X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcon.c;h=cebe0a7e7a473a49054cc14c1db468d5b3920399;hb=ede954128afca118025db6a04d4d9d259473c70f;hp=282c389f694c78e1a735fa193e2bcb9172ecca37;hpb=cc09348414472e68287ab918df57158552146f72;p=i3%2Fi3 diff --git a/src/con.c b/src/con.c index 282c389f..ca65a150 100644 --- a/src/con.c +++ b/src/con.c @@ -1,10 +1,8 @@ -#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, @@ -13,18 +11,22 @@ */ #include "all.h" +#include "yajl_utils.h" + static void con_on_remove_child(Con *con); /* * force parent split containers to be redrawn * */ -static void con_force_split_parents_redraw(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; } } @@ -35,24 +37,26 @@ static void con_force_split_parents_redraw(Con *con) { * */ 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); @@ -65,24 +69,38 @@ Con *con_new_skeleton(Con *parent, i3Window *window) { */ 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). + * Frees the specified container. * */ -void con_attach(Con *con, Con *parent, bool ignore_focus) { +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; - Con *current = NULL; + Con *current = previous; struct nodes_head *nodes_head = &(parent->nodes_head); struct focus_head *focus_head = &(parent->focus_head); @@ -153,9 +171,8 @@ void con_attach(Con *con, Con *parent, bool ignore_focus) { /* 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); @@ -169,6 +186,20 @@ add_to_focus_head: 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 * @@ -207,13 +238,64 @@ void con_focus(Con *con) { * 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); } } +/* + * Raise container to the top if it is floating or inside some floating + * container. + * + */ +static void con_raise(Con *con) { + Con *floating = con_inside_floating(con); + if (floating) { + floating_raise_con(floating); + } +} + +/* + * Sets input focus to the given container and raises it to the top. + * + */ +void con_activate(Con *con) { + con_focus(con); + con_raise(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); + child = nextchild; + } + + return; + } + + tree_close_internal(con, kill_window, false); +} + /* * Returns true when this node is a leaf node (has no children) * @@ -256,6 +338,46 @@ bool con_is_split(Con *con) { } } +/* + * 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). @@ -302,7 +424,7 @@ Con *con_get_workspace(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. * */ @@ -335,7 +457,8 @@ Con *con_parent_with_orientation(Con *con, orientation_t orientation) { struct bfs_entry { Con *con; - TAILQ_ENTRY(bfs_entry) entries; + TAILQ_ENTRY(bfs_entry) + entries; }; /* @@ -347,7 +470,9 @@ Con *con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode) { /* 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); @@ -384,6 +509,23 @@ Con *con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode) { 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 * @@ -402,6 +544,20 @@ bool con_is_floating(Con *con) { 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. @@ -433,6 +589,23 @@ bool con_inside_focused(Con *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. @@ -446,6 +619,31 @@ Con *con_by_window_id(xcb_window_t window) { 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 true if the given container (still) exists. + * This can be used, e.g., to make sure a container hasn't been closed in the meantime. + * + */ +bool con_exists(Con *con) { + return con_by_con_id((long)con) != NULL; +} + /* * Returns the container with the given frame ID or NULL if no such container * exists. @@ -454,11 +652,140 @@ Con *con_by_window_id(xcb_window_t window) { 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 @@ -499,6 +826,62 @@ Con *con_for_window(Con *con, i3Window *window, Match **store_match) { return NULL; } +static int num_focus_heads(Con *con) { + int focus_heads = 0; + + Con *current; + TAILQ_FOREACH(current, &(con->focus_head), focused) { + focus_heads++; + } + + return focus_heads; +} + +/* + * Iterate over the container's focus stack and return an array with the + * containers inside it, ordered from higher focus order to lowest. + * + */ +Con **get_focus_order(Con *con) { + const int focus_heads = num_focus_heads(con); + Con **focus_order = smalloc(focus_heads * sizeof(Con *)); + Con *current; + int idx = 0; + TAILQ_FOREACH(current, &(con->focus_head), focused) { + assert(idx < focus_heads); + focus_order[idx++] = current; + } + + return focus_order; +} + +/* + * Clear the container's focus stack and re-add it using the provided container + * array. The function doesn't check if the provided array contains the same + * containers with the previous focus stack but will not add floating containers + * in the new focus stack if container is not a workspace. + * + */ +void set_focus_order(Con *con, Con **focus_order) { + int focus_heads = 0; + while (!TAILQ_EMPTY(&(con->focus_head))) { + Con *current = TAILQ_FIRST(&(con->focus_head)); + + TAILQ_REMOVE(&(con->focus_head), current, focused); + focus_heads++; + } + + for (int idx = 0; idx < focus_heads; idx++) { + /* Useful when encapsulating a workspace. */ + if (con->type != CT_WORKSPACE && con_inside_floating(focus_order[idx])) { + focus_heads++; + continue; + } + + TAILQ_INSERT_TAIL(&(con->focus_head), focus_order[idx], focused); + } +} + /* * Returns the number of children of this container. * @@ -513,6 +896,49 @@ int con_num_children(Con *con) { 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 @@ -539,10 +965,11 @@ void con_fix_percent(Con *con) { 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); + } } } } @@ -550,11 +977,13 @@ void con_fix_percent(Con *con) { // 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; + } } } @@ -565,37 +994,27 @@ void con_fix_percent(Con *con) { * */ void con_toggle_fullscreen(Con *con, int fullscreen_mode) { - Con *workspace, *fullscreen; - if (con->type == CT_WORKSPACE) { DLOG("You cannot make a workspace fullscreen.\n"); return; } DLOG("toggling fullscreen for %p / %s\n", con, con->name); - if (con->fullscreen_mode == CF_NONE) { - /* 1: check if there already is a fullscreen con */ - if (fullscreen_mode == CF_GLOBAL) - fullscreen = con_get_fullscreen_con(croot, CF_GLOBAL); - else { - workspace = con_get_workspace(con); - fullscreen = con_get_fullscreen_con(workspace, CF_OUTPUT); - } - if (fullscreen != NULL) { - /* Disable fullscreen for the currently fullscreened - * container and enable it for the one the user wants - * to have in fullscreen mode. */ - LOG("Disabling fullscreen for (%p/%s) upon user request\n", - fullscreen, fullscreen->name); - fullscreen->fullscreen_mode = CF_NONE; - } - /* 2: enable fullscreen */ - con->fullscreen_mode = fullscreen_mode; - } else { - /* 1: disable fullscreen */ - con->fullscreen_mode = CF_NONE; - } + if (con->fullscreen_mode == CF_NONE) + con_enable_fullscreen(con, fullscreen_mode); + else + con_disable_fullscreen(con); +} + +/* + * Sets the specified fullscreen mode for the given container, sends the + * “fullscreen_mode” event and changes the XCB fullscreen property of the + * container’s window, if any. + * + */ +static void con_set_fullscreen_mode(Con *con, fullscreen_mode_t fullscreen_mode) { + con->fullscreen_mode = fullscreen_mode; DLOG("mode now: %d\n", con->fullscreen_mode); @@ -608,103 +1027,163 @@ void con_toggle_fullscreen(Con *con, int fullscreen_mode) { if (con->window == NULL) return; - uint32_t values[1]; - unsigned int num = 0; + 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); + } +} + +/* + * Enables fullscreen mode for the given container, if necessary. + * + * If the container’s mode is already CF_OUTPUT or CF_GLOBAL, the container is + * kept fullscreen but its mode is set to CF_GLOBAL and CF_OUTPUT, + * respectively. + * + * Other fullscreen containers will be disabled first, if they hide the new + * one. + * + */ +void con_enable_fullscreen(Con *con, fullscreen_mode_t fullscreen_mode) { + if (con->type == CT_WORKSPACE) { + DLOG("You cannot make a workspace fullscreen.\n"); + return; + } + + assert(fullscreen_mode == CF_GLOBAL || fullscreen_mode == CF_OUTPUT); + + if (fullscreen_mode == CF_GLOBAL) + DLOG("enabling global fullscreen for %p / %s\n", con, con->name); + else + DLOG("enabling fullscreen for %p / %s\n", con, con->name); + + if (con->fullscreen_mode == fullscreen_mode) { + DLOG("fullscreen already enabled for %p / %s\n", con, con->name); + return; + } + + Con *con_ws = con_get_workspace(con); + + /* Disable any fullscreen container that would conflict the new one. */ + Con *fullscreen = con_get_fullscreen_con(croot, CF_GLOBAL); + if (fullscreen == NULL) + fullscreen = con_get_fullscreen_con(con_ws, CF_OUTPUT); + if (fullscreen != NULL) + con_disable_fullscreen(fullscreen); + + /* Set focus to new fullscreen container. Unless in global fullscreen mode + * and on another workspace restore focus afterwards. + * Switch to the container’s workspace if mode is global. */ + Con *cur_ws = con_get_workspace(focused); + Con *old_focused = focused; + if (fullscreen_mode == CF_GLOBAL && cur_ws != con_ws) + workspace_show(con_ws); + con_activate(con); + if (fullscreen_mode != CF_GLOBAL && cur_ws != con_ws) + con_activate(old_focused); + + con_set_fullscreen_mode(con, fullscreen_mode); +} + +/* + * Disables fullscreen mode for the given container regardless of the mode, if + * necessary. + * + */ +void con_disable_fullscreen(Con *con) { + if (con->type == CT_WORKSPACE) { + DLOG("You cannot make a workspace fullscreen.\n"); + return; + } + + DLOG("disabling fullscreen for %p / %s\n", con, con->name); - if (con->fullscreen_mode != CF_NONE) - values[num++] = A__NET_WM_STATE_FULLSCREEN; + if (con->fullscreen_mode == CF_NONE) { + DLOG("fullscreen already disabled for %p / %s\n", con, con->name); + return; + } - xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->window->id, - A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values); + 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 (!ignore_focus && !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; } } + /* Save the urgency state so that we can restore it. */ + bool urgent = con->urgent; + /* Save the current workspace. So we can call workspace_show() by the end * of this function. */ 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); + 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); + } + } - /* 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) { @@ -714,72 +1193,70 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool floating_fix_coordinates(con, &(source_output->rect), &(dest_output->rect)); } else DLOG("Not fixing coordinates, fix_coordinates flag = %d\n", fix_coordinates); - - /* 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); - - /* Don’t warp if told so (when dragging floating windows with the - * mouse for example) */ - if (dont_warp) - x_set_warp_to(NULL); - else - x_set_warp_to(&(con->rect)); - } } /* 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 *old_focus = TAILQ_FIRST(&(output_get_content(dest_output)->focus_head)); - con_focus(con_descend_focused(con)); + 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 (con_get_workspace(focused) != old_focus_ws) { con_focus(old_focus); + } + + /* Restore focus to the currently focused container. */ + if (old_focus_ws == current_ws && old_focus->type != CT_WORKSPACE) { + con_activate(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); + 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. */ - if (source_ws == current_ws) - con_focus(con_descend_focused(focus_next)); + if (focus_next) + con_activate(con_descend_focused(focus_next)); - /* 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; @@ -811,9 +1288,127 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool startup_sequence_delete(sequence); } + /* 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 (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; + } + + /* 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, 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_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; } /* @@ -835,87 +1430,56 @@ orientation_t con_orientation(Con *con) { 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); } /* * 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. * */ 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 */ - 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)); + } + + if (con->type == CT_FLOATING_CON && next != con->parent) { + next = con_descend_focused(next); + } return next; } @@ -1070,6 +1634,12 @@ Con *con_descend_direction(Con *con, direction_t direction) { * */ 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); @@ -1085,19 +1655,14 @@ Rect con_border_style_rect(Con *con) { /* Shortcut to avoid calling con_adjacent_borders() on dock containers. */ 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; + return (Rect){0, 0, 0, 0}; if (border_style == BS_NORMAL) { - result = (Rect) {border_width, 0, -(2 * border_width), -(border_width)}; + result = (Rect){border_width, 0, -(2 * border_width), -(border_width)}; } else { - result = (Rect) {border_width, border_width, -(2 * border_width), -(2 * border_width)}; + 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; @@ -1121,6 +1686,11 @@ Rect con_border_style_rect(Con *con) { */ 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; @@ -1144,8 +1714,7 @@ adjacent_t con_adjacent_borders(Con *con) { * */ 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; } @@ -1229,12 +1798,14 @@ void con_set_layout(Con *con, layout_t layout) { * 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 || layout == L_SPLITV || layout == L_SPLITH) { DLOG("Creating new split container\n"); /* 1: create a new split container */ Con *new = con_new(NULL, NULL); @@ -1245,11 +1816,9 @@ void con_set_layout(Con *con, layout_t layout) { new->layout = layout; new->last_split_layout = con->last_split_layout; - Con *old_focused = TAILQ_FIRST(&(con->focus_head)); - if (old_focused == TAILQ_END(&(con->focus_head))) - old_focused = NULL; - /* 3: move the existing cons of this workspace below the new con */ + Con **focus_order = get_focus_order(con); + DLOG("Moving cons\n"); Con *child; while (!TAILQ_EMPTY(&(con->nodes_head))) { @@ -1258,13 +1827,13 @@ void con_set_layout(Con *con, layout_t layout) { con_attach(child, new, true); } + set_focus_order(new, focus_order); + free(focus_order); + /* 4: attach the new split container to the workspace */ DLOG("Attaching new split to ws\n"); con_attach(new, con, false); - if (old_focused) - con_focus(old_focused); - tree_flatten(croot); } con_force_split_parents_redraw(con); @@ -1276,11 +1845,7 @@ void con_set_layout(Con *con, layout_t layout) { * 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) @@ -1307,28 +1872,70 @@ void con_toggle_layout(Con *con, const char *toggle_mode) { 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; + /* In case last_split_layout was not initialized… */ + if (layout == L_DEFAULT) { + layout = L_SPLITH; + } + } 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; + break; + } + + if (parent->layout == layout) { + current_layout_found = true; + } } - } else { + free(tm_dup); + + 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. */ @@ -1366,8 +1973,15 @@ static void con_on_remove_child(Con *con) { if (con->type == CT_WORKSPACE) { if (TAILQ_EMPTY(&(con->focus_head)) && !workspace_is_visible(con)) { LOG("Closing old workspace (%p / %s), it is empty\n", con, con->name); - tree_close(con, DONT_KILL_WINDOW, false, false); - ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"empty\"}"); + yajl_gen gen = ipc_marshal_workspace_event("empty", con, NULL); + tree_close_internal(con, DONT_KILL_WINDOW, false); + + const unsigned char *payload; + ylength length; + y(get_buf, &payload, &length); + ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, (const char *)payload); + + y(free); } return; } @@ -1381,7 +1995,7 @@ static void con_on_remove_child(Con *con) { 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); return; } } @@ -1396,7 +2010,7 @@ Rect con_minimum_size(Con *con) { if (con_is_leaf(con)) { DLOG("leaf node, returning 75x50\n"); - return (Rect) {0, 0, 75, 50}; + return (Rect){0, 0, 75, 50}; } if (con->type == CT_FLOATING_CON) { @@ -1416,7 +2030,7 @@ Rect con_minimum_size(Con *con) { } DLOG("stacked/tabbed now, returning %d x %d + deco_rect = %d\n", max_width, max_height, deco_height); - return (Rect) {0, 0, max_width, max_height + deco_height}; + return (Rect){0, 0, max_width, max_height + deco_height}; } /* For horizontal/vertical split containers we sum up the width (h-split) @@ -1436,7 +2050,7 @@ Rect con_minimum_size(Con *con) { } } DLOG("split container, returning width = %d x height = %d\n", width, height); - return (Rect) {0, 0, width, height}; + return (Rect){0, 0, width, height}; } ELOG("Unhandled case, type = %d, layout = %d, split = %d\n", @@ -1497,14 +2111,7 @@ bool con_fullscreen_permits_focusing(Con *con) { /* Allow it only if the container to be focused is contained within the * current fullscreen container. */ - do { - if (con->parent == fs) - return true; - con = con->parent; - } while (con); - - /* Focusing con would hide it behind a fullscreen window, disallow it. */ - return false; + return con_has_parent(con, fs); } /* @@ -1536,6 +2143,13 @@ bool con_has_urgent_child(Con *con) { 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) { @@ -1555,13 +2169,13 @@ void con_update_parents_urgency(Con *con) { * */ 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 @@ -1585,7 +2199,7 @@ void con_set_urgency(Con *con, bool urgent) { 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); } @@ -1643,6 +2257,7 @@ char *con_get_tree_representation(Con *con) { (TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt); free(buf); buf = tmp_buf; + free(child_txt); } /* 3) close the brackets */ @@ -1652,3 +2267,224 @@ char *con_get_tree_representation(Con *con) { 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)); + 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 swapping the containers didn't work we don't need to mess with the focus. */ + if (!result) { + goto swap_end; + } + + /* 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)); + } + + /* Move second to where first has been originally. */ + result &= _con_move_to_con(second, fake, false, false, false, true, false); + 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_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); + } + + /* 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; +}