X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Ftree.c;h=e384987366bd5982f4a430a80b48ed349995e40f;hb=ede954128afca118025db6a04d4d9d259473c70f;hp=b3d2ce93c04408e3d8e6b87318b2fefa018baccb;hpb=c45c002bad141add5b72a7e37ae930cf14f30f18;p=i3%2Fi3

diff --git a/src/tree.c b/src/tree.c
index b3d2ce93..e3849873 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -66,13 +66,13 @@ 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);
         goto out;
     }
 
-    char *buf = NULL;
     ssize_t len;
     if ((len = slurp(globbed, &buf)) < 0) {
         /* slurp already logged an error. */
@@ -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;
     }
 
@@ -266,7 +245,7 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par
              * 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 */
+             * 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.
@@ -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,38 +294,19 @@ 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();
+        ewmh_update_desktop_names();
+        ewmh_update_wm_desktop();
     }
 
     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 */
@@ -433,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;
     }
 
@@ -444,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;
 }
 
@@ -469,7 +420,7 @@ bool level_down(void) {
             next = TAILQ_FIRST(&(next->focus_head));
     }
 
-    con_focus(next);
+    con_activate(next);
     return true;
 }
 
@@ -560,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;
     }
 
@@ -616,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;
     }
 
@@ -641,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 */
@@ -665,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;
 }
 
@@ -675,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);
 }
 
 /*
@@ -752,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,