X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Ffocus.c;h=197948e98c286c619a01cbd24036d16d45aac0d3;hb=939fbcfd31e07a6e0f1cdbfcef9b04f63e6af700;hp=b64d3e0071e4332feeff8b3fa25e4c83e04bd5a8;hpb=e4be1f860bc579fd4a0d9dee6a6ca590030a791e;p=chaz%2Fopenbox diff --git a/openbox/focus.c b/openbox/focus.c index b64d3e00..197948e9 100644 --- a/openbox/focus.c +++ b/openbox/focus.c @@ -1,3 +1,23 @@ +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + focus.c for the Openbox window manager + Copyright (c) 2006 Mikael Magnusson + 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + See the COPYING file for a copy of the GNU General Public License. +*/ + +#include "debug.h" #include "event.h" #include "openbox.h" #include "grab.h" @@ -8,75 +28,129 @@ #include "screen.h" #include "group.h" #include "prop.h" -#include "dispatch.h" #include "focus.h" #include "stacking.h" #include "popup.h" +#include "render/render.h" #include #include #include -ObClient *focus_client = NULL; -GList **focus_order = NULL; /* these lists are created when screen_startup - sets the number of desktops */ - -Window focus_backup = None; +ObClient *focus_client, *focus_hilite; +GList *focus_order; +ObClient *focus_cycle_target; -static ObClient *focus_cycle_target = NULL; -static Popup *focus_cycle_popup = NULL; +struct { + InternalWindow top; + InternalWindow left; + InternalWindow right; + InternalWindow bottom; +} focus_indicator; -void focus_startup() -{ - /* create the window which gets focus when no clients get it. Have to - make it override-redirect so we don't try manage it, since it is - mapped. */ - XSetWindowAttributes attrib; +RrAppearance *a_focus_indicator; +RrColor *color_white; - focus_client = NULL; +static ObIconPopup *focus_cycle_popup; - attrib.override_redirect = TRUE; - focus_backup = XCreateWindow(ob_display, ob_root, - -100, -100, 1, 1, 0, - CopyFromParent, InputOutput, CopyFromParent, - CWOverrideRedirect, &attrib); - XMapRaised(ob_display, focus_backup); +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); +} - /* do this *after* focus_backup is created, since it is used for - stacking */ - focus_cycle_popup = popup_new(TRUE); +static Window createWindow(Window parent, gulong mask, + XSetWindowAttributes *attrib) +{ + return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0, + RrDepth(ob_rr_inst), InputOutput, + RrVisual(ob_rr_inst), mask, attrib); + +} - /* start with nothing focused */ - focus_set_client(NULL); +void focus_startup(gboolean reconfig) +{ + focus_cycle_popup = icon_popup_new(TRUE); + + if (!reconfig) { + XSetWindowAttributes attr; + + client_add_destructor(focus_cycle_destructor, NULL); + + /* start with nothing focused */ + focus_set_client(NULL); + + focus_indicator.top.obwin.type = Window_Internal; + focus_indicator.left.obwin.type = Window_Internal; + focus_indicator.right.obwin.type = Window_Internal; + focus_indicator.bottom.obwin.type = Window_Internal; + + attr.override_redirect = True; + attr.background_pixel = BlackPixel(ob_display, ob_screen); + focus_indicator.top.win = + createWindow(RootWindow(ob_display, ob_screen), + CWOverrideRedirect | CWBackPixel, &attr); + focus_indicator.left.win = + createWindow(RootWindow(ob_display, ob_screen), + CWOverrideRedirect | CWBackPixel, &attr); + focus_indicator.right.win = + createWindow(RootWindow(ob_display, ob_screen), + CWOverrideRedirect | CWBackPixel, &attr); + focus_indicator.bottom.win = + createWindow(RootWindow(ob_display, ob_screen), + CWOverrideRedirect | CWBackPixel, &attr); + + stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.top)); + stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.left)); + stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.right)); + stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.bottom)); + + color_white = RrColorNew(ob_rr_inst, 0xff, 0xff, 0xff); + + a_focus_indicator = RrAppearanceNew(ob_rr_inst, 4); + a_focus_indicator->surface.grad = RR_SURFACE_SOLID; + a_focus_indicator->surface.relief = RR_RELIEF_FLAT; + a_focus_indicator->surface.primary = RrColorNew(ob_rr_inst, + 0, 0, 0); + a_focus_indicator->texture[0].type = RR_TEXTURE_LINE_ART; + a_focus_indicator->texture[0].data.lineart.color = color_white; + a_focus_indicator->texture[1].type = RR_TEXTURE_LINE_ART; + a_focus_indicator->texture[1].data.lineart.color = color_white; + a_focus_indicator->texture[2].type = RR_TEXTURE_LINE_ART; + a_focus_indicator->texture[2].data.lineart.color = color_white; + a_focus_indicator->texture[3].type = RR_TEXTURE_LINE_ART; + a_focus_indicator->texture[3].data.lineart.color = color_white; + } } -void focus_shutdown() +void focus_shutdown(gboolean reconfig) { - guint i; + icon_popup_free(focus_cycle_popup); - for (i = 0; i < screen_num_desktops; ++i) - g_list_free(focus_order[i]); - g_free(focus_order); - focus_order = NULL; + if (!reconfig) { + client_remove_destructor(focus_cycle_destructor); - popup_free(focus_cycle_popup); - focus_cycle_popup = NULL; + /* reset focus to root */ + XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime); - XDestroyWindow(ob_display, focus_backup); + RrColorFree(color_white); - /* reset focus to root */ - XSetInputFocus(ob_display, PointerRoot, RevertToPointerRoot, - event_lasttime); + RrAppearanceFree(a_focus_indicator); + + XDestroyWindow(ob_display, focus_indicator.top.win); + XDestroyWindow(ob_display, focus_indicator.left.win); + XDestroyWindow(ob_display, focus_indicator.right.win); + XDestroyWindow(ob_display, focus_indicator.bottom.win); + } } 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) @@ -84,24 +158,27 @@ void focus_set_client(ObClient *client) Window active; ObClient *old; -#ifdef DEBUG_FOCUS - g_message("focus_set_client 0x%lx", 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) { - /* when nothing will be focused, send focus to the backup target */ - XSetInputFocus(ob_display, focus_backup, RevertToPointerRoot, - event_lasttime); + ob_debug_type(OB_DEBUG_FOCUS, "actively focusing NONWINDOW\n"); + + /* 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. */ + /* 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); + focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); old = focus_client; focus_client = client; @@ -111,72 +188,92 @@ void focus_set_client(ObClient *client) push_to_top(client); /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */ - if (ob_state != OB_STATE_EXITING) { + if (ob_state() != OB_STATE_EXITING) { active = client ? client->window : None; - PROP_SET32(ob_root, net_active_window, window, active); - } + PROP_SET32(RootWindow(ob_display, ob_screen), + net_active_window, window, active); - if (focus_client != NULL) - dispatch_client(Event_Client_Focus, focus_client, 0, 0); - if (old != NULL) - dispatch_client(Event_Client_Unfocus, old, 0, 0); + /* remove hiliting from the window when it gets focused */ + if (client != NULL) + client_hilite(client, FALSE); + } } -static gboolean focus_under_pointer() +ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old) { - int x, y; GList *it; + ObClient *target = NULL; + ObClient *desktop = NULL; + + ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff\n"); + if (config_focus_follow && !config_focus_last) + { + if ((target = client_under_pointer())) + 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 (ob_pointer_pos(&x, &y)) { - for (it = stacking_list; it != NULL; it = it->next) { - if (WINDOW_IS_CLIENT(it->data)) { - ObClient *c = WINDOW_AS_CLIENT(it->data); - if (c->desktop == screen_desktop && - RECT_CONTAINS(c->frame->area, x, y)) - break; - } - } - if (it != NULL) { - g_assert(WINDOW_IS_CLIENT(it->data)); - return client_normal(it->data) && client_focus(it->data); +#if 0 + /* try for group relations */ + if (old->group) { + GSList *sit; + + for (it = focus_order[screen_desktop]; it; it = g_list_next(it)) + for (sit = old->group->members; sit; sit = g_slist_next(sit)) + if (sit->data == it->data) + if (sit->data != old && client_normal(sit->data)) + if (client_can_focus(sit->data)) + return sit->data; } - } - return FALSE; -} +#endif -/* 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 = it->next) { - 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; -} + ob_debug_type(OB_DEBUG_FOCUS, "trying omnipresentness\n"); + if (allow_refocus && old && old->desktop == DESKTOP_ALL) + 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 + 2. it is validated. if the window is about to disappear, then + don't try focus it. + 3. it is visible on the current desktop. this ignores + omnipresent windows, which are problematic in their own rite. + 4. it's not iconic + 5. 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) && c->desktop == screen_desktop && + !c->iconic) + { + if (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) + desktop = c; + } + } -static gboolean 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 FALSE; - target = top; /* no transient, keep the top */ - } - return client_focus(target); + /* 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 desktop; } -void focus_fallback(FallbackType type) +void focus_fallback(gboolean allow_refocus) { - GList *it; - ObClient *old = NULL; + ObClient *new; + ObClient *old; + /* save this before moving focus away to nothing */ old = focus_client; /* unfocus any focused clients.. they can be focused by Pointer events @@ -185,129 +282,246 @@ void focus_fallback(FallbackType type) */ focus_set_client(NULL); - if (!(type == Fallback_Desktop ? - config_focus_last_on_desktop : config_focus_last)) { - if (config_focus_follow) focus_under_pointer(); - return; - } - - if (type == Fallback_Unfocusing && old) { - /* try for transient relations */ - if (old->transient_for) { - if (old->transient_for == OB_TRAN_GROUP) { - for (it = focus_order[screen_desktop]; it; it = it->next) { - GSList *sit; - - for (sit = old->group->members; sit; sit = sit->next) - if (sit->data == it->data) - if (focus_fallback_transient(sit->data, old)) - return; - } - } else { - if (focus_fallback_transient(old->transient_for, old)) - return; - } - } - - /* try for group relations */ - if (old->group) { - GSList *sit; - - for (it = focus_order[screen_desktop]; it != NULL; it = it->next) - for (sit = old->group->members; sit; sit = sit->next) - if (sit->data == it->data) - if (sit->data != old && client_normal(sit->data)) - if (client_can_focus(sit->data)) { - gboolean r = client_focus(sit->data); - assert(r); - return; - } - } - } - - for (it = focus_order[screen_desktop]; it != NULL; it = it->next) - if (type != Fallback_Unfocusing || it->data != old) - if (client_normal(it->data) && - /* dont fall back to 'anonymous' fullscreen windows. theres no - checks for this is in transient/group fallbacks, so they can - be fallback targets there. */ - !((ObClient*)it->data)->fullscreen && - client_can_focus(it->data)) { - gboolean r = client_focus(it->data); - assert(r); - return; - } - - /* nothing to focus, and already set it to none above */ + if ((new = focus_fallback_target(allow_refocus, old))) + client_focus(new); } static void popup_cycle(ObClient *c, gboolean show) { if (!show) { - popup_hide(focus_cycle_popup); + icon_popup_hide(focus_cycle_popup); } else { Rect *a; ObClient *p = c; - char *title; + gchar *title = NULL; a = screen_physical_area_monitor(0); - popup_position(focus_cycle_popup, CenterGravity, - a->x + a->width / 2, a->y + a->height / 2); -/* popup_size(focus_cycle_popup, a->height/2, a->height/16); - popup_show(focus_cycle_popup, c->title, - client_icon(c, a->height/16, a->height/16)); + 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 */ - popup_size(focus_cycle_popup, 320, 48); + 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) - title = NULL; - else - title = g_strconcat((c->iconic ? c->icon_title : c->title), + 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); - - popup_show(focus_cycle_popup, - (title ? title : (c->iconic ? c->icon_title : c->title)), - client_icon(p, 48, 48)); + */ + icon_popup_show(focus_cycle_popup, + (title ? title : + (c->iconic ? c->icon_title : c->title)), + client_icon(p, 48, 48)); g_free(title); } } -ObClient *focus_cycle(gboolean forward, gboolean linear, gboolean done, - gboolean cancel) +void focus_cycle_draw_indicator() +{ + if (!focus_cycle_target) { + XUnmapWindow(ob_display, focus_indicator.top.win); + XUnmapWindow(ob_display, focus_indicator.left.win); + XUnmapWindow(ob_display, focus_indicator.right.win); + XUnmapWindow(ob_display, focus_indicator.bottom.win); + } else { + /* + if (focus_cycle_target) + frame_adjust_focus(focus_cycle_target->frame, FALSE); + frame_adjust_focus(focus_cycle_target->frame, TRUE); + */ + 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); + + x = focus_cycle_target->frame->area.x; + y = focus_cycle_target->frame->area.y; + w = focus_cycle_target->frame->area.width; + h = wt; + + XMoveResizeWindow(ob_display, focus_indicator.top.win, + x, y, w, h); + a_focus_indicator->texture[0].data.lineart.x1 = 0; + a_focus_indicator->texture[0].data.lineart.y1 = h-1; + a_focus_indicator->texture[0].data.lineart.x2 = 0; + a_focus_indicator->texture[0].data.lineart.y2 = 0; + a_focus_indicator->texture[1].data.lineart.x1 = 0; + a_focus_indicator->texture[1].data.lineart.y1 = 0; + a_focus_indicator->texture[1].data.lineart.x2 = w-1; + a_focus_indicator->texture[1].data.lineart.y2 = 0; + a_focus_indicator->texture[2].data.lineart.x1 = w-1; + a_focus_indicator->texture[2].data.lineart.y1 = 0; + a_focus_indicator->texture[2].data.lineart.x2 = w-1; + a_focus_indicator->texture[2].data.lineart.y2 = h-1; + a_focus_indicator->texture[3].data.lineart.x1 = (wl-1); + a_focus_indicator->texture[3].data.lineart.y1 = h-1; + a_focus_indicator->texture[3].data.lineart.x2 = w - wr; + a_focus_indicator->texture[3].data.lineart.y2 = h-1; + RrPaint(a_focus_indicator, focus_indicator.top.win, + w, h); + + x = focus_cycle_target->frame->area.x; + y = focus_cycle_target->frame->area.y; + w = wl; + h = focus_cycle_target->frame->area.height; + + XMoveResizeWindow(ob_display, focus_indicator.left.win, + x, y, w, h); + a_focus_indicator->texture[0].data.lineart.x1 = w-1; + a_focus_indicator->texture[0].data.lineart.y1 = 0; + a_focus_indicator->texture[0].data.lineart.x2 = 0; + a_focus_indicator->texture[0].data.lineart.y2 = 0; + a_focus_indicator->texture[1].data.lineart.x1 = 0; + a_focus_indicator->texture[1].data.lineart.y1 = 0; + a_focus_indicator->texture[1].data.lineart.x2 = 0; + a_focus_indicator->texture[1].data.lineart.y2 = h-1; + a_focus_indicator->texture[2].data.lineart.x1 = 0; + a_focus_indicator->texture[2].data.lineart.y1 = h-1; + a_focus_indicator->texture[2].data.lineart.x2 = w-1; + a_focus_indicator->texture[2].data.lineart.y2 = h-1; + a_focus_indicator->texture[3].data.lineart.x1 = w-1; + a_focus_indicator->texture[3].data.lineart.y1 = wt-1; + a_focus_indicator->texture[3].data.lineart.x2 = w-1; + a_focus_indicator->texture[3].data.lineart.y2 = h - wb; + RrPaint(a_focus_indicator, focus_indicator.left.win, + w, h); + + x = focus_cycle_target->frame->area.x + + focus_cycle_target->frame->area.width - wr; + y = focus_cycle_target->frame->area.y; + w = wr; + h = focus_cycle_target->frame->area.height ; + + XMoveResizeWindow(ob_display, focus_indicator.right.win, + x, y, w, h); + a_focus_indicator->texture[0].data.lineart.x1 = 0; + a_focus_indicator->texture[0].data.lineart.y1 = 0; + a_focus_indicator->texture[0].data.lineart.x2 = w-1; + a_focus_indicator->texture[0].data.lineart.y2 = 0; + a_focus_indicator->texture[1].data.lineart.x1 = w-1; + a_focus_indicator->texture[1].data.lineart.y1 = 0; + a_focus_indicator->texture[1].data.lineart.x2 = w-1; + a_focus_indicator->texture[1].data.lineart.y2 = h-1; + a_focus_indicator->texture[2].data.lineart.x1 = w-1; + a_focus_indicator->texture[2].data.lineart.y1 = h-1; + a_focus_indicator->texture[2].data.lineart.x2 = 0; + a_focus_indicator->texture[2].data.lineart.y2 = h-1; + a_focus_indicator->texture[3].data.lineart.x1 = 0; + a_focus_indicator->texture[3].data.lineart.y1 = wt-1; + a_focus_indicator->texture[3].data.lineart.x2 = 0; + a_focus_indicator->texture[3].data.lineart.y2 = h - wb; + RrPaint(a_focus_indicator, focus_indicator.right.win, + w, h); + + x = focus_cycle_target->frame->area.x; + y = focus_cycle_target->frame->area.y + + focus_cycle_target->frame->area.height - wb; + w = focus_cycle_target->frame->area.width; + h = wb; + + XMoveResizeWindow(ob_display, focus_indicator.bottom.win, + x, y, w, h); + a_focus_indicator->texture[0].data.lineart.x1 = 0; + a_focus_indicator->texture[0].data.lineart.y1 = 0; + a_focus_indicator->texture[0].data.lineart.x2 = 0; + a_focus_indicator->texture[0].data.lineart.y2 = h-1; + a_focus_indicator->texture[1].data.lineart.x1 = 0; + a_focus_indicator->texture[1].data.lineart.y1 = h-1; + a_focus_indicator->texture[1].data.lineart.x2 = w-1; + a_focus_indicator->texture[1].data.lineart.y2 = h-1; + a_focus_indicator->texture[2].data.lineart.x1 = w-1; + a_focus_indicator->texture[2].data.lineart.y1 = h-1; + a_focus_indicator->texture[2].data.lineart.x2 = w-1; + a_focus_indicator->texture[2].data.lineart.y2 = 0; + a_focus_indicator->texture[3].data.lineart.x1 = wl-1; + a_focus_indicator->texture[3].data.lineart.y1 = 0; + a_focus_indicator->texture[3].data.lineart.x2 = w - wr; + a_focus_indicator->texture[3].data.lineart.y2 = 0; + RrPaint(a_focus_indicator, focus_indicator.bottom.win, + w, h); + + XMapWindow(ob_display, focus_indicator.top.win); + XMapWindow(ob_display, focus_indicator.left.win); + XMapWindow(ob_display, focus_indicator.right.win); + XMapWindow(ob_display, focus_indicator.bottom.win); + } +} + +static gboolean valid_focus_target(ObClient *ft) +{ + /* 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; + + for (it = ft->transients; it; it = g_slist_next(it)) { + ObClient *c = it->data; + + if (c->frame->visible) + return FALSE; + } + return TRUE; + } +*/ + + return FALSE; +} + +void focus_cycle(gboolean forward, gboolean linear, gboolean interactive, + gboolean dialog, gboolean done, gboolean cancel) { static ObClient *first = NULL; static ObClient *t = NULL; static GList *order = NULL; GList *it, *start, *list; - ObClient *ft; + ObClient *ft = NULL; - if (cancel) { - if (focus_cycle_target) - frame_adjust_focus(focus_cycle_target->frame, FALSE); - if (focus_client) - frame_adjust_focus(focus_client->frame, TRUE); - goto done_cycle; - } else if (done) { - if (focus_cycle_target) - client_activate(focus_cycle_target); - goto done_cycle; - } - if (!first) - grab_pointer(TRUE, None); + if (interactive) { + if (cancel) { + focus_cycle_target = NULL; + goto done_cycle; + } else if (done) + goto done_cycle; - if (!first) first = focus_client; - if (!focus_cycle_target) focus_cycle_target = focus_client; + if (!focus_order) + goto done_cycle; + + if (!first) first = focus_client; - if (linear) list = client_list; - else list = focus_order[screen_desktop]; + if (linear) list = client_list; + else list = focus_order; + } else { + if (!focus_order) + goto done_cycle; + list = client_list; + } + if (!focus_cycle_target) focus_cycle_target = focus_client; start = it = g_list_find(list, focus_cycle_target); if (!start) /* switched desktops or something? */ @@ -322,124 +536,155 @@ ObClient *focus_cycle(gboolean forward, gboolean linear, gboolean done, it = it->prev; if (it == NULL) it = g_list_last(list); } - /*ft = client_focus_target(it->data);*/ ft = it->data; - /* 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->transients == NULL && client_normal(ft) && - ((ft->can_focus || ft->focus_notify) && - (ft->desktop == screen_desktop || ft->desktop == DESKTOP_ALL))) { - if (ft != focus_cycle_target) { /* prevents flicker */ - if (focus_cycle_target) - frame_adjust_focus(focus_cycle_target->frame, FALSE); + if (valid_focus_target(ft)) { + if (interactive) { + if (ft != focus_cycle_target) { /* prevents flicker */ + focus_cycle_target = ft; + focus_cycle_draw_indicator(); + } + popup_cycle(ft, dialog); + return; + } else if (ft != focus_cycle_target) { focus_cycle_target = ft; - frame_adjust_focus(focus_cycle_target->frame, TRUE); + done = TRUE; + break; } - popup_cycle(ft, config_focus_popup); - return ft; } } while (it != start); done_cycle: + if (done && focus_cycle_target) + client_activate(focus_cycle_target, FALSE, TRUE); + t = NULL; first = NULL; focus_cycle_target = NULL; g_list_free(order); order = NULL; + if (interactive) { + focus_cycle_draw_indicator(); + popup_cycle(ft, FALSE); + } + + return; +} + +void focus_directional_cycle(ObDirection dir, gboolean interactive, + gboolean dialog, gboolean done, gboolean cancel) +{ + static ObClient *first = NULL; + ObClient *ft = NULL; + + if (!interactive) + return; + + if (cancel) { + focus_cycle_target = NULL; + goto done_cycle; + } else if (done) + goto done_cycle; + + 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); + else { + GList *it; + + for (it = focus_order; it; it = g_list_next(it)) + if (valid_focus_target(it->data)) + ft = it->data; + } + + if (ft) { + if (ft != focus_cycle_target) {/* prevents flicker */ + focus_cycle_target = ft; + focus_cycle_draw_indicator(); + } + } + if (focus_cycle_target) { + popup_cycle(focus_cycle_target, dialog); + if (dialog) + return; + } + + +done_cycle: + if (done && focus_cycle_target) + client_activate(focus_cycle_target, FALSE, TRUE); + + first = NULL; + focus_cycle_target = NULL; + + focus_cycle_draw_indicator(); popup_cycle(ft, FALSE); - grab_pointer(FALSE, None); - return NULL; + 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) { - 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 - 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]; - it && !((ObClient*)it->data)->iconic; it = it->next); - g_list_insert_before(focus_order[d], it, c); + for (it = focus_order; + it && !((ObClient*)it->data)->iconic; it = g_list_next(it)); + 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]; - it && !((ObClient*)it->data)->iconic; it = it->next); - g_list_insert_before(focus_order[d], it, c); + for (it = focus_order; + it && !((ObClient*)it->data)->iconic; it = g_list_next(it)); + 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; }