X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Ftree.c;h=96766b6a4f9346e37682d44f03c45a3e84728441;hb=b87bc70cd6184f3fd066587df960a628a34e17fd;hp=e296a9819bdae297e0f86a259b62680c060232a9;hpb=0dd71674dea30076f6cda6029f624386acfe015f;p=i3%2Fi3 diff --git a/src/tree.c b/src/tree.c index e296a981..96766b6a 100644 --- a/src/tree.c +++ b/src/tree.c @@ -1,5 +1,3 @@ -#undef I3__FILE__ -#define I3__FILE__ "tree.c" /* * vim:ts=4:sw=4:expandtab * @@ -66,12 +64,19 @@ static Con *_create___i3(void) { * */ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { + bool result = false; char *globbed = resolve_tilde(path); + char *buf = NULL; if (!path_exists(globbed)) { LOG("%s does not exist, not restoring tree\n", globbed); - free(globbed); - return false; + goto out; + } + + ssize_t len; + if ((len = slurp(globbed, &buf)) < 0) { + /* slurp already logged an error. */ + goto out; } /* TODO: refactor the following */ @@ -83,7 +88,7 @@ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { geometry->height}; focused = croot; - tree_append_json(focused, globbed, NULL); + tree_append_json(focused, buf, len, NULL); DLOG("appended tree, using new root\n"); croot = TAILQ_FIRST(&(croot->nodes_head)); @@ -105,8 +110,12 @@ bool tree_restore(const char *path, xcb_get_geometry_reply_t *geometry) { } restore_open_placeholder_windows(croot); + result = true; - return true; +out: + free(globbed); + free(buf); + return result; } /* @@ -257,7 +266,7 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par * will be mapped when i3 closes its connection (e.g. when * restarting). This is not what we want, since some apps keep * unmapped windows around and don’t expect them to suddenly be - * mapped. See http://bugs.i3wm.org/1617 */ + * mapped. See https://bugs.i3wm.org/1617 */ xcb_change_save_set(conn, XCB_SET_MODE_DELETE, con->window->id); /* Ignore X11 errors for the ReparentWindow request. @@ -265,11 +274,8 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par add_ignore_event(cookie.sequence, 0); } ipc_send_window_event("close", con); - FREE(con->window->class_class); - FREE(con->window->class_instance); - i3string_free(con->window->name); - FREE(con->window->ran_assignments); - FREE(con->window); + window_free(con->window); + con->window = NULL; } Con *ws = con_get_workspace(con); @@ -324,10 +330,14 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par DLOG("parent container killed\n"); } - free(con->name); - FREE(con->deco_render_params); - TAILQ_REMOVE(&all_cons, con, all_cons); - free(con); + if (ws == con) { + DLOG("Closing a workspace container, updating EWMH atoms\n"); + ewmh_update_number_of_desktops(); + ewmh_update_desktop_names(); + ewmh_update_wm_desktop(); + } + + con_free(con); /* in the case of floating windows, we already focused another container * when closing the parent, so we can exit now. */ @@ -341,12 +351,12 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par DLOG("focusing %p / %s\n", next, next->name); if (next->type == CT_DOCKAREA) { /* Instead of focusing the dockarea, we need to restore focus to the workspace */ - con_focus(con_descend_focused(output_get_content(next->parent))); + con_activate(con_descend_focused(output_get_content(next->parent))); } else { if (!force_set_focus && con != focused) DLOG("not changing focus, the container was not focused before\n"); else - con_focus(next); + con_activate(next); } } else { DLOG("not focusing because we're not killing anybody\n"); @@ -362,34 +372,6 @@ bool tree_close_internal(Con *con, kill_window_t kill_window, bool dont_kill_par return true; } -/* - * Closes the current container using tree_close_internal(). - * - */ -void tree_close_con(kill_window_t kill_window) { - assert(focused != NULL); - - /* There *should* be no possibility to focus outputs / root container */ - assert(focused->type != CT_OUTPUT); - assert(focused->type != CT_ROOT); - - if (focused->type == CT_WORKSPACE) { - DLOG("Workspaces cannot be close, closing all children instead\n"); - Con *child, *nextchild; - for (child = TAILQ_FIRST(&(focused->focus_head)); child;) { - nextchild = TAILQ_NEXT(child, focused); - DLOG("killing child=%p\n", child); - tree_close_internal(child, kill_window, false, false); - child = nextchild; - } - - return; - } - - /* Kill con */ - tree_close_internal(focused, kill_window, false, false); -} - /* * Splits (horizontally or vertically) the given container by creating a new * container which contains the old one and the future ones. @@ -403,7 +385,11 @@ void tree_split(Con *con, orientation_t orientation) { if (con->type == CT_WORKSPACE) { if (con_num_children(con) < 2) { - DLOG("Just changing orientation of workspace\n"); + if (con_num_children(con) == 0) { + DLOG("Changing workspace_layout to L_DEFAULT\n"); + con->workspace_layout = L_DEFAULT; + } + DLOG("Changing orientation of workspace\n"); con->layout = (orientation == HORIZ) ? L_SPLITH : L_SPLITV; return; } else { @@ -454,7 +440,7 @@ bool level_up(void) { /* Skip over floating containers and go directly to the grandparent * (which should always be a workspace) */ if (focused->parent->type == CT_FLOATING_CON) { - con_focus(focused->parent->parent); + con_activate(focused->parent->parent); return true; } @@ -465,7 +451,7 @@ bool level_up(void) { ELOG("'focus parent': Focus is already on the workspace, cannot go higher than that.\n"); return false; } - con_focus(focused->parent); + con_activate(focused->parent); return true; } @@ -490,7 +476,7 @@ bool level_down(void) { next = TAILQ_FIRST(&(next->focus_head)); } - con_focus(next); + con_activate(next); return true; } @@ -501,7 +487,7 @@ static void mark_unmapped(Con *con) { TAILQ_FOREACH(current, &(con->nodes_head), nodes) mark_unmapped(current); if (con->type == CT_WORKSPACE) { - /* We need to call mark_unmapped on floating nodes aswell since we can + /* We need to call mark_unmapped on floating nodes as well since we can * make containers floating. */ TAILQ_FOREACH(current, &(con->floating_head), floating_windows) mark_unmapped(current); @@ -553,7 +539,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) if (!current_output) return false; - DLOG("Current output is %s\n", current_output->name); + DLOG("Current output is %s\n", output_primary_name(current_output)); /* Try to find next output */ direction_t direction; @@ -571,7 +557,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) next_output = get_output_next(direction, current_output, CLOSEST_OUTPUT); if (!next_output) return false; - DLOG("Next output is %s\n", next_output->name); + DLOG("Next output is %s\n", output_primary_name(next_output)); /* Find visible workspace on next output */ Con *workspace = NULL; @@ -581,26 +567,21 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) if (!workspace) return false; - workspace_show(workspace); - - /* If a workspace has an active fullscreen container, one of its - * children should always be focused. The above workspace_show() - * should be adequate for that, so return. */ - if (con_get_fullscreen_con(workspace, CF_OUTPUT)) - return true; - - Con *focus = con_descend_direction(workspace, direction); - - /* special case: if there was no tiling con to focus and the workspace - * has a floating con in the focus stack, focus the top of the focus - * stack (which may be floating) */ - if (focus == workspace) - focus = con_descend_focused(workspace); - - if (focus) { - con_focus(focus); - x_set_warp_to(&(focus->rect)); + /* Use descend_focused first to give higher priority to floating or + * tiling fullscreen containers. */ + Con *focus = con_descend_focused(workspace); + if (focus->fullscreen_mode == CF_NONE) { + Con *focus_tiling = con_descend_tiling_focused(workspace); + /* If descend_tiling returned a workspace then focus is either a + * floating container or the same workspace. */ + if (focus_tiling != workspace) { + focus = focus_tiling; + } } + + workspace_show(workspace); + con_activate(focus); + x_set_warp_to(&(focus->rect)); return true; } @@ -637,7 +618,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) TAILQ_INSERT_HEAD(&(parent->floating_head), last, floating_windows); } - con_focus(con_descend_focused(next)); + con_activate(con_descend_focused(next)); return true; } @@ -662,7 +643,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) next = TAILQ_PREV(current, nodes_head, nodes); if (!next) { - if (!config.force_focus_wrapping) { + if (config.focus_wrapping != FOCUS_WRAPPING_FORCE) { /* If there is no next/previous container, we check if we can focus one * when going higher (without wrapping, though). If so, we are done, if * not, we wrap */ @@ -686,7 +667,7 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) /* 3: focus choice comes in here. at the moment we will go down * until we find a window */ /* TODO: check for window, atm we only go down as far as possible */ - con_focus(con_descend_focused(next)); + con_activate(con_descend_focused(next)); return true; } @@ -696,7 +677,8 @@ static bool _tree_next(Con *con, char way, orientation_t orientation, bool wrap) * */ void tree_next(char way, orientation_t orientation) { - _tree_next(focused, way, orientation, true); + _tree_next(focused, way, orientation, + config.focus_wrapping != FOCUS_WRAPPING_OFF); } /*