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;
}
}
return new;
}
+/*
+ * Frees the specified container.
+ *
+ */
+void con_free(Con *con) {
+ free(con->name);
+ FREE(con->deco_render_params);
+ TAILQ_REMOVE(&all_cons, con, all_cons);
+ while (!TAILQ_EMPTY(&(con->swallow_head))) {
+ Match *match = TAILQ_FIRST(&(con->swallow_head));
+ TAILQ_REMOVE(&(con->swallow_head), match, matches);
+ match_free(match);
+ free(match);
+ }
+ while (!TAILQ_EMPTY(&(con->marks_head))) {
+ mark_t *mark = TAILQ_FIRST(&(con->marks_head));
+ TAILQ_REMOVE(&(con->marks_head), mark, marks);
+ FREE(mark->name);
+ FREE(mark);
+ }
+ free(con);
+ DLOG("con %p freed\n", con);
+}
+
static void _con_attach(Con *con, Con *parent, Con *previous, bool ignore_focus) {
con->parent = parent;
Con *loop;
/* 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) {
+ 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
workspace_update_urgent_flag(con_get_workspace(con));
ipc_send_window_event("urgent", con);
}
+
+ /* Focusing a container with a floating parent should raise it to the top. Since
+ * con_focus is called recursively for each parent we don't need to use
+ * con_inside_floating(). */
+ if (con->type == CT_FLOATING_CON) {
+ floating_raise_con(con);
+ }
}
/*
}
/*
- * Searches parenst of the given 'con' until it reaches one with the specified
+ * Searches parents of the given 'con' until it reaches one with the specified
* 'orientation'. Aborts when it comes across a floating_con.
*
*/
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.
return NULL;
}
+/*
+ * Returns the container with the given container ID or NULL if no such
+ * container exists.
+ *
+ */
+Con *con_by_con_id(long target) {
+ Con *con;
+ TAILQ_FOREACH(con, &all_cons, all_cons) {
+ if (con == (Con *)target) {
+ return con;
+ }
+ }
+
+ return NULL;
+}
+
/*
* Returns the container with the given frame ID or NULL if no such container
* exists.
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;
+ }
}
}
con_set_fullscreen_mode(con, CF_NONE);
}
-static bool _con_move_to_con(Con *con, Con *target, bool behind_focused, bool fix_coordinates, bool dont_warp, bool ignore_focus) {
+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. */
_con_attach(con, target, behind_focused ? NULL : orig_target, !behind_focused);
/* 5: fix the percentages */
- con_fix_percent(parent);
- con->percent = 0.0;
- con_fix_percent(target);
+ if (fix_percentage) {
+ con_fix_percent(parent);
+ con->percent = 0.0;
+ con_fix_percent(target);
+ }
/* 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
/* 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. */
- if (!ignore_focus)
+ if (!ignore_focus) {
workspace_show(current_ws);
+ if (dont_warp) {
+ DLOG("x_set_warp_to(NULL) because dont_warp is set\n");
+ x_set_warp_to(NULL);
+ }
+ }
/* Set focus only if con was on current workspace before moving.
* Otherwise we would give focus to some window on different workspace. */
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);
target = TAILQ_FIRST(&(target->focus_head));
}
- if (con == target || con == target->parent) {
+ 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);
+ return _con_move_to_con(con, target, false, true, false, false, true);
}
/*
}
Con *target = con_descend_focused(workspace);
- _con_move_to_con(con, target, true, fix_coordinates, dont_warp, ignore_focus);
+ _con_move_to_con(con, target, true, fix_coordinates, dont_warp, ignore_focus, true);
}
/*
* visible workspace on the given output.
*
*/
-void con_move_to_output(Con *con, Output *output) {
+void con_move_to_output(Con *con, Output *output, bool fix_coordinates) {
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);
+ DLOG("Moving con %p to output %s\n", con, output_primary_name(output));
+ con_move_to_workspace(con, ws, fix_coordinates, false, false);
+}
+
+/*
+ * Moves the given container to the currently focused container on the
+ * visible workspace on the output specified by the given name.
+ * The current output for the container is used to resolve relative names
+ * such as left, right, up, down.
+ *
+ */
+bool con_move_to_output_name(Con *con, const char *name, bool fix_coordinates) {
+ Output *current_output = get_output_for_con(con);
+ assert(current_output != NULL);
+
+ Output *output = get_output_from_string(current_output, name);
+ if (output == NULL) {
+ ELOG("Could not find output \"%s\"\n", name);
+ return false;
+ }
+
+ con_move_to_output(con, output, fix_coordinates);
+ return true;
}
/*
} 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;
}
* 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);
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 {
+
+ if (new_layout != L_DEFAULT) {
+ 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. */
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));
+ fullscreen_mode_t first_fullscreen_mode = first->fullscreen_mode;
+ fullscreen_mode_t second_fullscreen_mode = second->fullscreen_mode;
+
+ if (first_fullscreen_mode != CF_NONE) {
+ con_disable_fullscreen(first);
+ }
+ if (second_fullscreen_mode != CF_NONE) {
+ con_disable_fullscreen(second);
+ }
+
+ 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(first_fullscreen_mode, second_fullscreen_mode, fullscreen_mode_t);
+
+swap_end:
+ /* The two windows exchange their original fullscreen status */
+ if (first_fullscreen_mode != CF_NONE) {
+ con_enable_fullscreen(first, first_fullscreen_mode);
+ }
+ if (second_fullscreen_mode != CF_NONE) {
+ con_enable_fullscreen(second, second_fullscreen_mode);
+ }
+
+ /* 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