-#undef I3__FILE__
-#define I3__FILE__ "con.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)
*
* con.c: Functions which deal with containers directly (creating containers,
* searching containers, getting specific properties from containers,
*
*/
#include "all.h"
+
#include "yajl_utils.h"
static void con_on_remove_child(Con *con);
void con_force_split_parents_redraw(Con *con) {
Con *parent = con;
- while (parent && parent->type != CT_WORKSPACE && parent->type != CT_DOCKAREA) {
- if (!con_is_leaf(parent))
+ while (parent != NULL && parent->type != CT_WORKSPACE && parent->type != CT_DOCKAREA) {
+ if (!con_is_leaf(parent)) {
FREE(parent->deco_render_params);
+ }
+
parent = parent->parent;
}
}
*
*/
Con *con_new_skeleton(Con *parent, i3Window *window) {
- Con *new = scalloc(sizeof(Con));
+ Con *new = scalloc(1, sizeof(Con));
new->on_remove_child = con_on_remove_child;
TAILQ_INSERT_TAIL(&all_cons, new, all_cons);
- new->aspect_ratio = 0.0;
new->type = CT_CON;
new->window = window;
new->border_style = config.default_border;
new->current_border_width = -1;
- if (window)
+ if (window) {
new->depth = window->depth;
- else
- new->depth = XCB_COPY_FROM_PARENT;
+ new->window->aspect_ratio = 0.0;
+ } else {
+ new->depth = root_depth;
+ }
DLOG("opening window\n");
TAILQ_INIT(&(new->floating_head));
TAILQ_INIT(&(new->nodes_head));
TAILQ_INIT(&(new->focus_head));
TAILQ_INIT(&(new->swallow_head));
+ TAILQ_INIT(&(new->marks_head));
if (parent != NULL)
con_attach(new, parent, false);
*/
Con *con_new(Con *parent, i3Window *window) {
Con *new = con_new_skeleton(parent, window);
- x_con_init(new, new->depth);
+ x_con_init(new);
return new;
}
-/*
- * Attaches the given container to the given parent. This happens when moving
- * a container or when inserting a new container at a specific place in the
- * tree.
- *
- * ignore_focus is to just insert the Con at the end (useful when creating a
- * new split container *around* some containers, that is, detaching and
- * attaching them in order without wanting to mess with the focus in between).
- *
- */
-void con_attach(Con *con, Con *parent, bool ignore_focus) {
+static void _con_attach(Con *con, Con *parent, Con *previous, bool ignore_focus) {
con->parent = parent;
Con *loop;
- Con *current = NULL;
+ Con *current = previous;
struct nodes_head *nodes_head = &(parent->nodes_head);
struct focus_head *focus_head = &(parent->focus_head);
/* Insert the container after the tiling container, if found.
* When adding to a CT_OUTPUT, just append one after another. */
- if (current && parent->type != CT_OUTPUT) {
- DLOG("Inserting con = %p after last focused tiling con %p\n",
- con, current);
+ if (current != NULL && parent->type != CT_OUTPUT) {
+ DLOG("Inserting con = %p after con %p\n", con, current);
TAILQ_INSERT_AFTER(nodes_head, current, con, nodes);
} else
TAILQ_INSERT_TAIL(nodes_head, con, nodes);
con_force_split_parents_redraw(con);
}
+/*
+ * Attaches the given container to the given parent. This happens when moving
+ * a container or when inserting a new container at a specific place in the
+ * tree.
+ *
+ * ignore_focus is to just insert the Con at the end (useful when creating a
+ * new split container *around* some containers, that is, detaching and
+ * attaching them in order without wanting to mess with the focus in between).
+ *
+ */
+void con_attach(Con *con, Con *parent, bool ignore_focus) {
+ _con_attach(con, parent, NULL, ignore_focus);
+}
+
/*
* Detaches the given container from its current parent
*
* checks before resetting the urgency.
*/
if (con->urgent && con_is_leaf(con)) {
- con->urgent = false;
+ con_set_urgency(con, false);
con_update_parents_urgency(con);
workspace_update_urgent_flag(con_get_workspace(con));
ipc_send_window_event("urgent", con);
}
}
+/*
+ * Closes the given container.
+ *
+ */
+void con_close(Con *con, kill_window_t kill_window) {
+ assert(con != NULL);
+ DLOG("Closing con = %p.\n", con);
+
+ /* We never close output or root containers. */
+ if (con->type == CT_OUTPUT || con->type == CT_ROOT) {
+ DLOG("con = %p is of type %d, not closing anything.\n", con, con->type);
+ return;
+ }
+
+ if (con->type == CT_WORKSPACE) {
+ DLOG("con = %p is a workspace, closing all children instead.\n", con);
+ Con *child, *nextchild;
+ for (child = TAILQ_FIRST(&(con->focus_head)); child;) {
+ nextchild = TAILQ_NEXT(child, focused);
+ DLOG("killing child = %p.\n", child);
+ tree_close_internal(child, kill_window, false, false);
+ child = nextchild;
+ }
+
+ return;
+ }
+
+ tree_close_internal(con, kill_window, false, false);
+}
+
/*
* Returns true when this node is a leaf node (has no children)
*
}
}
+/*
+ * This will only return true for containers which have some parent with
+ * a tabbed / stacked parent of which they are not the currently focused child.
+ *
+ */
+bool con_is_hidden(Con *con) {
+ Con *current = con;
+
+ /* ascend to the workspace level and memorize the highest-up container
+ * which is stacked or tabbed. */
+ while (current != NULL && current->type != CT_WORKSPACE) {
+ Con *parent = current->parent;
+ if (parent != NULL && (parent->layout == L_TABBED || parent->layout == L_STACKED)) {
+ if (TAILQ_FIRST(&(parent->focus_head)) != current)
+ return true;
+ }
+
+ current = parent;
+ }
+
+ return false;
+}
+
+/*
+ * Returns whether the container or any of its children is sticky.
+ *
+ */
+bool con_is_sticky(Con *con) {
+ if (con->sticky)
+ return true;
+
+ Con *child;
+ TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ if (con_is_sticky(child))
+ return true;
+ }
+
+ return false;
+}
+
/*
* Returns true if this node accepts a window (if the node swallows windows,
* it might already have swallowed enough and cannot hold any more).
struct bfs_entry {
Con *con;
- TAILQ_ENTRY(bfs_entry) entries;
+ TAILQ_ENTRY(bfs_entry)
+ entries;
};
/*
/* TODO: is breadth-first-search really appropriate? (check as soon as
* fullscreen levels and fullscreen for containers is implemented) */
- TAILQ_HEAD(bfs_head, bfs_entry) bfs_head = TAILQ_HEAD_INITIALIZER(bfs_head);
+ TAILQ_HEAD(bfs_head, bfs_entry)
+ bfs_head = TAILQ_HEAD_INITIALIZER(bfs_head);
+
struct bfs_entry *entry = smalloc(sizeof(struct bfs_entry));
entry->con = con;
TAILQ_INSERT_TAIL(&bfs_head, entry, entries);
return (con->floating >= FLOATING_AUTO_ON);
}
+/*
+ * Returns true if the container is a docked container.
+ *
+ */
+bool con_is_docked(Con *con) {
+ if (con->parent == NULL)
+ return false;
+
+ if (con->parent->type == CT_DOCKAREA)
+ return true;
+
+ return con_is_docked(con->parent);
+}
+
/*
* Checks if the given container is either floating or inside some floating
* container. It returns the FLOATING_CON container.
return con_inside_focused(con->parent);
}
+/*
+ * Checks if the container has the given parent as an actual parent.
+ *
+ */
+bool con_has_parent(Con *con, Con *parent) {
+ Con *current = con->parent;
+ if (current == NULL) {
+ return false;
+ }
+
+ if (current == parent) {
+ return true;
+ }
+
+ return con_has_parent(current, parent);
+}
+
/*
* Returns the container with the given client window ID or NULL if no such
* container exists.
Con *con_by_frame_id(xcb_window_t frame) {
Con *con;
TAILQ_FOREACH(con, &all_cons, all_cons)
- if (con->frame == frame)
+ if (con->frame.id == frame)
return con;
return NULL;
}
+/*
+ * Returns the container with the given mark or NULL if no such container
+ * exists.
+ *
+ */
+Con *con_by_mark(const char *mark) {
+ Con *con;
+ TAILQ_FOREACH(con, &all_cons, all_cons) {
+ if (con_has_mark(con, mark))
+ return con;
+ }
+
+ return NULL;
+}
+
+/*
+ * Returns true if and only if the given containers holds the mark.
+ *
+ */
+bool con_has_mark(Con *con, const char *mark) {
+ mark_t *current;
+ TAILQ_FOREACH(current, &(con->marks_head), marks) {
+ if (strcmp(current->name, mark) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+/*
+ * Toggles the mark on a container.
+ * If the container already has this mark, the mark is removed.
+ * Otherwise, the mark is assigned to the container.
+ *
+ */
+void con_mark_toggle(Con *con, const char *mark, mark_mode_t mode) {
+ assert(con != NULL);
+ DLOG("Toggling mark \"%s\" on con = %p.\n", mark, con);
+
+ if (con_has_mark(con, mark)) {
+ con_unmark(con, mark);
+ } else {
+ con_mark(con, mark, mode);
+ }
+}
+
+/*
+ * Assigns a mark to the container.
+ *
+ */
+void con_mark(Con *con, const char *mark, mark_mode_t mode) {
+ assert(con != NULL);
+ DLOG("Setting mark \"%s\" on con = %p.\n", mark, con);
+
+ con_unmark(NULL, mark);
+ if (mode == MM_REPLACE) {
+ DLOG("Removing all existing marks on con = %p.\n", con);
+
+ mark_t *current;
+ while (!TAILQ_EMPTY(&(con->marks_head))) {
+ current = TAILQ_FIRST(&(con->marks_head));
+ con_unmark(con, current->name);
+ }
+ }
+
+ mark_t *new = scalloc(1, sizeof(mark_t));
+ new->name = sstrdup(mark);
+ TAILQ_INSERT_TAIL(&(con->marks_head), new, marks);
+ ipc_send_window_event("mark", con);
+
+ con->mark_changed = true;
+}
+
+/*
+ * Removes marks from containers.
+ * If con is NULL, all containers are considered.
+ * If name is NULL, this removes all existing marks.
+ * Otherwise, it will only remove the given mark (if it is present).
+ *
+ */
+void con_unmark(Con *con, const char *name) {
+ Con *current;
+ if (name == NULL) {
+ DLOG("Unmarking all containers.\n");
+ TAILQ_FOREACH(current, &all_cons, all_cons) {
+ if (con != NULL && current != con)
+ continue;
+
+ if (TAILQ_EMPTY(&(current->marks_head)))
+ continue;
+
+ mark_t *mark;
+ while (!TAILQ_EMPTY(&(current->marks_head))) {
+ mark = TAILQ_FIRST(&(current->marks_head));
+ FREE(mark->name);
+ TAILQ_REMOVE(&(current->marks_head), mark, marks);
+ FREE(mark);
+
+ ipc_send_window_event("mark", current);
+ }
+
+ current->mark_changed = true;
+ }
+ } else {
+ DLOG("Removing mark \"%s\".\n", name);
+ current = (con == NULL) ? con_by_mark(name) : con;
+ if (current == NULL) {
+ DLOG("No container found with this mark, so there is nothing to do.\n");
+ return;
+ }
+
+ DLOG("Found mark on con = %p. Removing it now.\n", current);
+ current->mark_changed = true;
+
+ mark_t *mark;
+ TAILQ_FOREACH(mark, &(current->marks_head), marks) {
+ if (strcmp(mark->name, name) != 0)
+ continue;
+
+ FREE(mark->name);
+ TAILQ_REMOVE(&(current->marks_head), mark, marks);
+ FREE(mark);
+
+ ipc_send_window_event("mark", current);
+ break;
+ }
+ }
+}
+
/*
* Returns the first container below 'con' which wants to swallow this window
* TODO: priority
return children;
}
+/**
+ * Returns the number of visible non-floating children of this container.
+ * For example, if the container contains a hsplit which has two children,
+ * this will return 2 instead of 1.
+ */
+int con_num_visible_children(Con *con) {
+ if (con == NULL)
+ return 0;
+
+ int children = 0;
+ Con *current = NULL;
+ TAILQ_FOREACH(current, &(con->nodes_head), nodes) {
+ /* Visible leaf nodes are a child. */
+ if (!con_is_hidden(current) && con_is_leaf(current))
+ children++;
+ /* All other containers need to be recursed. */
+ else
+ children += con_num_visible_children(current);
+ }
+
+ return children;
+}
+
+/*
+ * Count the number of windows (i.e., leaf containers).
+ *
+ */
+int con_num_windows(Con *con) {
+ if (con == NULL)
+ return 0;
+
+ if (con_has_managed_window(con))
+ return 1;
+
+ int num = 0;
+ Con *current = NULL;
+ TAILQ_FOREACH(current, &(con->nodes_head), nodes) {
+ num += con_num_windows(current);
+ }
+
+ return num;
+}
+
/*
* Updates the percent attribute of the children of the given container. This
* function needs to be called when a window is added or removed from a
if (children_with_percent != children) {
TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
if (child->percent <= 0.0) {
- if (children_with_percent == 0)
+ if (children_with_percent == 0) {
total += (child->percent = 1.0);
- else
+ } else {
total += (child->percent = total / children_with_percent);
+ }
}
}
}
// if we got a zero, just distribute the space equally, otherwise
// distribute according to the proportions we got
if (total == 0.0) {
- TAILQ_FOREACH(child, &(con->nodes_head), nodes)
- child->percent = 1.0 / children;
+ TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ child->percent = 1.0 / children;
+ }
} else if (total != 1.0) {
- TAILQ_FOREACH(child, &(con->nodes_head), nodes)
- child->percent /= total;
+ TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ child->percent /= total;
+ }
}
}
if (con->window == NULL)
return;
- uint32_t values[1];
- unsigned int num = 0;
-
- if (con->fullscreen_mode != CF_NONE)
- values[num++] = A__NET_WM_STATE_FULLSCREEN;
-
- xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->window->id,
- A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values);
+ if (con->fullscreen_mode != CF_NONE) {
+ DLOG("Setting _NET_WM_STATE_FULLSCREEN for con = %p / window = %d.\n", con, con->window->id);
+ xcb_add_property_atom(conn, con->window->id, A__NET_WM_STATE, A__NET_WM_STATE_FULLSCREEN);
+ } else {
+ DLOG("Removing _NET_WM_STATE_FULLSCREEN for con = %p / window = %d.\n", con, con->window->id);
+ xcb_remove_property_atom(conn, con->window->id, A__NET_WM_STATE, A__NET_WM_STATE_FULLSCREEN);
+ }
}
/*
con_set_fullscreen_mode(con, CF_NONE);
}
-/*
- * Moves the given container to the currently focused container on the given
- * workspace.
- *
- * The fix_coordinates flag will translate the current coordinates (offset from
- * the monitor position basically) to appropriate coordinates on the
- * destination workspace.
- * Not enabling this behaviour comes in handy when this function gets called by
- * floating_maybe_reassign_ws, which will only "move" a floating window when it
- * *already* changed its coordinates to a different output.
- *
- * The dont_warp flag disables pointer warping and will be set when this
- * function is called while dragging a floating window.
- *
- * TODO: is there a better place for this function?
- *
- */
-void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp) {
+static bool _con_move_to_con(Con *con, Con *target, bool behind_focused, bool fix_coordinates, bool dont_warp, bool ignore_focus, bool fix_percentage) {
+ Con *orig_target = target;
+
/* Prevent moving if this would violate the fullscreen focus restrictions. */
- if (!con_fullscreen_permits_focusing(workspace)) {
- LOG("Cannot move out of a fullscreen container");
- return;
+ Con *target_ws = con_get_workspace(target);
+ if (!con_fullscreen_permits_focusing(target_ws)) {
+ LOG("Cannot move out of a fullscreen container.\n");
+ return false;
}
if (con_is_floating(con)) {
- DLOG("Using FLOATINGCON instead\n");
+ DLOG("Container is floating, using parent instead.\n");
con = con->parent;
}
Con *source_ws = con_get_workspace(con);
- if (workspace == source_ws) {
- DLOG("Not moving, already there\n");
- return;
- }
if (con->type == CT_WORKSPACE) {
/* Re-parent all of the old workspace's floating windows. */
Con *child;
while (!TAILQ_EMPTY(&(source_ws->floating_head))) {
child = TAILQ_FIRST(&(source_ws->floating_head));
- con_move_to_workspace(child, workspace, true, true);
+ con_move_to_workspace(child, target_ws, true, true, false);
}
/* If there are no non-floating children, ignore the workspace. */
if (con_is_leaf(con))
- return;
+ return false;
con = workspace_encapsulate(con);
if (con == NULL) {
ELOG("Workspace failed to move its contents into a container!\n");
- return;
+ return false;
}
}
Con *current_ws = con_get_workspace(focused);
Con *source_output = con_get_output(con),
- *dest_output = con_get_output(workspace);
+ *dest_output = con_get_output(target_ws);
/* 1: save the container which is going to be focused after the current
* container is moved away */
Con *focus_next = con_next_focused(con);
- /* 2: get the focused container of this workspace */
- Con *next = con_descend_focused(workspace);
-
- /* 3: we go up one level, but only when next is a normal container */
- if (next->type != CT_WORKSPACE) {
- DLOG("next originally = %p / %s / type %d\n", next, next->name, next->type);
- next = next->parent;
+ /* 2: we go up one level, but only when target is a normal container */
+ if (target->type != CT_WORKSPACE) {
+ DLOG("target originally = %p / %s / type %d\n", target, target->name, target->type);
+ target = target->parent;
}
- /* 4: if the target container is floating, we get the workspace instead.
+ /* 3: if the target container is floating, we get the workspace instead.
* Only tiling windows need to get inserted next to the current container.
* */
- Con *floatingcon = con_inside_floating(next);
+ Con *floatingcon = con_inside_floating(target);
if (floatingcon != NULL) {
DLOG("floatingcon, going up even further\n");
- next = floatingcon->parent;
+ target = floatingcon->parent;
}
if (con->type == CT_FLOATING_CON) {
- Con *ws = con_get_workspace(next);
+ Con *ws = con_get_workspace(target);
DLOG("This is a floating window, using workspace %p / %s\n", ws, ws->name);
- next = ws;
+ target = ws;
}
if (source_output != dest_output) {
/* If moving to a visible workspace, call show so it can be considered
* focused. Must do before attaching because workspace_show checks to see
* if focused container is in its area. */
- if (workspace_is_visible(workspace)) {
- workspace_show(workspace);
+ if (!ignore_focus && workspace_is_visible(target_ws)) {
+ workspace_show(target_ws);
/* Don’t warp if told so (when dragging floating windows with the
* mouse for example) */
/* If moving a fullscreen container and the destination already has a
* fullscreen window on it, un-fullscreen the target's fullscreen con. */
- Con *fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT);
+ Con *fullscreen = con_get_fullscreen_con(target_ws, CF_OUTPUT);
if (con->fullscreen_mode != CF_NONE && fullscreen != NULL) {
con_toggle_fullscreen(fullscreen, CF_OUTPUT);
fullscreen = NULL;
}
- DLOG("Re-attaching container to %p / %s\n", next, next->name);
- /* 5: re-attach the con to the parent of this focused container */
+ DLOG("Re-attaching container to %p / %s\n", target, target->name);
+ /* 4: re-attach the con to the parent of this focused container */
Con *parent = con->parent;
con_detach(con);
- con_attach(con, next, false);
+ _con_attach(con, target, behind_focused ? NULL : orig_target, !behind_focused);
- /* 6: fix the percentages */
- con_fix_percent(parent);
- con->percent = 0.0;
- con_fix_percent(next);
+ /* 5: fix the percentages */
+ if (fix_percentage) {
+ con_fix_percent(parent);
+ con->percent = 0.0;
+ con_fix_percent(target);
+ }
- /* 7: focus the con on the target workspace, but only within that
+ /* 6: focus the con on the target workspace, but only within that
* workspace, that is, don’t move focus away if the target workspace is
* invisible.
* We don’t focus the con for i3 pseudo workspaces like __i3_scratch and
- * we don’t focus when there is a fullscreen con on that workspace. */
- if (!con_is_internal(workspace) && !fullscreen) {
+ * we don’t focus when there is a fullscreen con on that workspace. We
+ * also don't do it if the caller requested to ignore focus. */
+ if (!ignore_focus && !con_is_internal(target_ws) && !fullscreen) {
/* We need to save the focused workspace on the output in case the
* new workspace is hidden and it's necessary to immediately switch
* back to the originally-focused workspace. */
con_focus(old_focus);
}
- /* 8: when moving to another workspace, we leave the focus on the current
+ /* 7: when moving to another workspace, we leave the focus on the current
* workspace. (see also #809) */
/* Descend focus stack in case focus_next is a workspace which can
* occur if we move to the same workspace. Also show current workspace
* to ensure it is focused. */
- workspace_show(current_ws);
+ if (!ignore_focus)
+ workspace_show(current_ws);
/* Set focus only if con was on current workspace before moving.
* Otherwise we would give focus to some window on different workspace. */
- if (source_ws == current_ws)
+ if (!ignore_focus && source_ws == current_ws)
con_focus(con_descend_focused(focus_next));
- /* 9. If anything within the container is associated with a startup sequence,
+ /* 8. If anything within the container is associated with a startup sequence,
* delete it so child windows won't be created on the old workspace. */
struct Startup_Sequence *sequence;
xcb_get_property_cookie_t cookie;
startup_sequence_delete(sequence);
}
- CALL(parent, on_remove_child);
-
- /* 10. If the container was marked urgent, move the urgency hint. */
+ /* 9. If the container was marked urgent, move the urgency hint. */
if (urgent) {
workspace_update_urgent_flag(source_ws);
con_set_urgency(con, true);
}
+ /* Ensure the container will be redrawn. */
+ FREE(con->deco_render_params);
+
+ CALL(parent, on_remove_child);
+
ipc_send_window_event("move", con);
+ ewmh_update_wm_desktop();
+ return true;
+}
+
+/*
+ * Moves the given container to the given mark.
+ *
+ */
+bool con_move_to_mark(Con *con, const char *mark) {
+ Con *target = con_by_mark(mark);
+ if (target == NULL) {
+ DLOG("found no container with mark \"%s\"\n", mark);
+ return false;
+ }
+
+ /* For floating target containers, we just send the window to the same workspace. */
+ if (con_is_floating(target)) {
+ DLOG("target container is floating, moving container to target's workspace.\n");
+ con_move_to_workspace(con, con_get_workspace(target), true, false, false);
+ return true;
+ }
+
+ if (con->type == CT_WORKSPACE) {
+ DLOG("target container is a workspace, simply moving the container there.\n");
+ con_move_to_workspace(con, target, true, false, false);
+ return true;
+ }
+
+ /* For split containers, we use the currently focused container within it.
+ * This allows setting marks on, e.g., tabbed containers which will move
+ * con to a new tab behind the focused tab. */
+ if (con_is_split(target)) {
+ DLOG("target is a split container, descending to the currently focused child.\n");
+ target = TAILQ_FIRST(&(target->focus_head));
+ }
+
+ if (con == target || con_has_parent(target, con)) {
+ DLOG("cannot move the container to or inside itself, aborting.\n");
+ return false;
+ }
+
+ return _con_move_to_con(con, target, false, true, false, false, true);
+}
+
+/*
+ * Moves the given container to the currently focused container on the given
+ * workspace.
+ *
+ * The fix_coordinates flag will translate the current coordinates (offset from
+ * the monitor position basically) to appropriate coordinates on the
+ * destination workspace.
+ * Not enabling this behaviour comes in handy when this function gets called by
+ * floating_maybe_reassign_ws, which will only "move" a floating window when it
+ * *already* changed its coordinates to a different output.
+ *
+ * The dont_warp flag disables pointer warping and will be set when this
+ * function is called while dragging a floating window.
+ *
+ * If ignore_focus is set, the container will be moved without modifying focus
+ * at all.
+ *
+ * TODO: is there a better place for this function?
+ *
+ */
+void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp, bool ignore_focus) {
+ assert(workspace->type == CT_WORKSPACE);
+
+ Con *source_ws = con_get_workspace(con);
+ if (workspace == source_ws) {
+ DLOG("Not moving, already there\n");
+ return;
+ }
+
+ Con *target = con_descend_focused(workspace);
+ _con_move_to_con(con, target, true, fix_coordinates, dont_warp, ignore_focus, true);
+}
+
+/*
+ * Moves the given container to the currently focused container on the
+ * visible workspace on the given output.
+ *
+ */
+void con_move_to_output(Con *con, Output *output) {
+ Con *ws = NULL;
+ GREP_FIRST(ws, output_get_content(output->con), workspace_is_visible(child));
+ assert(ws != NULL);
+ DLOG("Moving con %p to output %s\n", con, output->name);
+ con_move_to_workspace(con, ws, false, false, false);
}
/*
/*
* Returns the container which will be focused next when the given container
- * is not available anymore. Called in tree_close and con_move_to_workspace
+ * is not available anymore. Called in tree_close_internal and con_move_to_workspace
* to properly restore focus.
*
*/
} else {
/* try to focus the next container on the same level as this one or fall
* back to its parent */
- if (!(next = TAILQ_NEXT(con, focused)))
+ if (!(next = TAILQ_NEXT(con, focused))) {
next = con->parent;
+ }
}
/* now go down the focus stack as far as
* possible, excluding the current container */
- while (!TAILQ_EMPTY(&(next->focus_head)) &&
- TAILQ_FIRST(&(next->focus_head)) != con)
+ while (!TAILQ_EMPTY(&(next->focus_head)) && TAILQ_FIRST(&(next->focus_head)) != con) {
next = TAILQ_FIRST(&(next->focus_head));
+ }
return next;
}
*
*/
Rect con_border_style_rect(Con *con) {
+ if (config.hide_edge_borders == HEBM_SMART && con_num_visible_children(con_get_workspace(con)) <= 1) {
+ if (!con_is_floating(con)) {
+ return (Rect){0, 0, 0, 0};
+ }
+ }
+
adjacent_t borders_to_hide = ADJ_NONE;
int border_width = con->current_border_width;
DLOG("The border width for con is set to: %d\n", con->current_border_width);
int border_style = con_border_style(con);
if (border_style == BS_NONE)
return (Rect){0, 0, 0, 0};
- borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders;
if (border_style == BS_NORMAL) {
result = (Rect){border_width, 0, -(2 * border_width), -(border_width)};
} else {
result = (Rect){border_width, border_width, -(2 * border_width), -(2 * border_width)};
}
- /* Floating windows are never adjacent to any other window, so
- don’t hide their border(s). This prevents bug #998. */
- if (con_is_floating(con))
- return result;
-
+ borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders;
if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) {
result.x -= border_width;
result.width += border_width;
*/
adjacent_t con_adjacent_borders(Con *con) {
adjacent_t result = ADJ_NONE;
+ /* Floating windows are never adjacent to any other window, so
+ don’t hide their border(s). This prevents bug #998. */
+ if (con_is_floating(con))
+ return result;
+
Con *workspace = con_get_workspace(con);
if (con->rect.x == workspace->rect.x)
result |= ADJ_LEFT_SCREEN_EDGE;
* whole workspace into stacked/tabbed mode. To do this and still allow
* intuitive operations (like level-up and then opening a new window), we
* need to create a new split container. */
- if (con->type == CT_WORKSPACE &&
- (layout == L_STACKED || layout == L_TABBED)) {
+ if (con->type == CT_WORKSPACE) {
if (con_num_children(con) == 0) {
- DLOG("Setting workspace_layout to %d\n", layout);
- con->workspace_layout = layout;
- } else {
+ layout_t ws_layout = (layout == L_STACKED || layout == L_TABBED) ? layout : L_DEFAULT;
+ DLOG("Setting workspace_layout to %d\n", ws_layout);
+ con->workspace_layout = ws_layout;
+ DLOG("Setting layout to %d\n", layout);
+ con->layout = layout;
+ } else if (layout == L_STACKED || layout == L_TABBED) {
DLOG("Creating new split container\n");
/* 1: create a new split container */
Con *new = con_new(NULL, NULL);
* with an orientation). Since we switched to splith/splitv layouts,
* using the "default" layout (which "only" should happen when using
* legacy configs) is using the last split layout (either splith or
- * splitv) in order to still do the same thing.
- *
- * Starting from v4.6 though, we will nag users about using "layout
- * default", and in v4.9 we will remove it entirely (with an
- * appropriate i3-migrate-config mechanism). */
+ * splitv) in order to still do the same thing. */
con->layout = con->last_split_layout;
/* In case last_split_layout was not initialized… */
if (con->layout == L_DEFAULT)
parent = con->parent;
DLOG("con_toggle_layout(%p, %s), parent = %p\n", con, toggle_mode, parent);
- if (strcmp(toggle_mode, "split") == 0) {
- /* Toggle between splits. When the current layout is not a split
- * layout, we just switch back to last_split_layout. Otherwise, we
- * change to the opposite split layout. */
- if (parent->layout != L_SPLITH && parent->layout != L_SPLITV)
- con_set_layout(con, parent->last_split_layout);
- else {
- if (parent->layout == L_SPLITH)
- con_set_layout(con, L_SPLITV);
- else
- con_set_layout(con, L_SPLITH);
+ const char delim[] = " ";
+
+ if (strcasecmp(toggle_mode, "split") == 0 || strstr(toggle_mode, delim)) {
+ /* L_DEFAULT is used as a placeholder value to distinguish if
+ * the first layout has already been saved. (it can never be L_DEFAULT) */
+ layout_t new_layout = L_DEFAULT;
+ bool current_layout_found = false;
+ char *tm_dup = sstrdup(toggle_mode);
+ char *cur_tok = strtok(tm_dup, delim);
+
+ for (layout_t layout; cur_tok != NULL; cur_tok = strtok(NULL, delim)) {
+ if (strcasecmp(cur_tok, "split") == 0) {
+ /* Toggle between splits. When the current layout is not a split
+ * layout, we just switch back to last_split_layout. Otherwise, we
+ * change to the opposite split layout. */
+ if (parent->layout != L_SPLITH && parent->layout != L_SPLITV) {
+ layout = parent->last_split_layout;
+ } else {
+ layout = (parent->layout == L_SPLITH) ? L_SPLITV : L_SPLITH;
+ }
+ } else {
+ bool success = layout_from_name(cur_tok, &layout);
+ if (!success || layout == L_DEFAULT) {
+ ELOG("The token '%s' was not recognized and has been skipped.\n", cur_tok);
+ continue;
+ }
+ }
+
+ /* If none of the specified layouts match the current,
+ * fall back to the first layout in the list */
+ if (new_layout == L_DEFAULT) {
+ new_layout = layout;
+ }
+
+ /* We found the active layout in the last iteration, so
+ * now let's activate the current layout (next in list) */
+ if (current_layout_found) {
+ new_layout = layout;
+ free(tm_dup);
+ break;
+ }
+
+ if (parent->layout == layout) {
+ current_layout_found = true;
+ }
}
- } else {
+
+ con_set_layout(con, new_layout);
+ } else if (strcasecmp(toggle_mode, "all") == 0 || strcasecmp(toggle_mode, "default") == 0) {
if (parent->layout == L_STACKED)
con_set_layout(con, L_TABBED);
else if (parent->layout == L_TABBED) {
- if (strcmp(toggle_mode, "all") == 0)
+ if (strcasecmp(toggle_mode, "all") == 0)
con_set_layout(con, L_SPLITH);
else
con_set_layout(con, parent->last_split_layout);
} else if (parent->layout == L_SPLITH || parent->layout == L_SPLITV) {
- if (strcmp(toggle_mode, "all") == 0) {
+ if (strcasecmp(toggle_mode, "all") == 0) {
/* When toggling through all modes, we toggle between
* splith/splitv, whereas normally we just directly jump to
* stacked. */
if (TAILQ_EMPTY(&(con->focus_head)) && !workspace_is_visible(con)) {
LOG("Closing old workspace (%p / %s), it is empty\n", con, con->name);
yajl_gen gen = ipc_marshal_workspace_event("empty", con, NULL);
- tree_close(con, DONT_KILL_WINDOW, false, false);
+ tree_close_internal(con, DONT_KILL_WINDOW, false, false);
const unsigned char *payload;
ylength length;
int children = con_num_children(con);
if (children == 0) {
DLOG("Container empty, closing\n");
- tree_close(con, DONT_KILL_WINDOW, false, false);
+ tree_close_internal(con, DONT_KILL_WINDOW, false, false);
return;
}
}
void con_update_parents_urgency(Con *con) {
Con *parent = con->parent;
+ /* Urgency hints should not be set on any container higher up in the
+ * hierarchy than the workspace level. Unfortunately, since the content
+ * container has type == CT_CON, that’s not easy to verify in the loop
+ * below, so we need another condition to catch that case: */
+ if (con->type == CT_WORKSPACE)
+ return;
+
bool new_urgency_value = con->urgent;
while (parent && parent->type != CT_WORKSPACE && parent->type != CT_DOCKAREA) {
if (new_urgency_value) {
*
*/
void con_set_urgency(Con *con, bool urgent) {
- if (focused == con) {
+ if (urgent && focused == con) {
DLOG("Ignoring urgency flag for current client\n");
- con->window->urgent.tv_sec = 0;
- con->window->urgent.tv_usec = 0;
return;
}
+ const bool old_urgent = con->urgent;
+
if (con->urgency_timer == NULL) {
con->urgent = urgent;
} else
if ((ws = con_get_workspace(con)) != NULL)
workspace_update_urgent_flag(ws);
- if (con->urgent == urgent) {
+ if (con->urgent != old_urgent) {
LOG("Urgency flag changed to %d\n", con->urgent);
ipc_send_window_event("urgent", con);
}
(TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt);
free(buf);
buf = tmp_buf;
+ free(child_txt);
}
/* 3) close the brackets */
return complete_buf;
}
+
+/*
+ * Returns the container's title considering the current title format.
+ *
+ */
+i3String *con_parse_title_format(Con *con) {
+ assert(con->title_format != NULL);
+
+ i3Window *win = con->window;
+
+ /* We need to ensure that we only escape the window title if pango
+ * is used by the current font. */
+ const bool pango_markup = font_is_pango();
+
+ char *title;
+ char *class;
+ char *instance;
+ if (win == NULL) {
+ title = pango_escape_markup(con_get_tree_representation(con));
+ class = sstrdup("i3-frame");
+ instance = sstrdup("i3-frame");
+ } else {
+ title = pango_escape_markup(sstrdup((win->name == NULL) ? "" : i3string_as_utf8(win->name)));
+ class = pango_escape_markup(sstrdup((win->class_class == NULL) ? "" : win->class_class));
+ instance = pango_escape_markup(sstrdup((win->class_instance == NULL) ? "" : win->class_instance));
+ }
+
+ placeholder_t placeholders[] = {
+ {.name = "%title", .value = title},
+ {.name = "%class", .value = class},
+ {.name = "%instance", .value = instance}};
+ const size_t num = sizeof(placeholders) / sizeof(placeholder_t);
+
+ char *formatted_str = format_placeholders(con->title_format, &placeholders[0], num);
+ i3String *formatted = i3string_from_utf8(formatted_str);
+ i3string_set_markup(formatted, pango_markup);
+ FREE(formatted_str);
+
+ for (size_t i = 0; i < num; i++) {
+ FREE(placeholders[i].value);
+ }
+
+ return formatted;
+}
+
+/*
+ * Swaps the two containers.
+ *
+ */
+bool con_swap(Con *first, Con *second) {
+ assert(first != NULL);
+ assert(second != NULL);
+ DLOG("Swapping containers %p / %p\n", first, second);
+
+ if (first->type != CT_CON) {
+ ELOG("Only regular containers can be swapped, but found con = %p with type = %d.\n", first, first->type);
+ return false;
+ }
+
+ if (second->type != CT_CON) {
+ ELOG("Only regular containers can be swapped, but found con = %p with type = %d.\n", second, second->type);
+ return false;
+ }
+
+ if (con_is_floating(first) || con_is_floating(second)) {
+ ELOG("Floating windows cannot be swapped.\n");
+ return false;
+ }
+
+ if (first == second) {
+ DLOG("Swapping container %p with itself, nothing to do.\n", first);
+ return false;
+ }
+
+ if (con_has_parent(first, second) || con_has_parent(second, first)) {
+ ELOG("Cannot swap containers %p and %p because they are in a parent-child relationship.\n", first, second);
+ return false;
+ }
+
+ Con *old_focus = focused;
+
+ Con *first_ws = con_get_workspace(first);
+ Con *second_ws = con_get_workspace(second);
+ Con *current_ws = con_get_workspace(old_focus);
+ const bool focused_within_first = (first == old_focus || con_has_parent(old_focus, first));
+ const bool focused_within_second = (second == old_focus || con_has_parent(old_focus, second));
+
+ if (!con_fullscreen_permits_focusing(first_ws)) {
+ DLOG("Cannot swap because target workspace \"%s\" is obscured.\n", first_ws->name);
+ return false;
+ }
+
+ if (!con_fullscreen_permits_focusing(second_ws)) {
+ DLOG("Cannot swap because target workspace \"%s\" is obscured.\n", second_ws->name);
+ return false;
+ }
+
+ double first_percent = first->percent;
+ double second_percent = second->percent;
+
+ /* De- and reattaching the containers will insert them at the tail of the
+ * focus_heads. We will need to fix this. But we need to make sure first
+ * and second don't get in each other's way if they share the same parent,
+ * so we select the closest previous focus_head that isn't involved. */
+ Con *first_prev_focus_head = first;
+ while (first_prev_focus_head == first || first_prev_focus_head == second) {
+ first_prev_focus_head = TAILQ_PREV(first_prev_focus_head, focus_head, focused);
+ }
+
+ Con *second_prev_focus_head = second;
+ while (second_prev_focus_head == second || second_prev_focus_head == first) {
+ second_prev_focus_head = TAILQ_PREV(second_prev_focus_head, focus_head, focused);
+ }
+
+ /* We use a fake container to mark the spot of where the second container needs to go. */
+ Con *fake = con_new(NULL, NULL);
+ fake->layout = L_SPLITH;
+ _con_attach(fake, first->parent, first, true);
+
+ bool result = true;
+ /* Swap the containers. We set the ignore_focus flag here because after the
+ * container is attached, the focus order is not yet correct and would
+ * result in wrong windows being focused. */
+
+ /* Move first to second. */
+ result &= _con_move_to_con(first, second, false, false, false, true, false);
+
+ /* If we moved the container holding the focused window to another
+ * workspace we need to ensure the visible workspace has the focused
+ * container.
+ * We don't need to check this for the second container because we've only
+ * moved the first one at this point.*/
+ if (first_ws != second_ws && focused_within_first) {
+ con_focus(con_descend_focused(current_ws));
+ }
+
+ /* Move second to where first has been originally. */
+ result &= _con_move_to_con(second, fake, false, false, false, true, false);
+
+ /* If swapping the containers didn't work we don't need to mess with the focus. */
+ if (!result) {
+ goto swap_end;
+ }
+
+ /* Swapping will have inserted the containers at the tail of their parents'
+ * focus head. We fix this now by putting them in the position of the focus
+ * head the container they swapped with was in. */
+ TAILQ_REMOVE(&(first->parent->focus_head), first, focused);
+ TAILQ_REMOVE(&(second->parent->focus_head), second, focused);
+
+ if (second_prev_focus_head == NULL) {
+ TAILQ_INSERT_HEAD(&(first->parent->focus_head), first, focused);
+ } else {
+ TAILQ_INSERT_AFTER(&(first->parent->focus_head), second_prev_focus_head, first, focused);
+ }
+
+ if (first_prev_focus_head == NULL) {
+ TAILQ_INSERT_HEAD(&(second->parent->focus_head), second, focused);
+ } else {
+ TAILQ_INSERT_AFTER(&(second->parent->focus_head), first_prev_focus_head, second, focused);
+ }
+
+ /* If the focus was within any of the swapped containers, do the following:
+ * - If swapping took place within a workspace, ensure the previously
+ * focused container stays focused.
+ * - Otherwise, focus the container that has been swapped in.
+ *
+ * To understand why fixing the focus_head previously wasn't enough,
+ * consider the scenario
+ * H[ V[ A X ] V[ Y B ] ]
+ * with B being focused, but X being the focus_head within its parent. If
+ * we swap A and B now, fixing the focus_head would focus X, but since B
+ * was the focused container before it should stay focused.
+ */
+ if (focused_within_first) {
+ if (first_ws == second_ws) {
+ con_focus(old_focus);
+ } else {
+ con_focus(con_descend_focused(second));
+ }
+ } else if (focused_within_second) {
+ if (first_ws == second_ws) {
+ con_focus(old_focus);
+ } else {
+ con_focus(con_descend_focused(first));
+ }
+ }
+
+ /* We need to copy each other's percentages to ensure that the geometry
+ * doesn't change during the swap. This needs to happen _before_ we close
+ * the fake container as closing the tree will recalculate percentages. */
+ first->percent = second_percent;
+ second->percent = first_percent;
+ fake->percent = 0.0;
+
+swap_end:
+ /* We don't actually need this since percentages-wise we haven't changed
+ * anything, but we'll better be safe than sorry and just make sure as we'd
+ * otherwise crash i3. */
+ con_fix_percent(first->parent);
+ con_fix_percent(second->parent);
+
+ /* We can get rid of the fake container again now. */
+ con_close(fake, DONT_KILL_WINDOW);
+
+ con_force_split_parents_redraw(first);
+ con_force_split_parents_redraw(second);
+
+ return result;
+}
projects / i3 / i3 / blobdiff