X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Ftree.c;h=fc9526e6d196e65a01016c9a500e6ec0b079eec1;hb=50edf495aa3971bfb67471c3aaf2eb72e7abd443;hp=046d0b4c18caec263fd41f84ae70380c7e5ced55;hpb=61b53603e21c8604af6d2a3131c410539f83f6a0;p=i3%2Fi3 diff --git a/src/tree.c b/src/tree.c index 046d0b4c..fc9526e6 100644 --- a/src/tree.c +++ b/src/tree.c @@ -1,10 +1,8 @@ -#undef I3__FILE__ -#define I3__FILE__ "tree.c" /* * vim:ts=4:sw=4:expandtab * * i3 - an improved dynamic tiling window manager - * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE) + * © 2009 Michael Stapelberg and contributors (see also: LICENSE) * * tree.c: Everything that primarily modifies the layout tree data structure. * @@ -66,12 +64,19 @@ static Con *_create___i3(void) { * */ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { + bool result = false; char *globbed = resolve_tilde(path); + char *buf = NULL; if (!path_exists(globbed)) { LOG("%s does not exist, not restoring tree\n", globbed); - free(globbed); - return false; + goto out; + } + + ssize_t len; + if ((len = slurp(globbed, &buf)) < 0) { + /* slurp already logged an error. */ + goto out; } /* TODO: refactor the following */ @@ -80,19 +85,18 @@ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { geometry->x, geometry->y, geometry->width, - geometry->height - }; + geometry->height}; focused = croot; - tree_append_json(globbed, NULL); + tree_append_json(focused, buf, len, NULL); - printf("appended tree, using new root\n"); + DLOG("appended tree, using new root\n"); croot = TAILQ_FIRST(&(croot->nodes_head)); - printf("new root = %p\n", croot); + DLOG("new root = %p\n", croot); Con *out = TAILQ_FIRST(&(croot->nodes_head)); - printf("out = %p\n", out); + DLOG("out = %p\n", out); Con *ws = TAILQ_FIRST(&(out->nodes_head)); - printf("ws = %p\n", ws); + DLOG("ws = %p\n", ws); /* For in-place restarting into v4.2, we need to make sure the new * pseudo-output __i3 is present. */ @@ -105,7 +109,13 @@ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { TAILQ_INSERT_HEAD(&(croot->nodes_head), __i3, nodes); } - return true; + restore_open_placeholder_windows(croot); + result = true; + +out: + free(globbed); + free(buf); + return result; } /* @@ -123,8 +133,7 @@ void tree_init(xcb_get_geometry_reply_t *geometry) { geometry->x, geometry->y, geometry->width, - geometry->height - }; + geometry->height}; _create___i3(); } @@ -170,8 +179,8 @@ static bool _is_con_mapped(Con *con) { Con *child; TAILQ_FOREACH(child, &(con->nodes_head), nodes) - if (_is_con_mapped(child)) - return true; + if (_is_con_mapped(child)) + return true; return con->mapped; } @@ -185,11 +194,11 @@ static bool _is_con_mapped(Con *con) { * recursively while deleting a containers children. * * The force_set_focus flag is specified in the case of killing a floating - * window: tree_close() will be invoked for the CT_FLOATINGCON (the parent + * window: tree_close_internal() will be invoked for the CT_FLOATINGCON (the parent * container) and focus should be set there. * */ -bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool force_set_focus) { +bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool force_set_focus) { bool was_mapped = con->mapped; Con *parent = con->parent; @@ -202,7 +211,7 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool /* remove the urgency hint of the workspace (if set) */ if (con->urgent) { - con->urgent = false; + con_set_urgency(con, false); con_update_parents_urgency(con); workspace_update_urgent_flag(con_get_workspace(con)); } @@ -216,10 +225,10 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool bool abort_kill = false; /* We cannot use TAILQ_FOREACH because the children get deleted * in their parent’s nodes_head */ - for (child = TAILQ_FIRST(&(con->nodes_head)); child; ) { + for (child = TAILQ_FIRST(&(con->nodes_head)); child;) { nextchild = TAILQ_NEXT(child, nodes); DLOG("killing child=%p\n", child); - if (!tree_close(child, kill_window, true, false)) + if (!tree_close_internal(child, kill_window, true, false)) abort_kill = true; child = nextchild; } @@ -239,7 +248,7 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool * unmap the window, * then reparent it to the root window. */ xcb_change_window_attributes(conn, con->window->id, - XCB_CW_EVENT_MASK, (uint32_t[]){ XCB_NONE }); + XCB_CW_EVENT_MASK, (uint32_t[]){XCB_NONE}); xcb_unmap_window(conn, con->window->id); cookie = xcb_reparent_window(conn, con->window->id, root, 0, 0); @@ -249,18 +258,24 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool /* We are no longer handling this window, thus set WM_STATE to * WM_STATE_WITHDRAWN (see ICCCM 4.1.3.1) */ - long data[] = { XCB_ICCCM_WM_STATE_WITHDRAWN, XCB_NONE }; + long data[] = {XCB_ICCCM_WM_STATE_WITHDRAWN, XCB_NONE}; cookie = xcb_change_property(conn, XCB_PROP_MODE_REPLACE, - con->window->id, A_WM_STATE, A_WM_STATE, 32, 2, data); + con->window->id, A_WM_STATE, A_WM_STATE, 32, 2, data); + + /* Remove the window from the save set. All windows in the save set + * will be mapped when i3 closes its connection (e.g. when + * restarting). This is not what we want, since some apps keep + * unmapped windows around and don’t expect them to suddenly be + * mapped. See http://bugs.i3wm.org/1617 */ + xcb_change_save_set(conn, XCB_SET_MODE_DELETE, con->window->id); /* Ignore X11 errors for the ReparentWindow request. * X11 Errors are returned when the window was already destroyed */ add_ignore_event(cookie.sequence, 0); } - FREE(con->window->class_class); - FREE(con->window->class_instance); - i3string_free(con->window->name); - free(con->window); + ipc_send_window_event("close", con); + window_free(con->window); + con->window = NULL; } Con *ws = con_get_workspace(con); @@ -301,7 +316,7 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool * underlying container, see ticket #660. * * Rendering has to be avoided when dont_kill_parent is set (when - * tree_close calls itself recursively) because the tree is in a + * tree_close_internal calls itself recursively) because the tree is in a * non-renderable state during that time. */ if (!dont_kill_parent) tree_render(); @@ -311,14 +326,11 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool if (con_is_floating(con)) { DLOG("Container was floating, killing floating container\n"); - tree_close(parent, DONT_KILL_WINDOW, false, (con == focused)); + tree_close_internal(parent, DONT_KILL_WINDOW, false, (con == focused)); DLOG("parent container killed\n"); } - free(con->name); - FREE(con->deco_render_params); - TAILQ_REMOVE(&all_cons, con, all_cons); - free(con); + con_free(con); /* in the case of floating windows, we already focused another container * when closing the parent, so we can exit now. */ @@ -336,10 +348,10 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool } else { if (!force_set_focus && con != focused) DLOG("not changing focus, the container was not focused before\n"); - else con_focus(next); + else + con_focus(next); } - } - else { + } else { DLOG("not focusing because we're not killing anybody\n"); } } else { @@ -353,48 +365,24 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool return true; } -/* - * Closes the current container using tree_close(). - * - */ -void tree_close_con(kill_window_t kill_window) { - assert(focused != NULL); - - /* There *should* be no possibility to focus outputs / root container */ - assert(focused->type != CT_OUTPUT); - assert(focused->type != CT_ROOT); - - if (focused->type == CT_WORKSPACE) { - DLOG("Workspaces cannot be close, closing all children instead\n"); - Con *child, *nextchild; - for (child = TAILQ_FIRST(&(focused->focus_head)); child; ) { - nextchild = TAILQ_NEXT(child, focused); - DLOG("killing child=%p\n", child); - tree_close(child, kill_window, false, false); - child = nextchild; - } - - return; - } - - /* Kill con */ - tree_close(focused, kill_window, false, false); -} - /* * Splits (horizontally or vertically) the given container by creating a new * container which contains the old one and the future ones. * */ void tree_split(Con *con, orientation_t orientation) { - if (con->type == CT_FLOATING_CON) { + if (con_is_floating(con)) { DLOG("Floating containers can't be split.\n"); return; } if (con->type == CT_WORKSPACE) { if (con_num_children(con) < 2) { - DLOG("Just changing orientation of workspace\n"); + if (con_num_children(con) == 0) { + DLOG("Changing workspace_layout to L_DEFAULT\n"); + con->workspace_layout = L_DEFAULT; + } + DLOG("Changing orientation of workspace\n"); con->layout = (orientation == HORIZ) ? L_SPLITH : L_SPLITV; return; } else { @@ -407,8 +395,7 @@ void tree_split(Con *con, orientation_t orientation) { Con *parent = con->parent; /* Force re-rendering to make the indicator border visible. */ - FREE(con->deco_render_params); - FREE(parent->deco_render_params); + con_force_split_parents_redraw(con); /* if we are in a container whose parent contains only one * child (its split functionality is unused so far), we just change the @@ -471,16 +458,14 @@ bool level_down(void) { if (next == TAILQ_END(&(focused->focus_head))) { DLOG("cannot go down\n"); return false; - } - else if (next->type == CT_FLOATING_CON) { + } else if (next->type == CT_FLOATING_CON) { /* Floating cons shouldn't be directly focused; try immediately * going to the grandchild of the focused con. */ Con *child = TAILQ_FIRST(&(next->focus_head)); if (child == TAILQ_END(&(next->focus_head))) { DLOG("cannot go down\n"); return false; - } - else + } else next = TAILQ_FIRST(&(next->focus_head)); } @@ -493,12 +478,12 @@ static void mark_unmapped(Con *con) { con->mapped = false; TAILQ_FOREACH(current, &(con->nodes_head), nodes) - mark_unmapped(current); + mark_unmapped(current); if (con->type == CT_WORKSPACE) { - /* We need to call mark_unmapped on floating nodes aswell since we can + /* We need to call mark_unmapped on floating nodes as well since we can * make containers floating. */ TAILQ_FOREACH(current, &(con->floating_head), floating_windows) - mark_unmapped(current); + mark_unmapped(current); } } @@ -547,7 +532,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) if (!current_output) return false; - DLOG("Current output is %s\n", current_output->name); + DLOG("Current output is %s\n", output_primary_name(current_output)); /* Try to find next output */ direction_t direction; @@ -565,7 +550,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) next_output = get_output_next(direction, current_output, CLOSEST_OUTPUT); if (!next_output) return false; - DLOG("Next output is %s\n", next_output->name); + DLOG("Next output is %s\n", output_primary_name(next_output)); /* Find visible workspace on next output */ Con *workspace = NULL; @@ -584,6 +569,13 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) return true; Con *focus = con_descend_direction(workspace, direction); + + /* special case: if there was no tiling con to focus and the workspace + * has a floating con in the focus stack, focus the top of the focus + * stack (which may be floating) */ + if (focus == workspace) + focus = con_descend_focused(workspace); + if (focus) { con_focus(focus); x_set_warp_to(&(focus->rect)); @@ -594,31 +586,38 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) Con *parent = con->parent; if (con->type == CT_FLOATING_CON) { + if (orientation != HORIZ) + return false; + /* left/right focuses the previous/next floating container */ - if (orientation == HORIZ) { - Con *next; - if (way == 'n') - next = TAILQ_NEXT(con, floating_windows); - else next = TAILQ_PREV(con, floating_head, floating_windows); - - /* If there is no next/previous container, wrap */ - if (!next) { - if (way == 'n') - next = TAILQ_FIRST(&(parent->floating_head)); - else next = TAILQ_LAST(&(parent->floating_head), floating_head); - } + Con *next; + if (way == 'n') + next = TAILQ_NEXT(con, floating_windows); + else + next = TAILQ_PREV(con, floating_head, floating_windows); - /* Still no next/previous container? bail out */ - if (!next) - return false; + /* If there is no next/previous container, wrap */ + if (!next) { + if (way == 'n') + next = TAILQ_FIRST(&(parent->floating_head)); + else + next = TAILQ_LAST(&(parent->floating_head), floating_head); + } - con_focus(con_descend_focused(next)); - return true; - } else { - /* up/down cycles through the Z-index */ - /* TODO: implement cycling through the z-index */ + /* Still no next/previous container? bail out */ + if (!next) return false; + + /* Raise the floating window on top of other windows preserving + * relative stack order */ + while (TAILQ_LAST(&(parent->floating_head), floating_head) != next) { + Con *last = TAILQ_LAST(&(parent->floating_head), floating_head); + TAILQ_REMOVE(&(parent->floating_head), last, floating_windows); + TAILQ_INSERT_HEAD(&(parent->floating_head), last, floating_windows); } + + con_focus(con_descend_focused(next)); + return true; } /* If the orientation does not match or there is no other con to focus, we @@ -638,10 +637,11 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) Con *next; if (way == 'n') next = TAILQ_NEXT(current, nodes); - else next = TAILQ_PREV(current, nodes_head, nodes); + else + next = TAILQ_PREV(current, nodes_head, nodes); if (!next) { - if (!config.force_focus_wrapping) { + if (config.focus_wrapping != FOCUS_WRAPPING_FORCE) { /* If there is no next/previous container, we check if we can focus one * when going higher (without wrapping, though). If so, we are done, if * not, we wrap */ @@ -654,7 +654,8 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) if (way == 'n') next = TAILQ_FIRST(&(parent->nodes_head)); - else next = TAILQ_LAST(&(parent->nodes_head), nodes_head); + else + next = TAILQ_LAST(&(parent->nodes_head), nodes_head); } /* Don't violate fullscreen focus restrictions. */ @@ -674,7 +675,8 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) * */ void tree_next(char way, orientation_t orientation) { - _tree_next(focused, way, orientation, true); + _tree_next(focused, way, orientation, + config.focus_wrapping != FOCUS_WRAPPING_OFF); } /* @@ -751,7 +753,7 @@ void tree_flatten(Con *con) { /* 4: close the redundant cons */ DLOG("closing redundant cons\n"); - tree_close(con, DONT_KILL_WINDOW, true, false); + tree_close_internal(con, DONT_KILL_WINDOW, true, false); /* Well, we got to abort the recursion here because we destroyed the * container. However, if tree_flatten() is called sufficiently often,