X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Ftree.c;h=e384987366bd5982f4a430a80b48ed349995e40f;hb=ede954128afca118025db6a04d4d9d259473c70f;hp=e99c5063b3b26ed5bb363874a8a5d6be35e291b2;hpb=fe482cf193b56c9a2f7fffc7dd2e943fda42061d;p=i3%2Fi3 diff --git a/src/tree.c b/src/tree.c index e99c5063..e3849873 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,27 +64,38 @@ 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 */ croot = con_new(NULL, NULL); - croot->rect = (Rect) { + croot->rect = (Rect){ geometry->x, geometry->y, geometry->width, geometry->height}; focused = croot; - tree_append_json(focused, globbed, NULL); + tree_append_json(focused, buf, len, NULL); DLOG("appended tree, using new root\n"); croot = TAILQ_FIRST(&(croot->nodes_head)); + if (!croot) { + /* tree_append_json failed. Continuing here would segfault. */ + goto out; + } DLOG("new root = %p\n", croot); Con *out = TAILQ_FIRST(&(croot->nodes_head)); DLOG("out = %p\n", out); @@ -104,7 +113,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; } /* @@ -118,7 +133,7 @@ void tree_init(xcb_get_geometry_reply_t *geometry) { croot->name = "root"; croot->type = CT_ROOT; croot->layout = L_SPLITH; - croot->rect = (Rect) { + croot->rect = (Rect){ geometry->x, geometry->y, geometry->width, @@ -164,16 +179,6 @@ Con *tree_open_con(Con *con, i3Window *window) { return new; } -static bool _is_con_mapped(Con *con) { - Con *child; - - TAILQ_FOREACH(child, &(con->nodes_head), nodes) - if (_is_con_mapped(child)) - return true; - - return con->mapped; -} - /* * Closes the given container including all children. * Returns true if the container was killed or false if just WM_DELETE was sent @@ -182,33 +187,17 @@ static bool _is_con_mapped(Con *con) { * The dont_kill_parent flag is specified when the function calls itself * 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 - * 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 was_mapped = con->mapped; +bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_parent) { Con *parent = con->parent; - if (!was_mapped) { - /* Even if the container itself is not mapped, its children may be - * mapped (for example split containers don't have a mapped window on - * their own but usually contain mapped children). */ - was_mapped = _is_con_mapped(con); - } - /* 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)); } - /* Get the container which is next focused */ - Con *next = con_next_focused(con); - DLOG("next = %p, focused = %p\n", next, focused); - DLOG("closing %p, kill_window = %d\n", con, kill_window); Con *child, *nextchild; bool abort_kill = false; @@ -217,8 +206,9 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool 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)) { abort_kill = true; + } child = nextchild; } @@ -237,7 +227,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); @@ -251,32 +241,27 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool cookie = xcb_change_property(conn, XCB_PROP_MODE_REPLACE, 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 https://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); } ipc_send_window_event("close", con); - FREE(con->window->class_class); - FREE(con->window->class_instance); - i3string_free(con->window->name); - FREE(con->window->ran_assignments); - FREE(con->window); + window_free(con->window); + con->window = NULL; } Con *ws = con_get_workspace(con); /* Figure out which container to focus next before detaching 'con'. */ - if (con_is_floating(con)) { - if (con == focused) { - DLOG("This is the focused container, i need to find another one to focus. I start looking at ws = %p\n", ws); - next = con_next_focused(parent); - - dont_kill_parent = true; - DLOG("Alright, focusing %p\n", next); - } else { - next = NULL; - } - } + Con *next = (con == focused) ? con_next_focused(con) : NULL; + DLOG("next = %p, focused = %p\n", next, focused); /* Detach the container so that it will not be rendered anymore. */ con_detach(con); @@ -301,7 +286,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(); @@ -309,41 +294,19 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool /* kill the X11 part of this container */ x_con_kill(con); - if (con_is_floating(con)) { - DLOG("Container was floating, killing floating container\n"); - tree_close(parent, DONT_KILL_WINDOW, false, (con == focused)); - DLOG("parent container killed\n"); + if (ws == con) { + DLOG("Closing a workspace container, updating EWMH atoms\n"); + ewmh_update_number_of_desktops(); + ewmh_update_desktop_names(); + ewmh_update_wm_desktop(); } - 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. */ - if (!next) { - DLOG("No next container, i will just exit now\n"); - return true; - } - - if (was_mapped || con == focused) { - if ((kill_window != DONT_KILL_WINDOW) || !dont_kill_parent || con == focused) { - DLOG("focusing %p / %s\n", next, next->name); - if (next->type == CT_DOCKAREA) { - /* Instead of focusing the dockarea, we need to restore focus to the workspace */ - con_focus(con_descend_focused(output_get_content(next->parent))); - } else { - if (!force_set_focus && con != focused) - DLOG("not changing focus, the container was not focused before\n"); - else - con_focus(next); - } - } else { - DLOG("not focusing because we're not killing anybody\n"); - } + if (next) { + con_activate(next); } else { - DLOG("not focusing, was not mapped\n"); + DLOG("not changing focus, the container was not focused before\n"); } /* check if the parent container is empty now and close it */ @@ -353,34 +316,6 @@ 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. @@ -394,7 +329,11 @@ void tree_split(Con *con, orientation_t orientation) { 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 { @@ -445,7 +384,7 @@ bool level_up(void) { /* Skip over floating containers and go directly to the grandparent * (which should always be a workspace) */ if (focused->parent->type == CT_FLOATING_CON) { - con_focus(focused->parent->parent); + con_activate(focused->parent->parent); return true; } @@ -456,7 +395,7 @@ bool level_up(void) { ELOG("'focus parent': Focus is already on the workspace, cannot go higher than that.\n"); return false; } - con_focus(focused->parent); + con_activate(focused->parent); return true; } @@ -481,7 +420,7 @@ bool level_down(void) { next = TAILQ_FIRST(&(next->focus_head)); } - con_focus(next); + con_activate(next); return true; } @@ -492,7 +431,7 @@ static void mark_unmapped(Con *con) { TAILQ_FOREACH(current, &(con->nodes_head), nodes) 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); @@ -544,7 +483,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; @@ -562,7 +501,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; @@ -572,26 +511,21 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) if (!workspace) return false; - workspace_show(workspace); - - /* If a workspace has an active fullscreen container, one of its - * children should always be focused. The above workspace_show() - * should be adequate for that, so return. */ - if (con_get_fullscreen_con(workspace, CF_OUTPUT)) - 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)); + /* Use descend_focused first to give higher priority to floating or + * tiling fullscreen containers. */ + Con *focus = con_descend_focused(workspace); + if (focus->fullscreen_mode == CF_NONE) { + Con *focus_tiling = con_descend_tiling_focused(workspace); + /* If descend_tiling returned a workspace then focus is either a + * floating container or the same workspace. */ + if (focus_tiling != workspace) { + focus = focus_tiling; + } } + + workspace_show(workspace); + con_activate(focus); + x_set_warp_to(&(focus->rect)); return true; } @@ -628,7 +562,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) TAILQ_INSERT_HEAD(&(parent->floating_head), last, floating_windows); } - con_focus(con_descend_focused(next)); + con_activate(con_descend_focused(next)); return true; } @@ -653,7 +587,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) 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 */ @@ -677,7 +611,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) /* 3: focus choice comes in here. at the moment we will go down * until we find a window */ /* TODO: check for window, atm we only go down as far as possible */ - con_focus(con_descend_focused(next)); + con_activate(con_descend_focused(next)); return true; } @@ -687,7 +621,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); } /* @@ -764,7 +699,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); /* Well, we got to abort the recursion here because we destroyed the * container. However, if tree_flatten() is called sufficiently often,