#include "grab.h"
#include "prompt.h"
#include "focus.h"
+#include "focus_cycle.h"
#include "stacking.h"
#include "openbox.h"
#include "group.h"
XFree(hints);
}
+
+ focus_cycle_addremove(self, TRUE);
}
void client_update_title(ObClient *self)
self->iconic = iconic;
/* update the focus lists.. iconic windows go to the bottom of
- the list */
+ the list. this will also call focus_cycle_addremove(). */
focus_order_to_bottom(self);
changed = TRUE;
self->desktop != DESKTOP_ALL)
client_set_desktop(self, screen_desktop, FALSE, FALSE);
- /* this puts it after the current focused window */
- focus_order_remove(self);
- focus_order_add_new(self);
+ /* this puts it after the current focused window, this will
+ also cause focus_cycle_addremove() to be called for the
+ client */
+ focus_order_like_new(self);
changed = TRUE;
}
/* the new desktop's geometry may be different, so we may need to
resize, for example if we are maximized */
client_reconfigure(self, FALSE);
+
+ focus_cycle_addremove(self, FALSE);
}
/* move all transients */
{
self = client_search_top_direct_parent(self);
client_set_desktop_recursive(self, target, donthide, dontraise);
+
+ focus_cycle_addremove(NULL, TRUE);
}
gboolean client_is_direct_child(ObClient *parent, ObClient *child)
client_hilite(self, demands_attention);
client_change_state(self); /* change the hint to reflect these changes */
+
+ focus_cycle_addremove(self, TRUE);
}
ObClient *client_focus_target(ObClient *self)
push_to_top(client);
/* remove hiliting from the window when it gets focused */
client_hilite(client, FALSE);
+
+ /* make sure the focus cycle popup shows things in the right order */
+ focus_cycle_reorder();
}
/* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
PROP_SET32(RootWindow(ob_display, ob_screen),
net_active_window, window, active);
}
-
- /* make sure the focus cycle popup shows things in the right order */
- focus_cycle_reorder();
}
static ObClient* focus_fallback_target(gboolean allow_refocus,
focus_order_to_top(c);
else {
g_assert(!g_list_find(focus_order, c));
- /* if there are any iconic windows, put this above them in the order,
+ /* if there are only 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);
focus_order = g_list_insert(focus_order, c, 1);
}
- focus_cycle_add(c);
+ focus_cycle_addremove(c, TRUE);
}
void focus_order_remove(ObClient *c)
{
focus_order = g_list_remove(focus_order, c);
- focus_cycle_remove(c);
+ focus_cycle_addremove(c, TRUE);
+}
+
+void focus_order_like_new(struct _ObClient *c)
+{
+ focus_order = g_list_remove(focus_order, c);
+ focus_order_add_new(c);
}
void focus_order_to_top(ObClient *c)
it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
focus_order = g_list_insert_before(focus_order, it, c);
}
+
+ focus_cycle_reorder();
}
void focus_order_to_bottom(ObClient *c)
it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
focus_order = g_list_insert_before(focus_order, it, c);
}
+
+ focus_cycle_reorder();
}
ObClient *focus_order_find_first(guint desktop)
gboolean desktop_windows,
gboolean user_request)
{
+ /* NOTE: if any of these things change on a client, then they should call
+ focus_cycle_addremove() to make sure the client is not shown/hidden
+ when it should not be */
+
gboolean ok = FALSE;
/* see if the window is still managed or is going away */
/*! Move a client to the top of the focus order */
void focus_order_to_top(struct _ObClient *c);
+/*! Move a client to where it would be if it was newly added to the focus order
+ */
+void focus_order_like_new(struct _ObClient *c);
+
/*! Move a client to the bottom of the focus order (keeps iconic windows at the
very bottom always though). */
void focus_order_to_bottom(struct _ObClient *c);
#include <X11/Xlib.h>
#include <glib.h>
+typedef enum {
+ OB_CYCLE_NONE = 0,
+ OB_CYCLE_NORMAL,
+ OB_CYCLE_DIRECTIONAL
+} ObCycleType;
+
ObClient *focus_cycle_target = NULL;
-static gboolean focus_cycle_directional = FALSE;
+static ObCycleType focus_cycle_type = OB_CYCLE_NONE;
static gboolean focus_cycle_iconic_windows;
static gboolean focus_cycle_all_desktops;
static gboolean focus_cycle_dock_windows;
if (reconfig) return;
}
-void focus_cycle_add(ObClient *ifclient)
-{
- if (!(focus_cycle_target && ifclient && !focus_cycle_directional))
- return;
-
- if (focus_valid_target(ifclient, TRUE,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows,
- FALSE))
- focus_cycle_popup_refresh(focus_cycle_target,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows);
-}
-
-void focus_cycle_remove(ObClient *ifclient)
+void focus_cycle_addremove(ObClient *c, gboolean redraw)
{
- if (!(focus_cycle_target && ifclient))
+ if (!focus_cycle_type)
return;
- if (focus_cycle_directional) {
- if (focus_cycle_target == ifclient) {
+ if (focus_cycle_type == OB_CYCLE_DIRECTIONAL) {
+ if (c && focus_cycle_target == c) {
focus_directional_cycle(0, TRUE, TRUE, TRUE, TRUE,
TRUE, TRUE, TRUE);
}
}
- else {
- if (!focus_valid_target(ifclient, TRUE,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows,
- FALSE)) {
- if (focus_cycle_target == ifclient) {
- focus_cycle_target =
- focus_cycle_popup_revert(focus_cycle_target);
- focus_cycle_update_indicator(focus_cycle_target);
- }
- focus_cycle_popup_refresh(focus_cycle_target,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows);
+ else if (c && redraw) {
+ gboolean v, s;
+
+ v = focus_cycle_valid(c);
+ s = focus_cycle_popup_is_showing(c);
+
+ if (v != s) {
+ focus_cycle_target =
+ focus_cycle_popup_refresh(focus_cycle_target, redraw);
}
}
+ else if (redraw) {
+ focus_cycle_reorder();
+ }
}
void focus_cycle_reorder()
{
- if (focus_cycle_target && !focus_cycle_directional)
- focus_cycle_popup_refresh(focus_cycle_target,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows);
+ if (focus_cycle_type == OB_CYCLE_NORMAL) {
+ focus_cycle_target = focus_cycle_popup_refresh(focus_cycle_target,
+ TRUE);
+ focus_cycle_update_indicator(focus_cycle_target);
+ if (!focus_cycle_target)
+ focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE,
+ TRUE, TRUE, TRUE, TRUE, TRUE);
+ }
}
ObClient* focus_cycle(gboolean forward, gboolean all_desktops,
if (interactive) {
if (cancel) {
focus_cycle_target = NULL;
- focus_cycle_directional = FALSE;
goto done_cycle;
} else if (done)
goto done_cycle;
if (it == NULL) it = g_list_last(list);
}
ft = it->data;
- if (focus_valid_target(ft, TRUE,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows,
- FALSE))
- {
+ if (focus_cycle_valid(ft)) {
if (interactive) {
if (ft != focus_cycle_target) { /* prevents flicker */
focus_cycle_target = ft;
- focus_cycle_directional = FALSE;
+ focus_cycle_type = OB_CYCLE_NORMAL;
focus_cycle_draw_indicator(showbar ? ft : NULL);
}
if (dialog)
return focus_cycle_target;
} else if (ft != focus_cycle_target) {
focus_cycle_target = ft;
- focus_cycle_directional = FALSE;
+ focus_cycle_type = OB_CYCLE_NORMAL;
done = TRUE;
break;
}
if (done && !cancel) ret = focus_cycle_target;
focus_cycle_target = NULL;
- focus_cycle_directional = FALSE;
+ focus_cycle_type = OB_CYCLE_NONE;
g_list_free(order);
order = NULL;
/* the currently selected window isn't interesting */
if (cur == c)
continue;
- if (!focus_valid_target(it->data, TRUE, FALSE, FALSE, dock_windows,
- desktop_windows, FALSE))
+ if (!focus_cycle_valid(it->data))
continue;
/* find the centre coords of this window, from the
if (cancel) {
focus_cycle_target = NULL;
- focus_cycle_directional = FALSE;
goto done_cycle;
} else if (done && interactive)
goto done_cycle;
GList *it;
for (it = focus_order; it; it = g_list_next(it))
- if (focus_valid_target(it->data, TRUE,
- focus_cycle_iconic_windows,
- focus_cycle_all_desktops,
- focus_cycle_dock_windows,
- focus_cycle_desktop_windows, FALSE))
+ if (focus_cycle_valid(it->data)) {
ft = it->data;
+ break;
+ }
}
if (ft && ft != focus_cycle_target) {/* prevents flicker */
focus_cycle_target = ft;
- focus_cycle_directional = TRUE;
+ focus_cycle_type = OB_CYCLE_DIRECTIONAL;
if (!interactive)
goto done_cycle;
focus_cycle_draw_indicator(showbar ? ft : NULL);
first = NULL;
focus_cycle_target = NULL;
- focus_cycle_directional = FALSE;
+ focus_cycle_type = OB_CYCLE_NONE;
focus_cycle_draw_indicator(NULL);
focus_cycle_popup_single_hide();
return ret;
}
+
+gboolean focus_cycle_valid(struct _ObClient *client)
+{
+ return focus_valid_target(client, TRUE,
+ focus_cycle_iconic_windows,
+ focus_cycle_all_desktops,
+ focus_cycle_dock_windows,
+ focus_cycle_desktop_windows,
+ FALSE);
+}
gboolean dialog,
gboolean done, gboolean cancel);
-void focus_cycle_add(struct _ObClient *ifclient);
-void focus_cycle_remove(struct _ObClient *ifclient);
+/*! Set @redraw to FALSE if there are more clients to be added/removed first */
+void focus_cycle_addremove(struct _ObClient *ifclient, gboolean redraw);
void focus_cycle_reorder();
+gboolean focus_cycle_valid(struct _ObClient *client);
+
#endif
*/
#include "focus_cycle_popup.h"
+#include "focus_cycle.h"
#include "popup.h"
#include "client.h"
#include "screen.h"
static gchar *popup_get_name (ObClient *c);
static gboolean popup_setup (ObFocusCyclePopup *p,
gboolean create_targets,
- gboolean refresh_targets,
- gboolean iconic_windows,
- gboolean all_desktops,
- gboolean dock_windows,
- gboolean desktop_windows);
+ gboolean refresh_targets);
static void popup_render (ObFocusCyclePopup *p,
const ObClient *c);
}
static gboolean popup_setup(ObFocusCyclePopup *p, gboolean create_targets,
- gboolean refresh_targets,
- gboolean iconic_windows, gboolean all_desktops,
- gboolean dock_windows, gboolean desktop_windows)
+ gboolean refresh_targets)
{
gint maxwidth, n;
GList *it;
for (it = g_list_last(focus_order); it; it = g_list_previous(it)) {
ObClient *ft = it->data;
- if (focus_valid_target(ft, TRUE,
- iconic_windows,
- all_desktops,
- dock_windows,
- desktop_windows,
- FALSE))
- {
+ if (focus_cycle_valid(ft)) {
GList *rit;
/* reuse the target if possible during refresh */
while (rtargets) {
popup_target_free(rtargets->data);
rtargets = g_list_delete_link(rtargets, rtargets);
-
- popup.targets = g_list_delete_link(popup.targets, popup.targets);
}
}
/* do this stuff only when the dialog is first showing */
if (!popup.mapped)
- popup_setup(&popup, TRUE, FALSE, iconic_windows, all_desktops,
- dock_windows, desktop_windows);
+ popup_setup(&popup, TRUE, FALSE);
g_assert(popup.targets != NULL);
popup_render(&popup, c);
if (!popup.mapped) {
Rect *a;
- popup_setup(&popup, FALSE, FALSE, iconic_windows, all_desktops,
- dock_windows, desktop_windows);
+ popup_setup(&popup, FALSE, FALSE);
g_assert(popup.targets == NULL);
/* position the popup */
icon_popup_hide(single_popup);
}
-GList* focus_cycle_popup_is_showing(ObClient *client)
+gboolean focus_cycle_popup_is_showing(ObClient *c)
{
if (popup.mapped) {
GList *it;
for (it = popup.targets; it; it = g_list_next(it)) {
ObFocusCyclePopupTarget *t = it->data;
- if (t->client == client)
- return it;
+ if (t->client == c)
+ return TRUE;
}
}
- return NULL;
+ return FALSE;
}
-ObClient* focus_cycle_popup_revert(ObClient *target)
+static ObClient* popup_revert(ObClient *target)
{
- GList *it;
-
- if (!popup.mapped) return NULL;
+ GList *it, *itt;
for (it = popup.targets; it; it = g_list_next(it)) {
ObFocusCyclePopupTarget *t = it->data;
if (t->client == target) {
- if (it->prev)
- return ((ObFocusCyclePopupTarget*)it->prev->data)->client;
- else if (it->next)
- return ((ObFocusCyclePopupTarget*)it->next->data)->client;
- else
- return NULL;
+ /* move to a previous window if possible */
+ for (itt = it->prev; itt; itt = g_list_previous(itt)) {
+ ObFocusCyclePopupTarget *t2 = it->data;
+ if (focus_cycle_valid(t2->client))
+ return t2->client;
+ }
+
+ /* otherwise move to a following window if possible */
+ for (itt = it->next; itt; itt = g_list_next(itt)) {
+ ObFocusCyclePopupTarget *t2 = it->data;
+ if (focus_cycle_valid(t2->client))
+ return t2->client;
+ }
+
+ /* otherwise, we can't go anywhere there is nowhere valid to go */
+ return NULL;
}
}
- g_assert_not_reached();
+ return NULL;
}
-void focus_cycle_popup_refresh(ObClient *target,
- gboolean iconic_windows,
- gboolean all_desktops,
- gboolean dock_windows,
- gboolean desktop_windows)
+ObClient* focus_cycle_popup_refresh(ObClient *target,
+ gboolean redraw)
{
- if (!popup.mapped) return;
+ if (!popup.mapped) return NULL;
- if (popup_setup(&popup, TRUE, TRUE, iconic_windows, all_desktops,
- dock_windows, desktop_windows))
- {
+ if (!focus_cycle_valid(target))
+ target = popup_revert(target);
+
+ redraw = popup_setup(&popup, TRUE, TRUE) && redraw;
+
+ if (!target && popup.targets)
+ target = ((ObFocusCyclePopupTarget*)popup.targets->data)->client;
+
+ if (target && redraw) {
popup.mapped = FALSE;
popup_render(&popup, target);
XFlush(ob_display);
popup.mapped = TRUE;
}
+
+ return target;
}
gboolean desktop_windows);
void focus_cycle_popup_single_hide();
-/*! Reverts from the current @target to a new focus cycle target window */
-struct _ObClient* focus_cycle_popup_revert(struct _ObClient *target);
-/*! Redraws the focus cycle popup */
-void focus_cycle_popup_refresh(struct _ObClient *target,
- gboolean iconic_windows,
- gboolean all_desktops,
- gboolean dock_windows,
- gboolean desktop_windows);
+gboolean focus_cycle_popup_is_showing(struct _ObClient *c);
+
+/*! Redraws the focus cycle popup, and returns the current target. If
+ the target given to the function is no longer valid, this will return
+ a different target that is valid, and which should be considered the
+ current focus cycling target. */
+struct _ObClient *focus_cycle_popup_refresh(struct _ObClient *target,
+ gboolean redraw);
#endif
for (it = stacking_list; it; it = g_list_next(it)) {
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = it->data;
- if (client_show(c))
- focus_cycle_add(c);
+ client_show(c);
}
}
if (WINDOW_IS_CLIENT(it->data)) {
ObClient *c = it->data;
if (client_hide(c)) {
- focus_cycle_remove(c);
-
if (c == focus_client) {
/* c was focused and we didn't do fallback clearly so make
sure openbox doesnt still consider the window focused.
}
}
+ focus_cycle_addremove(NULL, TRUE);
+
event_end_ignore_all_enters(ignore_start);
if (event_curtime != CurrentTime)
projects / dana / openbox.git / commitdiff