X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Ffocus.c;h=2c66336da39e3ca281647253e03f38b39610f424;hb=1d1aef75a0a4ab016243336fce0a69d00623caf8;hp=7b40db5e585bd1a512a2980afeb96fe2a797e668;hpb=d113b9f33fb7031add7026d123f34b31888d7411;p=chaz%2Fopenbox diff --git a/openbox/focus.c b/openbox/focus.c index 7b40db5e..2c66336d 100644 --- a/openbox/focus.c +++ b/openbox/focus.c @@ -2,7 +2,7 @@ focus.c for the Openbox window manager Copyright (c) 2006 Mikael Magnusson - Copyright (c) 2003 Ben Jansens + Copyright (c) 2003-2007 Dana Jansens This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -37,10 +37,11 @@ #include #include -ObClient *focus_client, *focus_hilite; -GList **focus_order; /* these lists are created when screen_startup - sets the number of desktops */ -ObClient *focus_cycle_target; +#define FOCUS_INDICATOR_WIDTH 6 + +ObClient *focus_client = NULL; +GList *focus_order = NULL; +ObClient *focus_cycle_target = NULL; struct { InternalWindow top; @@ -54,14 +55,11 @@ 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, CurrentTime); -} +static gboolean valid_focus_target(ObClient *ft, + gboolean all_desktops, + gboolean dock_windows, + gboolean desktop_windows); +static void focus_cycle_destructor(ObClient *client, gpointer data); static Window createWindow(Window parent, gulong mask, XSetWindowAttributes *attrib) @@ -82,7 +80,7 @@ void focus_startup(gboolean reconfig) client_add_destructor(focus_cycle_destructor, NULL); /* start with nothing focused */ - focus_set_client(NULL); + focus_nothing(); focus_indicator.top.obwin.type = Window_Internal; focus_indicator.left.obwin.type = Window_Internal; @@ -129,17 +127,11 @@ void focus_startup(gboolean reconfig) void focus_shutdown(gboolean reconfig) { - guint i; - icon_popup_free(focus_cycle_popup); if (!reconfig) { client_remove_destructor(focus_cycle_destructor); - for (i = 0; i < screen_num_desktops; ++i) - g_list_free(focus_order[i]); - g_free(focus_order); - /* reset focus to root */ XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime); @@ -156,152 +148,59 @@ void focus_shutdown(gboolean reconfig) static void push_to_top(ObClient *client) { - guint desktop; - - desktop = client->desktop; - if (desktop == DESKTOP_ALL) desktop = screen_desktop; - focus_order[desktop] = g_list_remove(focus_order[desktop], client); - focus_order[desktop] = g_list_prepend(focus_order[desktop], client); + focus_order = g_list_remove(focus_order, client); + focus_order = g_list_prepend(focus_order, client); } void focus_set_client(ObClient *client) { Window active; - ObClient *old; -#ifdef DEBUG_FOCUS - ob_debug("focus_set_client 0x%lx\n", client ? client->window : 0); -#endif + ob_debug_type(OB_DEBUG_FOCUS, + "focus_set_client 0x%lx\n", client ? client->window : 0); /* uninstall the old colormap, and install the new one */ screen_install_colormap(focus_client, FALSE); screen_install_colormap(client, TRUE); - if (client == NULL) { -#ifdef DEBUG_FOCUS - ob_debug("actively focusing NONWINDOW\n"); -#endif - /* when nothing will be focused, send focus to the backup target */ - XSetInputFocus(ob_display, screen_support_win, RevertToNone, - event_curtime); - XSync(ob_display, FALSE); - } - /* in the middle of cycling..? kill it. CurrentTime is fine, time won't be used. */ if (focus_cycle_target) - focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, CurrentTime); + focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); - old = focus_client; focus_client = client; - /* move to the top of the list */ - if (client != NULL) + if (client != NULL) { + /* move to the top of the list */ push_to_top(client); + /* remove hiliting from the window when it gets focused */ + client_hilite(client, FALSE); + } /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */ if (ob_state() != OB_STATE_EXITING) { active = client ? client->window : None; PROP_SET32(RootWindow(ob_display, ob_screen), net_active_window, window, active); - - /* remove hiliting from the window when it gets focused */ - if (client != NULL) - client_hilite(client, FALSE); } } -/* finds the first transient that isn't 'skip' and ensure's that client_normal - is true for it */ -static ObClient *find_transient_recursive(ObClient *c, ObClient *top, - ObClient *skip) -{ - GSList *it; - ObClient *ret; - - for (it = c->transients; it; it = g_slist_next(it)) { - if (it->data == top) return NULL; - ret = find_transient_recursive(it->data, top, skip); - if (ret && ret != skip && client_normal(ret)) return ret; - if (it->data != skip && client_normal(it->data)) return it->data; - } - return NULL; -} - -static ObClient* focus_fallback_transient(ObClient *top, ObClient *old) -{ - ObClient *target = find_transient_recursive(top, top, old); - if (!target) { - /* make sure client_normal is true always */ - if (!client_normal(top)) - return NULL; - target = top; /* no transient, keep the top */ - } - if (client_can_focus(target)) - return target; - else - return NULL; -} - -ObClient* focus_fallback_target(ObFocusFallbackType type, ObClient *old) +ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old) { GList *it; ObClient *target = NULL; + ObClient *desktop = NULL; - if ((type == OB_FOCUS_FALLBACK_UNFOCUSING - || type == OB_FOCUS_FALLBACK_CLOSED) && old) { - if (old->transient_for) { - gboolean trans = FALSE; - - if (!config_focus_follow || config_focus_last) - trans = TRUE; - else if ((target = client_under_pointer()) && - (client_search_transient - (client_search_top_parent(target), old))) - trans = TRUE; - - /* try for transient relations */ - if (trans) { - if (old->transient_for == OB_TRAN_GROUP) { - for (it = focus_order[screen_desktop]; it; - it = g_list_next(it)) - { - GSList *sit; - - for (sit = old->group->members; sit; - sit = g_slist_next(sit)) - { - if (sit->data == it->data) - if ((target = - focus_fallback_transient(sit->data, old))) - { - ob_debug("found in transient #1\n"); - return target; - } - } - } - } else { - if ((target = - focus_fallback_transient(old->transient_for, old))) - { - ob_debug("found in transient #2\n"); - return target; - } - } - } - } - } - - ob_debug("trying pointer stuff\n"); - if (config_focus_follow && - (type == OB_FOCUS_FALLBACK_UNFOCUSING || !config_focus_last)) + ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff\n"); + if (config_focus_follow && !config_focus_last) { if ((target = client_under_pointer())) - if (client_normal(target) && client_can_focus(target)) { - ob_debug("found in pointer stuff\n"); - return target; - } + if (allow_refocus || target != old) + if (client_normal(target) && client_can_focus(target)) { + ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff\n"); + return target; + } } #if 0 @@ -318,23 +217,46 @@ ObClient* focus_fallback_target(ObFocusFallbackType type, ObClient *old) } #endif - ob_debug("trying the focus order\n"); - for (it = focus_order[screen_desktop]; it; it = g_list_next(it)) - if (type != OB_FOCUS_FALLBACK_UNFOCUSING || it->data != old) - if (client_normal(it->data) && client_can_focus(it->data)) { - ob_debug("found in focus order\n"); - return it->data; + ob_debug_type(OB_DEBUG_FOCUS, "trying omnipresentness\n"); + if (allow_refocus && old && old->desktop == DESKTOP_ALL && + client_normal(old)) + { + return old; + } + + + 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; + /* fallback focus to a window if: + 1. it is actually focusable, cuz if it's not then we're sending + focus off to nothing. this includes if it is visible right now + 2. it is on the current desktop. this ignores omnipresent + windows, which are problematic in their own rite. + 3. it is a normal type window, don't fall back onto a dock or + a splashscreen or a desktop window (save the desktop as a + backup fallback though) + */ + if (client_can_focus(c)) + { + if (c->desktop == screen_desktop && client_normal(c)) { + ob_debug_type(OB_DEBUG_FOCUS, "found in focus order\n"); + return it->data; + } else if (c->type == OB_CLIENT_TYPE_DESKTOP && + desktop == NULL) + desktop = c; } + } - /* XXX fallback to the "desktop window" if one exists ? - could store it while going through all the windows in the loop right - above this.. + /* as a last resort fallback to the desktop window if there is one. + (if there's more than one, then the one most recently focused.) */ - - return NULL; + ob_debug_type(OB_DEBUG_FOCUS, "found desktop: \n", !!desktop); + return desktop; } -void focus_fallback(ObFocusFallbackType type) +ObClient* focus_fallback(gboolean allow_refocus) { ObClient *new; ObClient *old = focus_client; @@ -343,49 +265,140 @@ void focus_fallback(ObFocusFallbackType type) and such, and then when I try focus them, I won't get a FocusIn event at all for them. */ - focus_set_client(NULL); + focus_nothing(); - if ((new = focus_fallback_target(type, old))) + if ((new = focus_fallback_target(allow_refocus, old))) { client_focus(new); + return new; + } else + return NULL; } -static void popup_cycle(ObClient *c, gboolean show) +void focus_nothing() { + /* Install our own colormap */ + if (focus_client != NULL) { + screen_install_colormap(focus_client, FALSE); + screen_install_colormap(NULL, TRUE); + } + + focus_client = NULL; + + /* when nothing will be focused, send focus to the backup target */ + XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot, + event_curtime); +} + +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 = c; - gchar *title = 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_size(focus_cycle_popup, a->height/2, a->height/16); - icon_popup_show(focus_cycle_popup, c->title, - client_icon(c, a->height/16, a->height/16)); -*/ - /* XXX the size and the font extents need to be related on some level - */ - icon_popup_size(focus_cycle_popup, POPUP_WIDTH, POPUP_HEIGHT); - - /* use the transient's parent's title/icon */ - while (p->transient_for && p->transient_for != OB_TRAN_GROUP) - p = p->transient_for; - - if (p != c && !strcmp("", (c->iconic ? c->icon_title : c->title))) - title = g_strdup(p->iconic ? p->icon_title : p->title); - /*title = g_strconcat((c->iconic ? c->icon_title : c->title), - " - ", - (p->iconic ? p->icon_title : p->title), - NULL); - */ - icon_popup_show(focus_cycle_popup, - (title ? title : - (c->iconic ? c->icon_title : c->title)), - client_icon(p, 48, 48)); - g_free(title); + 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)); + + + /* make its width to be the width of all the possible titles */ + + /* 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_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_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, TRUE); } void focus_cycle_draw_indicator() @@ -395,6 +408,9 @@ void focus_cycle_draw_indicator() XUnmapWindow(ob_display, focus_indicator.left.win); XUnmapWindow(ob_display, focus_indicator.right.win); XUnmapWindow(ob_display, focus_indicator.bottom.win); + + /* kill enter events cause by this unmapping */ + event_ignore_queued_enters(); } else { /* if (focus_cycle_target) @@ -404,10 +420,7 @@ void focus_cycle_draw_indicator() gint x, y, w, h; gint wt, wl, wr, wb; - wt = wl = wr = wb = MAX(3, - MAX(1, MAX(ob_rr_theme->paddingx, - ob_rr_theme->paddingy)) * 2 + - ob_rr_theme->fbwidth * 2); + wt = wl = wr = wb = FOCUS_INDICATOR_WIDTH; x = focus_cycle_target->frame->area.x; y = focus_cycle_target->frame->area.y; @@ -522,42 +535,80 @@ void focus_cycle_draw_indicator() } } -static gboolean valid_focus_target(ObClient *ft) +static gboolean has_valid_group_siblings_on_desktop(ObClient *ft, + gboolean all_desktops) + { - /* 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 ((ft->type == OB_CLIENT_TYPE_NORMAL || - ft->type == OB_CLIENT_TYPE_DIALOG || - (!client_has_group_siblings(ft) && - (ft->type == OB_CLIENT_TYPE_TOOLBAR || - ft->type == OB_CLIENT_TYPE_MENU || - ft->type == OB_CLIENT_TYPE_UTILITY))) && - ((ft->can_focus || ft->focus_notify) && - !ft->skip_pager && - (ft->desktop == screen_desktop || ft->desktop == DESKTOP_ALL)) && - ft == client_focus_target(ft)) - return TRUE; -/* - { - GSList *it; + GSList *it; - for (it = ft->transients; it; it = g_slist_next(it)) { - ObClient *c = it->data; + if (!ft->group) return FALSE; - if (c->frame->visible) - 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 TRUE; } -*/ - return FALSE; } -void focus_cycle(gboolean forward, gboolean linear, gboolean interactive, - gboolean dialog, gboolean done, gboolean cancel, Time time) +/*! @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 desktop_windows) +{ + gboolean ok = FALSE; + + /* 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); + + /* 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_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); + + return ok; +} + +void focus_cycle(gboolean forward, gboolean all_desktops, + gboolean dock_windows, gboolean desktop_windows, + gboolean linear, gboolean interactive, + gboolean dialog, gboolean done, gboolean cancel) { static ObClient *first = NULL; static ObClient *t = NULL; @@ -572,15 +623,15 @@ void focus_cycle(gboolean forward, gboolean linear, gboolean interactive, } else if (done) goto done_cycle; - if (!focus_order[screen_desktop]) + if (!focus_order) goto done_cycle; if (!first) first = focus_client; if (linear) list = client_list; - else list = focus_order[screen_desktop]; + else list = focus_order; } else { - if (!focus_order[screen_desktop]) + if (!focus_order) goto done_cycle; list = client_list; } @@ -600,13 +651,17 @@ void focus_cycle(gboolean forward, gboolean linear, gboolean interactive, if (it == NULL) it = g_list_last(list); } ft = it->data; - if (valid_focus_target(ft)) { + 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; @@ -618,7 +673,7 @@ void focus_cycle(gboolean forward, gboolean linear, gboolean interactive, done_cycle: if (done && focus_cycle_target) - client_activate(focus_cycle_target, FALSE, TRUE, time); + client_activate(focus_cycle_target, FALSE, TRUE); t = NULL; first = NULL; @@ -628,15 +683,121 @@ done_cycle: if (interactive) { focus_cycle_draw_indicator(); - popup_cycle(ft, FALSE); + popup_cycle(ft, FALSE, FALSE, FALSE, FALSE); } return; } -void focus_directional_cycle(ObDirection dir, gboolean interactive, - gboolean dialog, gboolean done, gboolean cancel, - Time time) +/* this be mostly ripped from fvwm */ +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; + gint distance = 0; + gint score, best_score; + ObClient *best_client, *cur; + GList *it; + + if(!client_list) + return NULL; + + /* first, find the centre coords of the currently focused window */ + my_cx = c->frame->area.x + c->frame->area.width / 2; + my_cy = c->frame->area.y + c->frame->area.height / 2; + + best_score = -1; + best_client = NULL; + + for(it = g_list_first(client_list); it; it = g_list_next(it)) { + cur = it->data; + + /* the currently selected window isn't interesting */ + if(cur == c) + continue; + if (!dock_windows && !desktop_windows && !client_normal(cur)) + continue; + if (!(dock_windows && cur->type == OB_CLIENT_TYPE_DOCK) || + (desktop_windows && 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 + * side effects */ + if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL) + continue; + if(cur->iconic) + continue; + if(!(client_focus_target(cur) == cur && + client_can_focus(cur))) + continue; + + /* find the centre coords of this window, from the + * currently focused window's point of view */ + his_cx = (cur->frame->area.x - my_cx) + + cur->frame->area.width / 2; + his_cy = (cur->frame->area.y - my_cy) + + cur->frame->area.height / 2; + + if(dir == OB_DIRECTION_NORTHEAST || dir == OB_DIRECTION_SOUTHEAST || + dir == OB_DIRECTION_SOUTHWEST || dir == OB_DIRECTION_NORTHWEST) { + gint tx; + /* Rotate the diagonals 45 degrees counterclockwise. + * To do this, multiply the matrix /+h +h\ with the + * vector (x y). \-h +h/ + * h = sqrt(0.5). We can set h := 1 since absolute + * distance doesn't matter here. */ + tx = his_cx + his_cy; + his_cy = -his_cx + his_cy; + his_cx = tx; + } + + switch(dir) { + case OB_DIRECTION_NORTH: + case OB_DIRECTION_SOUTH: + case OB_DIRECTION_NORTHEAST: + case OB_DIRECTION_SOUTHWEST: + offset = (his_cx < 0) ? -his_cx : his_cx; + distance = ((dir == OB_DIRECTION_NORTH || + dir == OB_DIRECTION_NORTHEAST) ? + -his_cy : his_cy); + break; + case OB_DIRECTION_EAST: + case OB_DIRECTION_WEST: + case OB_DIRECTION_SOUTHEAST: + case OB_DIRECTION_NORTHWEST: + offset = (his_cy < 0) ? -his_cy : his_cy; + distance = ((dir == OB_DIRECTION_WEST || + dir == OB_DIRECTION_NORTHWEST) ? + -his_cx : his_cx); + break; + } + + /* the target must be in the requested direction */ + if(distance <= 0) + continue; + + /* Calculate score for this window. The smaller the better. */ + score = distance + offset; + + /* windows more than 45 degrees off the direction are + * heavily penalized and will only be chosen if nothing + * else within a million pixels */ + if(offset > distance) + score += 1000000; + + if(best_score == -1 || score < best_score) + best_client = cur, + best_score = score; + } + + return best_client; +} + +void focus_directional_cycle(ObDirection dir, gboolean dock_windows, + gboolean desktop_windows, gboolean interactive, + gboolean dialog, gboolean done, gboolean cancel) { static ObClient *first = NULL; ObClient *ft = NULL; @@ -650,19 +811,21 @@ void focus_directional_cycle(ObDirection dir, gboolean interactive, } else if (done) goto done_cycle; - if (!focus_order[screen_desktop]) + if (!focus_order) goto done_cycle; if (!first) first = focus_client; if (!focus_cycle_target) focus_cycle_target = focus_client; if (focus_cycle_target) - ft = client_find_directional(focus_cycle_target, dir); + ft = focus_find_directional(focus_cycle_target, dir, dock_windows, + desktop_windows); else { GList *it; - for (it = focus_order[screen_desktop]; it; it = g_list_next(it)) - if (valid_focus_target(it->data)) + for (it = focus_order; it; it = g_list_next(it)) + if (valid_focus_target(it->data, FALSE, dock_windows, + desktop_windows)) ft = it->data; } @@ -673,7 +836,9 @@ void focus_directional_cycle(ObDirection dir, gboolean interactive, } } 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; } @@ -681,105 +846,74 @@ void focus_directional_cycle(ObDirection dir, gboolean interactive, done_cycle: if (done && focus_cycle_target) - client_activate(focus_cycle_target, FALSE, TRUE, time); + client_activate(focus_cycle_target, FALSE, TRUE); first = NULL; focus_cycle_target = NULL; focus_cycle_draw_indicator(); - popup_cycle(ft, FALSE); + popup_cycle(ft, FALSE, FALSE, FALSE, FALSE); return; } void focus_order_add_new(ObClient *c) { - guint d, i; - if (c->iconic) focus_order_to_top(c); else { - d = c->desktop; - if (d == DESKTOP_ALL) { - for (i = 0; i < screen_num_desktops; ++i) { - g_assert(!g_list_find(focus_order[i], c)); - if (focus_order[i] && ((ObClient*)focus_order[i]->data)->iconic) - focus_order[i] = g_list_insert(focus_order[i], c, 0); - else - focus_order[i] = g_list_insert(focus_order[i], c, 1); - } - } else { - g_assert(!g_list_find(focus_order[d], c)); - if (focus_order[d] && ((ObClient*)focus_order[d]->data)->iconic) - focus_order[d] = g_list_insert(focus_order[d], c, 0); - else - focus_order[d] = g_list_insert(focus_order[d], c, 1); - } + g_assert(!g_list_find(focus_order, c)); + /* if there are any iconic windows, put this above them in the order, + but if there are not, then put it under the currently focused one */ + if (focus_order && ((ObClient*)focus_order->data)->iconic) + focus_order = g_list_insert(focus_order, c, 0); + else + focus_order = g_list_insert(focus_order, c, 1); } } void focus_order_remove(ObClient *c) { - guint d, i; - - d = c->desktop; - if (d == DESKTOP_ALL) { - for (i = 0; i < screen_num_desktops; ++i) - focus_order[i] = g_list_remove(focus_order[i], c); - } else - focus_order[d] = g_list_remove(focus_order[d], c); + focus_order = g_list_remove(focus_order, c); } -static void to_top(ObClient *c, guint d) +void focus_order_to_top(ObClient *c) { - focus_order[d] = g_list_remove(focus_order[d], c); + focus_order = g_list_remove(focus_order, c); if (!c->iconic) { - focus_order[d] = g_list_prepend(focus_order[d], c); + focus_order = g_list_prepend(focus_order, c); } else { GList *it; /* insert before first iconic window */ - for (it = focus_order[d]; + for (it = focus_order; it && !((ObClient*)it->data)->iconic; it = g_list_next(it)); - focus_order[d] = g_list_insert_before(focus_order[d], it, c); + focus_order = g_list_insert_before(focus_order, it, c); } } -void focus_order_to_top(ObClient *c) -{ - guint d, i; - - d = c->desktop; - if (d == DESKTOP_ALL) { - for (i = 0; i < screen_num_desktops; ++i) - to_top(c, i); - } else - to_top(c, d); -} - -static void to_bottom(ObClient *c, guint d) +void focus_order_to_bottom(ObClient *c) { - focus_order[d] = g_list_remove(focus_order[d], c); + focus_order = g_list_remove(focus_order, c); if (c->iconic) { - focus_order[d] = g_list_append(focus_order[d], c); + focus_order = g_list_append(focus_order, c); } else { GList *it; /* insert before first iconic window */ - for (it = focus_order[d]; + for (it = focus_order; it && !((ObClient*)it->data)->iconic; it = g_list_next(it)); - focus_order[d] = g_list_insert_before(focus_order[d], it, c); + focus_order = g_list_insert_before(focus_order, it, c); } } -void focus_order_to_bottom(ObClient *c) +ObClient *focus_order_find_first(guint desktop) { - guint d, i; - - d = c->desktop; - if (d == DESKTOP_ALL) { - for (i = 0; i < screen_num_desktops; ++i) - to_bottom(c, i); - } else - to_bottom(c, d); + GList *it; + for (it = focus_order; it; it = g_list_next(it)) { + ObClient *c = it->data; + if (c->desktop == desktop || c->desktop == DESKTOP_ALL) + return c; + } + return NULL; }