X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcon.c;h=d1148301f5d5bb9d37e8f69a00112493b67a718c;hb=2f9ed9c4c3b0669a8cabe9d319bfb9d0cc1aca08;hp=78fe5fef55268494957e529e23a54a284440cddf;hpb=02794015289e749be71e60e9533a405b05317452;p=i3%2Fi3 diff --git a/src/con.c b/src/con.c index 78fe5fef..d1148301 100644 --- a/src/con.c +++ b/src/con.c @@ -4,7 +4,7 @@ * 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, @@ -12,18 +12,7 @@ * */ #include "all.h" - -char *colors[] = { - "#ff0000", - "#00FF00", - "#0000FF", - "#ff00ff", - "#00ffff", - "#ffff00", - "#aa0000", - "#00aa00", - "#0000aa", - "#aa00aa"}; +#include "yajl_utils.h" static void con_on_remove_child(Con *con); @@ -31,7 +20,7 @@ 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) { @@ -47,28 +36,20 @@ 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->window->aspect_ratio = 0.0; + } else { new->depth = XCB_COPY_FROM_PARENT; - static int cnt = 0; - DLOG("opening window %d\n", cnt); - - /* TODO: remove window coloring after test-phase */ - DLOG("color %s\n", colors[cnt]); - new->name = strdup(colors[cnt]); - //uint32_t cp = get_colorpixel(colors[cnt]); - cnt++; - if ((cnt % (sizeof(colors) / sizeof(char *))) == 0) - cnt = 0; + } + DLOG("opening window\n"); TAILQ_INIT(&(new->floating_head)); TAILQ_INIT(&(new->nodes_head)); @@ -90,20 +71,10 @@ Con *con_new(Con *parent, i3Window *window) { return new; } -/* - * Attaches the given container to the given parent. This happens when moving - * a container or when inserting a new container at a specific place in the - * tree. - * - * ignore_focus is to just insert the Con at the end (useful when creating a - * new split container *around* some containers, that is, detaching and - * attaching them in order without wanting to mess with the focus in between). - * - */ -void con_attach(Con *con, Con *parent, bool ignore_focus) { +static void _con_attach(Con *con, Con *parent, Con *previous, bool ignore_focus) { con->parent = parent; Con *loop; - Con *current = NULL; + Con *current = previous; struct nodes_head *nodes_head = &(parent->nodes_head); struct focus_head *focus_head = &(parent->focus_head); @@ -175,8 +146,7 @@ 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); + 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); @@ -190,6 +160,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 * @@ -228,7 +212,7 @@ 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); @@ -277,6 +261,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). @@ -480,6 +504,94 @@ Con *con_by_frame_id(xcb_window_t frame) { 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->mark != NULL && strcmp(con->mark, mark) == 0) + return con; + } + + return NULL; +} + +/* + * 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) { + assert(con != NULL); + DLOG("Toggling mark \"%s\" on con = %p.\n", mark, con); + + if (con->mark != NULL && strcmp(con->mark, mark) == 0) { + con_unmark(mark); + } else { + con_mark(con, mark); + } +} + +/* + * Assigns a mark to the container. + * + */ +void con_mark(Con *con, const char *mark) { + assert(con != NULL); + DLOG("Setting mark \"%s\" on con = %p.\n", mark, con); + + FREE(con->mark); + con->mark = sstrdup(mark); + con->mark_changed = true; + + DLOG("Clearing the mark from all other windows.\n"); + Con *other; + TAILQ_FOREACH(other, &all_cons, all_cons) { + /* Skip the window we actually handled since we took care of it already. */ + if (con == other) + continue; + + if (other->mark != NULL && strcmp(other->mark, mark) == 0) { + FREE(other->mark); + other->mark_changed = true; + } + } +} + +/* + * If mark is NULL, this removes all existing marks. + * Otherwise, it will only remove the given mark (if it is present). + * + */ +void con_unmark(const char *mark) { + Con *con; + if (mark == NULL) { + DLOG("Unmarking all containers.\n"); + TAILQ_FOREACH(con, &all_cons, all_cons) { + if (con->mark == NULL) + continue; + + FREE(con->mark); + con->mark_changed = true; + } + } else { + DLOG("Removing mark \"%s\".\n", mark); + con = con_by_mark(mark); + if (con == 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", con); + FREE(con->mark); + con->mark_changed = true; + } +} + /* * Returns the first container below 'con' which wants to swallow this window * TODO: priority @@ -586,37 +698,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); @@ -629,103 +731,157 @@ 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) - values[num++] = A__NET_WM_STATE_FULLSCREEN; - - xcb_change_property(conn, XCB_PROP_MODE_REPLACE, con->window->id, - A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values); + if (con->fullscreen_mode != CF_NONE) { + DLOG("Setting _NET_WM_STATE_FULLSCREEN for con = %p / window = %d.\n", con, con->window->id); + xcb_add_property_atom(conn, con->window->id, A__NET_WM_STATE, A__NET_WM_STATE_FULLSCREEN); + } else { + DLOG("Removing _NET_WM_STATE_FULLSCREEN for con = %p / window = %d.\n", con, con->window->id); + xcb_remove_property_atom(conn, con->window->id, A__NET_WM_STATE, A__NET_WM_STATE_FULLSCREEN); + } } /* - * Moves the given container to the currently focused container on the given - * workspace. + * Enables fullscreen mode for the given container, if necessary. * - * 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. + * 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. * - * The dont_warp flag disables pointer warping and will be set when this - * function is called while dragging a floating window. + * Other fullscreen containers will be disabled first, if they hide the new + * one. * - * TODO: is there a better place for this function? + */ +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_focus(con); + if (fullscreen_mode != CF_GLOBAL && cur_ws != con_ws) + con_focus(old_focused); + + con_set_fullscreen_mode(con, fullscreen_mode); +} + +/* + * Disables fullscreen mode for the given container regardless of the mode, if + * necessary. * */ -void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp) { - /* Prevent moving if this would violate the fullscreen focus restrictions. */ - if (!con_fullscreen_permits_focusing(workspace)) { - LOG("Cannot move out of a fullscreen container"); +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) { + DLOG("fullscreen already disabled for %p / %s\n", con, con->name); + return; + } + + 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) { + Con *orig_target = target; + + /* Prevent moving if this would violate the fullscreen focus restrictions. */ + Con *target_ws = con_get_workspace(target); + if (!con_fullscreen_permits_focusing(target_ws)) { + LOG("Cannot move out of a fullscreen container.\n"); + return false; + } + if (con_is_floating(con)) { - DLOG("Using FLOATINGCON instead\n"); + DLOG("Container is floating, using parent instead.\n"); con = con->parent; } Con *source_ws = con_get_workspace(con); - if (workspace == source_ws) { - DLOG("Not moving, already there\n"); - return; - } if (con->type == CT_WORKSPACE) { /* Re-parent all of the old workspace's floating windows. */ Con *child; while (!TAILQ_EMPTY(&(source_ws->floating_head))) { child = TAILQ_FIRST(&(source_ws->floating_head)); - con_move_to_workspace(child, workspace, true, true); + con_move_to_workspace(child, target_ws, true, true, false); } /* If there are no non-floating children, ignore the workspace. */ if (con_is_leaf(con)) - return; + return false; con = workspace_encapsulate(con); if (con == NULL) { ELOG("Workspace failed to move its contents into a container!\n"); - return; + return false; } } + /* 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); - - /* 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) { @@ -739,8 +895,8 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool /* If moving to a visible workspace, call show so it can be considered * focused. Must do before attaching because workspace_show checks to see * if focused container is in its area. */ - if (workspace_is_visible(workspace)) { - workspace_show(workspace); + if (!ignore_focus && workspace_is_visible(target_ws)) { + workspace_show(target_ws); /* Don’t warp if told so (when dragging floating windows with the * mouse for example) */ @@ -753,29 +909,30 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool /* 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 */ + /* 5: fix the percentages */ con_fix_percent(parent); con->percent = 0.0; - con_fix_percent(next); + 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. */ @@ -787,20 +944,21 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool con_focus(old_focus); } - /* 8: when moving to another workspace, we leave the focus on the current + /* 7: when moving to another workspace, we leave the focus on the current * workspace. (see also #809) */ /* Descend focus stack in case focus_next is a workspace which can * occur if we move to the same workspace. Also show current workspace * to ensure it is focused. */ - workspace_show(current_ws); + if (!ignore_focus) + workspace_show(current_ws); /* Set focus only if con was on current workspace before moving. * Otherwise we would give focus to some window on different workspace. */ - if (source_ws == current_ws) + if (!ignore_focus && source_ws == current_ws) con_focus(con_descend_focused(focus_next)); - /* 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; @@ -834,7 +992,81 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool CALL(parent, on_remove_child); + /* 9. If the container was marked urgent, move the urgency hint. */ + if (urgent) { + workspace_update_urgent_flag(source_ws); + con_set_urgency(con, true); + } + ipc_send_window_event("move", con); + 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; + } + + /* 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 == target->parent) { + DLOG("cannot move the container to or inside itself, aborting.\n"); + return false; + } + + return _con_move_to_con(con, target, false, true, false, false); +} + +/* + * 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); } /* @@ -1106,19 +1338,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; @@ -1142,6 +1369,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; @@ -1266,9 +1498,15 @@ void con_set_layout(Con *con, layout_t layout) { new->layout = layout; new->last_split_layout = con->last_split_layout; + /* Save the container that was focused before we move containers + * around, but only if the container is visible (otherwise focus + * will be restored properly automatically when switching). */ Con *old_focused = TAILQ_FIRST(&(con->focus_head)); if (old_focused == TAILQ_END(&(con->focus_head))) old_focused = NULL; + if (old_focused != NULL && + !workspace_is_visible(con_get_workspace(old_focused))) + old_focused = NULL; /* 3: move the existing cons of this workspace below the new con */ DLOG("Moving cons\n"); @@ -1297,11 +1535,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) @@ -1387,8 +1621,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); + yajl_gen gen = ipc_marshal_workspace_event("empty", con, NULL); tree_close(con, DONT_KILL_WINDOW, false, false); - ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, "{\"change\":\"empty\"}"); + + 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; } @@ -1417,7 +1658,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) { @@ -1437,7 +1678,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) @@ -1457,7 +1698,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", @@ -1576,13 +1817,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 @@ -1606,7 +1847,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); }