-#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.
*
*
*/
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 */
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);
+ 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));
- 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. */
TAILQ_INSERT_HEAD(&(croot->nodes_head), __i3, nodes);
}
- return true;
+ restore_open_placeholder_windows(croot);
+ result = true;
+
+out:
+ free(globbed);
+ free(buf);
+ return result;
}
/*
geometry->x,
geometry->y,
geometry->width,
- geometry->height
- };
+ geometry->height};
_create___i3();
}
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
* 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;
/* 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)) {
abort_kill = true;
+ }
child = nextchild;
}
* 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);
/* 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 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);
}
- 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);
/* 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);
* 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();
/* 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 */
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 {
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
/* 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;
}
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;
}
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));
}
- con_focus(next);
+ con_activate(next);
return true;
}
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);
}
}
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;
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;
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);
- 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;
}
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_activate(con_descend_focused(next));
+ return true;
}
/* If the orientation does not match or there is no other con to focus, we
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 */
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. */
/* 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;
}
*
*/
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);
}
/*
/* 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,
projects / i3 / i3 / blobdiff