new->current_border_width = -1;
if (window) {
new->depth = window->depth;
- new->window->aspect_ratio = 0.0;
} else {
new->depth = root_depth;
}
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);
+ tree_close_internal(child, kill_window, false);
child = nextchild;
}
return;
}
- tree_close_internal(con, kill_window, false, false);
+ tree_close_internal(con, kill_window, false);
}
/*
return (con != NULL && con->window != NULL && con->window->id != XCB_WINDOW_NONE && con_get_workspace(con) != NULL);
}
-/**
+/*
* Returns true if this node has regular or floating children.
*
*/
return NULL;
}
-/**
+/*
+ * Returns the fullscreen node that covers the given workspace if it exists.
+ * This is either a CF_GLOBAL fullscreen container anywhere or a CF_OUTPUT
+ * fullscreen container in the workspace.
+ *
+ */
+Con *con_get_fullscreen_covering_ws(Con *ws) {
+ if (!ws) {
+ return NULL;
+ }
+ Con *fs = con_get_fullscreen_con(croot, CF_GLOBAL);
+ if (!fs) {
+ return con_get_fullscreen_con(ws, CF_OUTPUT);
+ }
+ return fs;
+}
+
+/*
* Returns true if the container is internal, such as __i3_scratch
*
*/
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.
num += con_num_windows(current);
}
+ TAILQ_FOREACH(current, &(con->floating_head), floating_windows) {
+ num += con_num_windows(current);
+ }
+
return num;
}
/* Prevent moving if this would violate the fullscreen focus restrictions. */
Con *target_ws = con_get_workspace(target);
- if (!con_fullscreen_permits_focusing(target_ws)) {
+ if (!ignore_focus && !con_fullscreen_permits_focusing(target_ws)) {
LOG("Cannot move out of a fullscreen container.\n");
return false;
}
/* 1: save the container which is going to be focused after the current
* container is moved away */
- Con *focus_next = con_next_focused(con);
+ Con *focus_next = NULL;
+ if (!ignore_focus && source_ws == current_ws) {
+ focus_next = con_descend_focused(source_ws);
+ if (focus_next == con || con_has_parent(focus_next, con)) {
+ focus_next = con_next_focused(con);
+ }
+ }
/* 2: we go up one level, but only when target is a normal container */
if (target->type != CT_WORKSPACE) {
target = target->parent;
}
- /* 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(target);
- if (floatingcon != NULL) {
+ /* 3: if the original target is the direct child of a floating container, we
+ * can't move con next to it - floating containers have only one child - so
+ * we get the workspace instead. */
+ if (target->type == CT_FLOATING_CON) {
DLOG("floatingcon, going up even further\n");
- target = floatingcon->parent;
+ orig_target = target;
+ target = target->parent;
}
if (con->type == CT_FLOATING_CON) {
/* 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 *old_focus = TAILQ_FIRST(&(output_get_content(dest_output)->focus_head));
+ Con *old_focus_ws = TAILQ_FIRST(&(output_get_content(dest_output)->focus_head));
+ Con *old_focus = focused;
con_activate(con_descend_focused(con));
- /* Restore focus if the output's focused workspace has changed. */
- if (con_get_workspace(focused) != old_focus)
+ if (old_focus_ws == current_ws && old_focus->type != CT_WORKSPACE) {
+ /* Restore focus to the currently focused container. */
con_activate(old_focus);
+ } else if (con_get_workspace(focused) != old_focus_ws) {
+ /* Restore focus if the output's focused workspace has changed. */
+ con_focus(con_descend_focused(old_focus_ws));
+ }
}
/* 7: when moving to another workspace, we leave the focus on the current
/* Set focus only if con was on current workspace before moving.
* Otherwise we would give focus to some window on different workspace. */
- if (!ignore_focus && source_ws == current_ws)
+ if (focus_next)
con_activate(con_descend_focused(focus_next));
/* 8. If anything within the container is associated with a startup sequence,
return true;
}
- if (con->type == CT_WORKSPACE) {
+ if (target->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;
return HORIZ;
case L_DEFAULT:
- DLOG("Someone called con_orientation() on a con with L_DEFAULT, this is a bug in the code.\n");
+ ELOG("Someone called con_orientation() on a con with L_DEFAULT, this is a bug in the code.\n");
assert(false);
- return HORIZ;
case L_DOCKAREA:
case L_OUTPUT:
- DLOG("con_orientation() called on dockarea/output (%d) container %p\n", con->layout, con);
- assert(false);
- return HORIZ;
-
- default:
- DLOG("con_orientation() ran into default\n");
+ ELOG("con_orientation() called on dockarea/output (%d) container %p\n", con->layout, con);
assert(false);
}
+ /* should not be reached */
+ assert(false);
}
/*
*
*/
Con *con_next_focused(Con *con) {
- Con *next;
- /* floating containers are attached to a workspace, so we focus either the
- * next floating container (if any) or the workspace itself. */
- if (con->type == CT_FLOATING_CON) {
- DLOG("selecting next for CT_FLOATING_CON\n");
- next = TAILQ_NEXT(con, floating_windows);
- DLOG("next = %p\n", next);
- if (!next) {
- next = TAILQ_PREV(con, floating_head, floating_windows);
- DLOG("using prev, next = %p\n", next);
- }
- if (!next) {
- Con *ws = con_get_workspace(con);
- next = ws;
- DLOG("no more floating containers for next = %p, restoring workspace focus\n", next);
- while (next != TAILQ_END(&(ws->focus_head)) && !TAILQ_EMPTY(&(next->focus_head))) {
- next = TAILQ_FIRST(&(next->focus_head));
- if (next == con) {
- DLOG("skipping container itself, we want the next client\n");
- next = TAILQ_NEXT(next, focused);
- }
- }
- if (next == TAILQ_END(&(ws->focus_head))) {
- DLOG("Focus list empty, returning ws\n");
- next = ws;
- }
- } else {
- /* Instead of returning the next CT_FLOATING_CON, we descend it to
- * get an actual window to focus. */
- next = con_descend_focused(next);
- }
- return next;
- }
-
/* dock clients cannot be focused, so we focus the workspace instead */
if (con->parent->type == CT_DOCKAREA) {
DLOG("selecting workspace for dock client\n");
return con_descend_focused(output_get_content(con->parent->parent));
}
+ if (con_is_floating(con)) {
+ con = con->parent;
+ }
/* if 'con' is not the first entry in the focus stack, use the first one as
* it’s currently focused already */
- Con *first = TAILQ_FIRST(&(con->parent->focus_head));
- if (first != con) {
- DLOG("Using first entry %p\n", first);
- next = first;
+ Con *next = TAILQ_FIRST(&(con->parent->focus_head));
+ if (next != con) {
+ DLOG("Using first entry %p\n", next);
} else {
/* try to focus the next container on the same level as this one or fall
* back to its parent */
next = TAILQ_FIRST(&(next->focus_head));
}
- return next;
-}
-
-/*
- * Get the next/previous container in the specified orientation. This may
- * travel up until it finds a container with suitable orientation.
- *
- */
-Con *con_get_next(Con *con, char way, orientation_t orientation) {
- DLOG("con_get_next(way=%c, orientation=%d)\n", way, orientation);
- /* 1: get the first parent with the same orientation */
- Con *cur = con;
- while (con_orientation(cur->parent) != orientation) {
- DLOG("need to go one level further up\n");
- if (cur->parent->type == CT_WORKSPACE) {
- LOG("that's a workspace, we can't go further up\n");
- return NULL;
- }
- cur = cur->parent;
- }
-
- /* 2: chose next (or previous) */
- Con *next;
- if (way == 'n') {
- next = TAILQ_NEXT(cur, nodes);
- /* if we are at the end of the list, we need to wrap */
- if (next == TAILQ_END(&(parent->nodes_head)))
- return NULL;
- } else {
- next = TAILQ_PREV(cur, nodes_head, nodes);
- /* if we are at the end of the list, we need to wrap */
- if (next == TAILQ_END(&(cur->nodes_head)))
- return NULL;
+ if (con->type == CT_FLOATING_CON && next != con->parent) {
+ next = con_descend_focused(next);
}
- DLOG("next = %p\n", next);
return next;
}
*
*/
int con_border_style(Con *con) {
- Con *fs = con_get_fullscreen_con(con->parent, CF_OUTPUT);
- if (fs == con) {
+ if (con->fullscreen_mode == CF_OUTPUT || con->fullscreen_mode == CF_GLOBAL) {
DLOG("this one is fullscreen! overriding BS_NONE\n");
return BS_NONE;
}
* now let's activate the current layout (next in list) */
if (current_layout_found) {
new_layout = layout;
- free(tm_dup);
break;
}
current_layout_found = true;
}
}
+ free(tm_dup);
if (new_layout != L_DEFAULT) {
con_set_layout(con, new_layout);
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_internal(con, DONT_KILL_WINDOW, false, false);
+ tree_close_internal(con, DONT_KILL_WINDOW, false);
const unsigned char *payload;
ylength length;
int children = con_num_children(con);
if (children == 0) {
DLOG("Container empty, closing\n");
- tree_close_internal(con, DONT_KILL_WINDOW, false, false);
+ tree_close_internal(con, DONT_KILL_WINDOW, false);
return;
}
}
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;
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_activate(con_descend_focused(current_ws));
- }
+ Con *ws1 = con_get_workspace(first);
+ Con *ws2 = con_get_workspace(second);
+ Con *restore_focus = NULL;
+ if (ws1 == ws2 && ws1 == con_get_workspace(focused)) {
+ /* Preserve focus in the current workspace. */
+ restore_focus = focused;
+ } else if (first == focused || con_has_parent(focused, first)) {
+ restore_focus = second;
+ } else if (second == focused || con_has_parent(focused, second)) {
+ restore_focus = first;
+ }
+
+#define SWAP_CONS_IN_TREE(headname, field) \
+ do { \
+ struct headname *head1 = &(first->parent->headname); \
+ struct headname *head2 = &(second->parent->headname); \
+ Con *first_prev = TAILQ_PREV(first, headname, field); \
+ Con *second_prev = TAILQ_PREV(second, headname, field); \
+ if (second_prev == first) { \
+ TAILQ_SWAP(first, second, head1, field); \
+ } else if (first_prev == second) { \
+ TAILQ_SWAP(second, first, head1, field); \
+ } else { \
+ TAILQ_REMOVE(head1, first, field); \
+ TAILQ_REMOVE(head2, second, field); \
+ if (second_prev == NULL) { \
+ TAILQ_INSERT_HEAD(head2, first, field); \
+ } else { \
+ TAILQ_INSERT_AFTER(head2, second_prev, first, field); \
+ } \
+ if (first_prev == NULL) { \
+ TAILQ_INSERT_HEAD(head1, second, field); \
+ } else { \
+ TAILQ_INSERT_AFTER(head1, first_prev, second, field); \
+ } \
+ } \
+ } while (0)
+
+ SWAP_CONS_IN_TREE(nodes_head, nodes);
+ SWAP_CONS_IN_TREE(focus_head, focused);
+ SWAP(first->parent, second->parent, Con *);
+
+ /* Floating nodes are children of CT_FLOATING_CONs, they are listed in
+ * nodes_head and focus_head like all other containers. Thus, we don't need
+ * to do anything special other than swapping the floating status and the
+ * relevant rects. */
+ SWAP(first->floating, second->floating, int);
+ SWAP(first->rect, second->rect, Rect);
+ SWAP(first->window_rect, second->window_rect, Rect);
- /* Move second to where first has been originally. */
- result &= _con_move_to_con(second, fake, false, false, false, true, false);
+ /* We need to copy each other's percentages to ensure that the geometry
+ * doesn't change during the swap. */
+ SWAP(first->percent, second->percent, double);
- /* If swapping the containers didn't work we don't need to mess with the focus. */
- if (!result) {
- goto swap_end;
+ if (restore_focus) {
+ con_focus(restore_focus);
}
- /* 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);
+ /* Update new parents' & workspaces' urgency. */
+ con_set_urgency(first, first->urgent);
+ con_set_urgency(second, second->urgent);
- if (second_prev_focus_head == NULL) {
- TAILQ_INSERT_HEAD(&(first->parent->focus_head), first, focused);
+ /* Exchange fullscreen modes, can't use SWAP because we need to call the
+ * correct functions. */
+ fullscreen_mode_t second_fullscreen_mode = second->fullscreen_mode;
+ if (first->fullscreen_mode == CF_NONE) {
+ con_disable_fullscreen(second);
} else {
- TAILQ_INSERT_AFTER(&(first->parent->focus_head), second_prev_focus_head, first, focused);
+ con_enable_fullscreen(second, first->fullscreen_mode);
}
-
- if (first_prev_focus_head == NULL) {
- TAILQ_INSERT_HEAD(&(second->parent->focus_head), second, focused);
+ if (second_fullscreen_mode == CF_NONE) {
+ con_disable_fullscreen(first);
} 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_activate(old_focus);
- } else {
- con_activate(con_descend_focused(second));
- }
- } else if (focused_within_second) {
- if (first_ws == second_ws) {
- con_activate(old_focus);
- } else {
- con_activate(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);
+ con_enable_fullscreen(first, second_fullscreen_mode);
}
/* We don't actually need this since percentages-wise we haven't changed
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;
+ return true;
+}
+
+/*
+ * Returns container's rect size depending on its orientation.
+ * i.e. its width when horizontal, its height when vertical.
+ *
+ */
+uint32_t con_rect_size_in_orientation(Con *con) {
+ return (con_orientation(con) == HORIZ ? con->rect.width : con->rect.height);
}