X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcon.c;h=08c720015bd40b3099dc55fb55148fb4e7089214;hb=refs%2Fpull%2F1772%2Fhead;hp=ba14e06c66028083c46da87a16c5f7ed0dc75562;hpb=28939365cb2371f0c2374ec6546f751ff0f42350;p=i3%2Fi3 diff --git a/src/con.c b/src/con.c index ba14e06c..08c72001 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,19 +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); @@ -32,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) { @@ -60,16 +48,7 @@ Con *con_new_skeleton(Con *parent, i3Window *window) { new->depth = window->depth; 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)); @@ -91,20 +70,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); @@ -130,7 +99,8 @@ void con_attach(Con *con, Con *parent, bool ignore_focus) { /* we need to insert con after current, if current is not NULL */ if (current) TAILQ_INSERT_BEFORE(current, con, nodes); - else TAILQ_INSERT_TAIL(nodes_head, con, nodes); + else + TAILQ_INSERT_TAIL(nodes_head, con, nodes); } } goto add_to_focus_head; @@ -175,10 +145,10 @@ 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); + } else + TAILQ_INSERT_TAIL(nodes_head, con, nodes); } add_to_focus_head: @@ -189,6 +159,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 * @@ -230,6 +214,7 @@ void con_focus(Con *con) { con->urgent = false; con_update_parents_urgency(con); workspace_update_urgent_flag(con_get_workspace(con)); + ipc_send_window_event("urgent", con); } } @@ -241,6 +226,14 @@ bool con_is_leaf(Con *con) { return TAILQ_EMPTY(&(con->nodes_head)); } +/* + * Returns true when this con is a leaf node with a managed X11 window (e.g., + * excluding dock containers) + */ +bool con_has_managed_window(Con *con) { + 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. * @@ -267,6 +260,29 @@ 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 true if this node accepts a window (if the node swallows windows, * it might already have swallowed enough and cannot hold any more). @@ -353,7 +369,7 @@ struct bfs_entry { * Returns the first fullscreen node below this node. * */ -Con *con_get_fullscreen_con(Con *con, int fullscreen_mode) { +Con *con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode) { Con *current, *child; /* TODO: is breadth-first-search really appropriate? (check as soon as @@ -452,8 +468,8 @@ bool con_inside_focused(Con *con) { Con *con_by_window_id(xcb_window_t window) { Con *con; TAILQ_FOREACH(con, &all_cons, all_cons) - if (con->window != NULL && con->window->id == window) - return con; + if (con->window != NULL && con->window->id == window) + return con; return NULL; } @@ -465,8 +481,23 @@ 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 == 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->mark != NULL && strcmp(con->mark, mark) == 0) return con; + } + return NULL; } @@ -519,7 +550,7 @@ int con_num_children(Con *con) { int children = 0; TAILQ_FOREACH(child, &(con->nodes_head), nodes) - children++; + children++; return children; } @@ -552,7 +583,8 @@ void con_fix_percent(Con *con) { if (child->percent <= 0.0) { if (children_with_percent == 0) total += (child->percent = 1.0); - else total += (child->percent = total / children_with_percent); + else + total += (child->percent = total / children_with_percent); } } } @@ -561,10 +593,10 @@ void con_fix_percent(Con *con) { // distribute according to the proportions we got if (total == 0.0) { TAILQ_FOREACH(child, &(con->nodes_head), nodes) - child->percent = 1.0 / children; + child->percent = 1.0 / children; } else if (total != 1.0) { TAILQ_FOREACH(child, &(con->nodes_head), nodes) - child->percent /= total; + child->percent /= total; } } @@ -575,40 +607,33 @@ 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); + /* Send an ipc window "fullscreen_mode" event */ + ipc_send_window_event("fullscreen_mode", con); + /* update _NET_WM_STATE if this container has a window */ /* TODO: when a window is assigned to a container which is already * fullscreened, this state needs to be pushed to the client, too */ @@ -626,92 +651,147 @@ void con_toggle_fullscreen(Con *con, int fullscreen_mode) { } /* - * 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) { + 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); } /* 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) { @@ -719,13 +799,14 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool * to the coordinate space of the correct output */ if (fix_coordinates && con->type == CT_FLOATING_CON) { floating_fix_coordinates(con, &(source_output->rect), &(dest_output->rect)); - } else DLOG("Not fixing coordinates, fix_coordinates flag = %d\n", fix_coordinates); + } 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); + if (workspace_is_visible(target_ws)) { + workspace_show(target_ws); /* Don’t warp if told so (when dragging floating windows with the * mouse for example) */ @@ -738,29 +819,29 @@ 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) { + if (!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. */ @@ -772,7 +853,7 @@ 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 @@ -783,9 +864,9 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool /* 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)); + 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; @@ -798,7 +879,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool continue; cookie = xcb_get_property(conn, false, child->window->id, - A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512); + A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512); startup_id_reply = xcb_get_property_reply(conn, cookie, NULL); sequence = startup_sequence_get(child->window, startup_id_reply, true); @@ -809,7 +890,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool if (con->window) { cookie = xcb_get_property(conn, false, con->window->id, - A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512); + A__NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, 512); startup_id_reply = xcb_get_property_reply(conn, cookie, NULL); sequence = startup_sequence_get(con->window, startup_id_reply, true); @@ -818,6 +899,79 @@ 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); + 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) { + DLOG("cannot move the container to itself, aborting.\n"); + return false; + } + + return _con_move_to_con(con, target, false, true, 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. + * + * TODO: is there a better place for this function? + * + */ +void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp) { + 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); } /* @@ -826,7 +980,7 @@ void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool * container). * */ -int con_orientation(Con *con) { +orientation_t con_orientation(Con *con) { switch (con->layout) { case L_SPLITV: /* stacking containers behave like they are in vertical orientation */ @@ -1018,7 +1172,8 @@ Con *con_descend_direction(Con *con, direction_t direction) { * (D_RIGHT) or the last con (D_LEFT) */ if (direction == D_RIGHT) most = TAILQ_FIRST(&(con->nodes_head)); - else most = TAILQ_LAST(&(con->nodes_head), nodes_head); + else + most = TAILQ_LAST(&(con->nodes_head), nodes_head); } else if (orientation == VERT) { /* Wrong orientation. We use the last focused con. Within that con, * we recurse to chose the left/right con or at least the last @@ -1042,7 +1197,8 @@ Con *con_descend_direction(Con *con, direction_t direction) { * (D_DOWN) or the last con (D_UP) */ if (direction == D_UP) most = TAILQ_LAST(&(con->nodes_head), nodes_head); - else most = TAILQ_FIRST(&(con->nodes_head)); + else + most = TAILQ_FIRST(&(con->nodes_head)); } else if (orientation == HORIZ) { /* Wrong orientation. We use the last focused con. Within that con, * we recurse to chose the top/bottom con or at least the last @@ -1076,16 +1232,21 @@ Rect con_border_style_rect(Con *con) { int border_width = con->current_border_width; DLOG("The border width for con is set to: %d\n", con->current_border_width); Rect result; - if (con->current_border_width < 0) - border_width = config.default_border_width; + if (con->current_border_width < 0) { + if (con_is_floating(con)) { + border_width = config.default_floating_border_width; + } else { + border_width = config.default_border_width; + } + } DLOG("Effective border width is set to: %d\n", border_width); /* 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 }; + return (Rect){0, 0, 0, 0}; borders_to_hide = con_adjacent_borders(con) & config.hide_edge_borders; if (border_style == BS_NORMAL) { - result = (Rect){border_width, 0 , -(2 * border_width), -(border_width)}; + result = (Rect){border_width, 0, -(2 * border_width), -(border_width)}; } else { result = (Rect){border_width, border_width, -(2 * border_width), -(2 * border_width)}; } @@ -1093,7 +1254,7 @@ Rect con_border_style_rect(Con *con) { /* 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; + return result; if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) { result.x -= border_width; @@ -1110,7 +1271,6 @@ Rect con_border_style_rect(Con *con) { result.height += border_width; } return result; - } /* @@ -1175,34 +1335,30 @@ void con_set_border_style(Con *con, int border_style, int border_width) { /* For floating containers, we want to keep the position/size of the * *window* itself. We first add the border pixels to con->rect to make - * con->rect represent the absolute position of the window. Then, we change - * the border and subtract the new border pixels. Afterwards, we update - * parent->rect to contain con. */ + * con->rect represent the absolute position of the window (same for + * parent). Then, we change the border style and subtract the new border + * pixels. For the parent, we do the same also for the decoration. */ DLOG("This is a floating container\n"); + Con *parent = con->parent; Rect bsr = con_border_style_rect(con); - con->rect.x += bsr.x; - con->rect.y += bsr.y; - con->rect.width += bsr.width; - con->rect.height += bsr.height; + int deco_height = (con->border_style == BS_NORMAL ? render_deco_height() : 0); + + con->rect = rect_add(con->rect, bsr); + parent->rect = rect_add(parent->rect, bsr); + parent->rect.y += deco_height; + parent->rect.height -= deco_height; /* Change the border style, get new border/decoration values. */ con->border_style = border_style; con->current_border_width = border_width; bsr = con_border_style_rect(con); - int deco_height = - (con->border_style == BS_NORMAL ? render_deco_height() : 0); - - con->rect.x -= bsr.x; - con->rect.y -= bsr.y; - con->rect.width -= bsr.width; - con->rect.height -= bsr.height; + deco_height = (con->border_style == BS_NORMAL ? render_deco_height() : 0); - Con *parent = con->parent; - parent->rect.x = con->rect.x; - parent->rect.y = con->rect.y - deco_height; - parent->rect.width = con->rect.width; - parent->rect.height = con->rect.height + deco_height; + con->rect = rect_sub(con->rect, bsr); + parent->rect = rect_sub(parent->rect, bsr); + parent->rect.y -= deco_height; + parent->rect.height += deco_height; } /* @@ -1247,9 +1403,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"); @@ -1278,11 +1440,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) @@ -1318,7 +1476,8 @@ void con_toggle_layout(Con *con, const char *toggle_mode) { else { if (parent->layout == L_SPLITH) con_set_layout(con, L_SPLITV); - else con_set_layout(con, L_SPLITH); + else + con_set_layout(con, L_SPLITH); } } else { if (parent->layout == L_STACKED) @@ -1326,7 +1485,8 @@ void con_toggle_layout(Con *con, const char *toggle_mode) { else if (parent->layout == L_TABBED) { if (strcmp(toggle_mode, "all") == 0) con_set_layout(con, L_SPLITH); - else con_set_layout(con, parent->last_split_layout); + 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) { /* When toggling through all modes, we toggle between @@ -1334,7 +1494,8 @@ void con_toggle_layout(Con *con, const char *toggle_mode) { * stacked. */ if (parent->layout == L_SPLITH) con_set_layout(con, L_SPLITV); - else con_set_layout(con, L_STACKED); + else + con_set_layout(con, L_STACKED); } else { con_set_layout(con, L_STACKED); } @@ -1365,8 +1526,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; } @@ -1395,7 +1563,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) { @@ -1415,7 +1583,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) @@ -1435,7 +1603,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", @@ -1491,7 +1659,7 @@ bool con_fullscreen_permits_focusing(Con *con) { * sufficient to guarantee that change won't leave fullscreen in bad shape. */ if (fs->fullscreen_mode == CF_OUTPUT && con_get_workspace(con) != con_get_workspace(fs)) { - return true; + return true; } /* Allow it only if the container to be focused is contained within the @@ -1578,14 +1746,16 @@ void con_set_urgency(Con *con, bool urgent) { con_update_parents_urgency(con); - if (con->urgent == urgent) - LOG("Urgency flag changed to %d\n", con->urgent); - Con *ws; /* Set the urgency flag on the workspace, if a workspace could be found * (for dock clients, that is not the case). */ if ((ws = con_get_workspace(con)) != NULL) workspace_update_urgent_flag(ws); + + if (con->urgent == urgent) { + LOG("Urgency flag changed to %d\n", con->urgent); + ipc_send_window_event("urgent", con); + } } /* @@ -1637,7 +1807,7 @@ char *con_get_tree_representation(Con *con) { char *tmp_buf; sasprintf(&tmp_buf, "%s%s%s", buf, - (TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt); + (TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt); free(buf); buf = tmp_buf; }