X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Ftree.c;h=b40ba2a2879203b503d7640937184fae91f3ea13;hb=f790fedce385862c7a22df53d527960e82eff920;hp=c398ee1d36f6722a35fe4b77fb569ea3350d86d4;hpb=2c249b6949566fe9e2414d86b26bf5d29c7c1a6b;p=i3%2Fi3

diff --git a/src/tree.c b/src/tree.c
index c398ee1d..b40ba2a2 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -80,19 +80,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);
+    tree_append_json(focused, globbed, 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,6 +104,8 @@ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) {
         TAILQ_INSERT_HEAD(&(croot->nodes_head), __i3, nodes);
     }
 
+    restore_open_placeholder_windows(croot);
+
     return true;
 }
 
@@ -123,8 +124,7 @@ void tree_init(xcb_get_geometry_reply_t *geometry) {
         geometry->x,
         geometry->y,
         geometry->width,
-        geometry->height
-    };
+        geometry->height};
 
     _create___i3();
 }
@@ -170,8 +170,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;
 }
@@ -200,6 +200,13 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool
         was_mapped = _is_con_mapped(con);
     }
 
+    /* remove the urgency hint of the workspace (if set) */
+    if (con->urgent) {
+        con->urgent = 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);
@@ -209,7 +216,7 @@ 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))
@@ -228,7 +235,12 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool
             return false;
         } else {
             xcb_void_cookie_t cookie;
-            /* un-parent the window */
+            /* Ignore any further events by clearing the event mask,
+             * 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_unmap_window(conn, con->window->id);
             cookie = xcb_reparent_window(conn, con->window->id, root, 0, 0);
 
             /* Ignore X11 errors for the ReparentWindow request.
@@ -237,18 +249,20 @@ 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);
 
             /* 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);
+        FREE(con->window->ran_assignments);
+        FREE(con->window);
     }
 
     Con *ws = con_get_workspace(con);
@@ -324,10 +338,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 {
@@ -347,15 +361,24 @@ bool tree_close(Con *con, kill_window_t kill_window, bool dont_kill_parent, bool
  */
 void tree_close_con(kill_window_t kill_window) {
     assert(focused != NULL);
-    if (focused->type == CT_WORKSPACE) {
-        LOG("Cannot close workspace\n");
-        return;
-    }
 
     /* 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);
 }
@@ -366,22 +389,27 @@ void tree_close_con(kill_window_t kill_window) {
  *
  */
 void tree_split(Con *con, orientation_t orientation) {
-    /* for a workspace, we just need to change orientation */
-    if (con->type == CT_WORKSPACE) {
-        DLOG("Workspace, simply changing orientation to %d\n", orientation);
-        con->layout = (orientation == HORIZ) ? L_SPLITH : L_SPLITV;
-        return;
-    }
-    else 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");
+            con->layout = (orientation == HORIZ) ? L_SPLITH : L_SPLITV;
+            return;
+        } else {
+            /* if there is more than one container on the workspace
+             * move them into a new container and handle this instead */
+            con = workspace_encapsulate(con);
+        }
+    }
+
     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
@@ -444,16 +472,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));
     }
 
@@ -466,12 +492,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
          * make containers floating. */
         TAILQ_FOREACH(current, &(con->floating_head), floating_windows)
-            mark_unmapped(current);
+        mark_unmapped(current);
     }
 }
 
@@ -557,6 +583,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));
@@ -567,31 +600,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
@@ -611,7 +651,8 @@ 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) {
@@ -627,7 +668,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. */
@@ -684,6 +726,8 @@ void tree_flatten(Con *con) {
      * the con’s parent to be redundant */
     if (!con_is_split(con) ||
         !con_is_split(child) ||
+        (con->layout != L_SPLITH && con->layout != L_SPLITV) ||
+        (child->layout != L_SPLITH && child->layout != L_SPLITV) ||
         con_orientation(con) == con_orientation(child) ||
         con_orientation(child) != con_orientation(parent))
         goto recurse;