X-Git-Url: https://git.sur5r.net/?p=i3%2Fi3;a=blobdiff_plain;f=src%2Ftree.c;fp=src%2Ftree.c;h=e384987366bd5982f4a430a80b48ed349995e40f;hp=6c6a614e22d46479381e74447fd12f55dd378bb1;hb=1847938d4eeba98260cc79ca45a11a134274c2ea;hpb=c54f5008395b10c046f380cc3069ff779e5d2877 diff --git a/src/tree.c b/src/tree.c index 6c6a614e..e3849873 100644 --- a/src/tree.c +++ b/src/tree.c @@ -92,6 +92,10 @@ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { 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); @@ -175,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 @@ -193,22 +187,10 @@ 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_internal() will be invoked for the CT_FLOATINGCON (the parent - * container) and focus should be set there. - * */ -bool tree_close_internal(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_set_urgency(con, false); @@ -216,10 +198,6 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par 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; @@ -228,8 +206,9 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par for (child = TAILQ_FIRST(&(con->nodes_head)); child;) { nextchild = TAILQ_NEXT(child, nodes); DLOG("killing child=%p\n", child); - if (!tree_close_internal(child, kill_window, true, false)) + if (!tree_close_internal(child, kill_window, true)) { abort_kill = true; + } child = nextchild; } @@ -281,17 +260,8 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par 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); @@ -324,12 +294,6 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par /* 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_internal(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(); @@ -339,30 +303,10 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par 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_activate(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_activate(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 */ @@ -567,9 +511,16 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) if (!workspace) return false; - Con *focus = con_descend_tiling_focused(workspace); - if (focus == workspace) { - focus = con_descend_focused(workspace); + /* 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); @@ -748,7 +699,7 @@ void tree_flatten(Con *con) { /* 4: close the redundant cons */ DLOG("closing redundant cons\n"); - tree_close_internal(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,