X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fstacking.c;h=58551b5da28d17474c294cb0f31b81e291207e7c;hb=HEAD;hp=075f13868b5e303cf10e231a1eacc6572eaf7ce6;hpb=e61ad3581fa4e640c32fb78408a17712a7155aa1;p=chaz%2Fopenbox diff --git a/openbox/stacking.c b/openbox/stacking.c index 075f1386..58551b5d 100644 --- a/openbox/stacking.c +++ b/openbox/stacking.c @@ -18,18 +18,24 @@ */ #include "openbox.h" -#include "prop.h" #include "screen.h" #include "focus.h" #include "client.h" #include "group.h" #include "frame.h" #include "window.h" +#include "event.h" #include "debug.h" +#include "obt/prop.h" GList *stacking_list = NULL; +GList *stacking_list_tail = NULL; +/*! When true, stacking changes will not be reflected on the screen. This is + to freeze the on-screen stacking order while a window is being temporarily + raised during focus cycling */ +static gboolean pause_changes = FALSE; -void stacking_set_list() +void stacking_set_list(void) { Window *windows = NULL; GList *it; @@ -50,8 +56,8 @@ void stacking_set_list() } } - PROP_SETA32(RootWindow(ob_display, ob_screen), - net_client_list_stacking, window, (gulong*)windows, i); + OBT_PROP_SETA32(obt_root(ob_screen), NET_CLIENT_LIST_STACKING, WINDOW, + (gulong*)windows, i); g_free(windows); } @@ -64,6 +70,8 @@ static void do_restack(GList *wins, GList *before) #ifdef DEBUG GList *next; + + g_assert(wins); /* pls only restack stuff in the same layer at a time */ for (it = wins; it; it = next) { next = g_list_next(it); @@ -99,12 +107,59 @@ static void do_restack(GList *wins, GList *before) } #endif - XRestackWindows(ob_display, win, i); + if (!pause_changes) + XRestackWindows(obt_display, win, i); g_free(win); stacking_set_list(); } +void stacking_temp_raise(ObWindow *window) +{ + Window win[2]; + GList *it; + gulong start; + + /* don't use this for internal windows..! it would lower them.. */ + g_assert(window_layer(window) < OB_STACKING_LAYER_INTERNAL); + + /* find the window to drop it underneath */ + win[0] = screen_support_win; + for (it = stacking_list; it; it = g_list_next(it)) { + ObWindow *w = it->data; + if (window_layer(w) >= OB_STACKING_LAYER_INTERNAL) + win[0] = window_top(w); + else + break; + } + + win[1] = window_top(window); + start = event_start_ignore_all_enters(); + XRestackWindows(obt_display, win, 2); + event_end_ignore_all_enters(start); + + pause_changes = TRUE; +} + +void stacking_restore(void) +{ + Window *win; + GList *it; + gint i; + gulong start; + + win = g_new(Window, g_list_length(stacking_list) + 1); + win[0] = screen_support_win; + for (i = 1, it = stacking_list; it; ++i, it = g_list_next(it)) + win[i] = window_top(it->data); + start = event_start_ignore_all_enters(); + XRestackWindows(obt_display, win, i); + event_end_ignore_all_enters(start); + g_free(win); + + pause_changes = FALSE; +} + static void do_raise(GList *wins) { GList *it; @@ -164,35 +219,19 @@ static void restack_windows(ObClient *selected, gboolean raise) GList *it, *last, *below, *above, *next; GList *wins = NULL; + GList *group_helpers = NULL; GList *group_modals = NULL; GList *group_trans = NULL; GList *modals = NULL; GList *trans = NULL; - if (!raise && selected->transient_for) { - GSList *top, *top_it; - GSList *top_reorder = NULL; - - /* if it's a transient lowering, lower its parents so that we can lower - this window, or it won't move */ - top = client_search_all_top_parents_layer(selected); - - /* that is, if it has any parents */ - if (!(top->data == selected && top->next == NULL)) { - /* go thru stacking list backwards so we can use g_slist_prepend */ - for (it = g_list_last(stacking_list); it && top; - it = g_list_previous(it)) - if ((top_it = g_slist_find(top, it->data))) { - top_reorder = g_slist_prepend(top_reorder, top_it->data); - top = g_slist_delete_link(top, top_it); - } - g_assert(top == NULL); + if (raise) { + ObClient *p; - /* call restack for each of these to lower them */ - for (top_it = top_reorder; top_it; top_it = g_slist_next(top_it)) - restack_windows(top_it->data, raise); - return; - } + /* if a window is modal for another single window, then raise it to the + top too, the same is done with the focus order */ + while (selected->modal && (p = client_direct_parent(selected))) + selected = p; } /* remove first so we can't run into ourself */ @@ -200,40 +239,57 @@ static void restack_windows(ObClient *selected, gboolean raise) g_assert(it); stacking_list = g_list_delete_link(stacking_list, it); - /* go from the bottom of the stacking list up */ - for (it = g_list_last(stacking_list); it; it = next) { - next = g_list_previous(it); + /* go from the bottom of the stacking list up. don't move any other windows + when lowering, we call this for each window independently */ + if (raise) { + for (it = g_list_last(stacking_list); it; it = next) { + next = g_list_previous(it); - if (WINDOW_IS_CLIENT(it->data)) { - ObClient *ch = it->data; + if (WINDOW_IS_CLIENT(it->data)) { + ObClient *ch = it->data; - /* only move windows in the same stacking layer */ - if (ch->layer == selected->layer && - client_search_transient(selected, ch)) - { - if (client_is_direct_child(selected, ch)) { - if (ch->modal) - modals = g_list_prepend(modals, ch); - else - trans = g_list_prepend(trans, ch); - } - else { - if (ch->modal) - group_modals = g_list_prepend(group_modals, ch); - else - group_trans = g_list_prepend(group_trans, ch); + /* only move windows in the same stacking layer */ + if (ch->layer == selected->layer && + /* looking for windows that are transients, and so would + remain above the selected window */ + client_search_transient(selected, ch)) + { + if (client_is_direct_child(selected, ch)) { + if (ch->modal) + modals = g_list_prepend(modals, ch); + else + trans = g_list_prepend(trans, ch); + } + else if (client_helper(ch)) { + if (selected->transient) { + /* helpers do not stay above transient windows */ + continue; + } + group_helpers = g_list_prepend(group_helpers, ch); + } + else { + if (ch->modal) + group_modals = g_list_prepend(group_modals, ch); + else + group_trans = g_list_prepend(group_trans, ch); + } + stacking_list = g_list_delete_link(stacking_list, it); } - stacking_list = g_list_delete_link(stacking_list, it); } } } - /* put transients of the selected window right above it */ + /* put modals above other direct transients */ wins = g_list_concat(modals, trans); + + /* put helpers below direct transients */ + wins = g_list_concat(wins, group_helpers); + + /* put the selected window right below these children */ wins = g_list_append(wins, selected); /* if selected window is transient for group then raise it above others */ - if (selected->transient_for == OB_TRAN_GROUP) { + if (selected->transient_for_group) { /* if it's modal, raise it above those also */ if (selected->modal) { wins = g_list_concat(wins, group_modals); @@ -312,6 +368,27 @@ static void restack_windows(ObClient *selected, gboolean raise) do_restack(wins, below); g_list_free(wins); + + /* lower our parents after us, so they go below us */ + if (!raise && selected->parents) { + GSList *parents_copy, *sit; + GSList *reorder = NULL; + + parents_copy = g_slist_copy(selected->parents); + + /* go thru stacking list backwards so we can use g_slist_prepend */ + for (it = g_list_last(stacking_list); it && parents_copy; + it = g_list_previous(it)) + if ((sit = g_slist_find(parents_copy, it->data))) { + reorder = g_slist_prepend(reorder, sit->data); + parents_copy = g_slist_delete_link(parents_copy, sit); + } + g_assert(parents_copy == NULL); + + /* call restack for each of these to lower them */ + for (sit = reorder; sit; sit = g_slist_next(sit)) + restack_windows(sit->data, raise); + } } void stacking_raise(ObWindow *window) @@ -327,6 +404,7 @@ void stacking_raise(ObWindow *window) do_raise(wins); g_list_free(wins); } + stacking_list_tail = g_list_last(stacking_list); } void stacking_lower(ObWindow *window) @@ -342,6 +420,7 @@ void stacking_lower(ObWindow *window) do_lower(wins); g_list_free(wins); } + stacking_list_tail = g_list_last(stacking_list); } void stacking_below(ObWindow *window, ObWindow *below) @@ -356,22 +435,27 @@ void stacking_below(ObWindow *window, ObWindow *below) before = g_list_next(g_list_find(stacking_list, below)); do_restack(wins, before); g_list_free(wins); + stacking_list_tail = g_list_last(stacking_list); } void stacking_add(ObWindow *win) { g_assert(screen_support_win != None); /* make sure I dont break this in the future */ + /* don't add windows that are being unmanaged ! */ + if (WINDOW_IS_CLIENT(win)) g_assert(WINDOW_AS_CLIENT(win)->managed); stacking_list = g_list_append(stacking_list, win); + stacking_raise(win); + /* stacking_list_tail set by stacking_raise() */ } static GList *find_highest_relative(ObClient *client) -{ +{ GList *ret = NULL; - if (client->transient_for) { + if (client->parents) { GList *it; GSList *top; @@ -382,8 +466,14 @@ static GList *find_highest_relative(ObClient *client) for (it = stacking_list; !ret && it; it = g_list_next(it)) { if (WINDOW_IS_CLIENT(it->data)) { ObClient *c = it->data; - /* only look at windows in the same layer */ - if (c->layer == client->layer) { + /* only look at windows in the same layer and that are + visible */ + if (c->layer == client->layer && + !c->iconic && + (c->desktop == client->desktop || + c->desktop == DESKTOP_ALL || + client->desktop == DESKTOP_ALL)) + { GSList *sit; /* go through each top level parent and see it this window @@ -405,7 +495,9 @@ static GList *find_highest_relative(ObClient *client) void stacking_add_nonintrusive(ObWindow *win) { ObClient *client; - GList *it_below = NULL; + GList *it_below = NULL; /* this client will be below us */ + GList *it_above; + GList *wins; if (!WINDOW_IS_CLIENT(win)) { stacking_add(win); /* no special rules for others */ @@ -414,56 +506,62 @@ void stacking_add_nonintrusive(ObWindow *win) client = WINDOW_AS_CLIENT(win); + /* don't add windows that are being unmanaged ! */ + g_assert(client->managed); + /* insert above its highest parent (or its highest child !) */ it_below = find_highest_relative(client); - if (!it_below && client != focus_client) { - /* nothing to put it directly above, so try find the focused client to - put it underneath it */ - if (focus_client && focus_client->layer == client->layer) { - if ((it_below = g_list_find(stacking_list, focus_client))) - it_below = it_below->next; - } - } if (!it_below) { - /* There is no window to put this directly above, so put it at the - top, so you know it is there. - - It used to do this only if the window was focused and lower - it otherwise. - - We also put it at the top not the bottom to fix a bug with - fullscreen windows. When focusLast is off and followsMouse is - on, when you switch desktops, the fullscreen window loses - focus and goes into its lower layer. If this puts it at the - bottom then when you come back to the desktop, the window is - at the bottom and won't get focus back. - */ - stacking_list = g_list_append(stacking_list, win); - stacking_raise(win); - } else { - /* make sure it's not in the wrong layer though ! */ - for (; it_below; it_below = g_list_next(it_below)) + /* nothing to put it directly above, so try find the focused client + to put it underneath it */ + if (focus_client && client != focus_client && + focus_client->layer == client->layer) { - /* stop when the window is not in a higher layer than the window - it is going above (it_below) */ - if (client->layer >= window_layer(it_below->data)) - break; + it_below = g_list_find(stacking_list, focus_client); + /* this can give NULL, but it means the focused window is on the + bottom of the stacking order, so go to the bottom in that case, + below it */ + it_below = g_list_next(it_below); } - for (; it_below != stacking_list; - it_below = g_list_previous(it_below)) - { - /* stop when the window is not in a lower layer than the - window it is going under (it_above) */ - GList *it_above = g_list_previous(it_below); - if (client->layer <= window_layer(it_above->data)) - break; + else { + /* There is no window to put this directly above, so put it at the + top, so you know it is there. + + It used to do this only if the window was focused and lower + it otherwise. + + We also put it at the top not the bottom to fix a bug with + fullscreen windows. When focusLast is off and followsMouse is + on, when you switch desktops, the fullscreen window loses + focus and goes into its lower layer. If this puts it at the + bottom then when you come back to the desktop, the window is + at the bottom and won't get focus back. + */ + it_below = stacking_list; } + } - GList *wins = g_list_append(NULL, win); - do_restack(wins, it_below); - g_list_free(wins); + /* make sure it's not in the wrong layer though ! */ + for (; it_below; it_below = g_list_next(it_below)) { + /* stop when the window is not in a higher layer than the window + it is going above (it_below) */ + if (client->layer >= window_layer(it_below->data)) + break; } + for (; it_below != stacking_list; it_below = it_above) { + /* stop when the window is not in a lower layer than the + window it is going under (it_above) */ + it_above = it_below ? + g_list_previous(it_below) : g_list_last(stacking_list); + if (client->layer <= window_layer(it_above->data)) + break; + } + + wins = g_list_append(NULL, win); + do_restack(wins, it_below); + g_list_free(wins); + stacking_list_tail = g_list_last(stacking_list); } /*! Returns TRUE if client is occluded by the sibling. If sibling is NULL it @@ -473,19 +571,19 @@ static gboolean stacking_occluded(ObClient *client, ObClient *sibling) { GList *it; gboolean occluded = FALSE; - gboolean found = FALSE; /* no need for any looping in this case */ if (sibling && client->layer != sibling->layer) return occluded; - for (it = stacking_list; it; - it = (found ? g_list_previous(it) :g_list_next(it))) + for (it = g_list_previous(g_list_find(stacking_list, client)); it; + it = g_list_previous(it)) if (WINDOW_IS_CLIENT(it->data)) { ObClient *c = it->data; - if (found && !c->iconic && + if (!c->iconic && (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL || - c->desktop == client->desktop)) + c->desktop == client->desktop) && + !client_search_transient(client, c)) { if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area)) { @@ -503,8 +601,6 @@ static gboolean stacking_occluded(ObClient *client, ObClient *sibling) break; /* we past its layer */ } } - else if (c == client) - found = TRUE; } return occluded; } @@ -516,18 +612,19 @@ static gboolean stacking_occludes(ObClient *client, ObClient *sibling) { GList *it; gboolean occludes = FALSE; - gboolean found = FALSE; /* no need for any looping in this case */ if (sibling && client->layer != sibling->layer) return occludes; - for (it = stacking_list; it; it = g_list_next(it)) + for (it = g_list_next(g_list_find(stacking_list, client)); + it; it = g_list_next(it)) if (WINDOW_IS_CLIENT(it->data)) { ObClient *c = it->data; - if (found && !c->iconic && + if (!c->iconic && (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL || - c->desktop == client->desktop)) + c->desktop == client->desktop) && + !client_search_transient(c, client)) { if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area)) { @@ -545,14 +642,12 @@ static gboolean stacking_occludes(ObClient *client, ObClient *sibling) break; /* we past its layer */ } } - else if (c == client) - found = TRUE; } return occludes; } gboolean stacking_restack_request(ObClient *client, ObClient *sibling, - gint detail, gboolean activate) + gint detail) { gboolean ret = FALSE; @@ -562,21 +657,20 @@ gboolean stacking_restack_request(ObClient *client, ObClient *sibling, sibling->iconic)) { ob_debug("Setting restack sibling to NULL, they are not on the same " - "desktop or it is iconified\n"); + "desktop or it is iconified"); sibling = NULL; } switch (detail) { case Below: - ob_debug("Restack request Below for client %s sibling %s\n", + ob_debug("Restack request Below for client %s sibling %s", client->title, sibling ? sibling->title : "(all)"); /* just lower it */ stacking_lower(CLIENT_AS_WINDOW(client)); ret = TRUE; break; case BottomIf: - ob_debug("Restack request BottomIf for client %s sibling " - "%s\n", + ob_debug("Restack request BottomIf for client %s sibling %s", client->title, sibling ? sibling->title : "(all)"); /* if this client occludes sibling (or anything if NULL), then lower it to the bottom */ @@ -586,40 +680,24 @@ gboolean stacking_restack_request(ObClient *client, ObClient *sibling, } break; case Above: - ob_debug("Restack request Above for client %s sibling %s\n", + ob_debug("Restack request Above for client %s sibling %s", client->title, sibling ? sibling->title : "(all)"); - if (activate && !client->iconic && client_normal(client)) - /* use user=TRUE because it is impossible to get a timestamp - for this */ - client_activate(client, FALSE, TRUE); - else - stacking_raise(CLIENT_AS_WINDOW(client)); + stacking_raise(CLIENT_AS_WINDOW(client)); ret = TRUE; break; case TopIf: - ob_debug("Restack request TopIf for client %s sibling %s\n", + ob_debug("Restack request TopIf for client %s sibling %s", client->title, sibling ? sibling->title : "(all)"); if (stacking_occluded(client, sibling)) { - if (activate && !client->iconic && client_normal(client)) - /* use user=TRUE because it is impossible to get a timestamp - for this */ - client_activate(client, FALSE, TRUE); - else - stacking_raise(CLIENT_AS_WINDOW(client)); + stacking_raise(CLIENT_AS_WINDOW(client)); ret = TRUE; } break; case Opposite: - ob_debug("Restack request Opposite for client %s sibling " - "%s\n", + ob_debug("Restack request Opposite for client %s sibling %s", client->title, sibling ? sibling->title : "(all)"); if (stacking_occluded(client, sibling)) { - if (activate && !client->iconic && client_normal(client)) - /* use user=TRUE because it is impossible to get a timestamp - for this */ - client_activate(client, FALSE, TRUE); - else - stacking_raise(CLIENT_AS_WINDOW(client)); + stacking_raise(CLIENT_AS_WINDOW(client)); ret = TRUE; } else if (stacking_occludes(client, sibling)) {