-#undef I3__FILE__
-#define I3__FILE__ "con.c"
/*
* vim:ts=4:sw=4:expandtab
*
*
*/
#include "all.h"
+
#include "yajl_utils.h"
static void con_on_remove_child(Con *con);
*/
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;
}
struct bfs_entry {
Con *con;
- TAILQ_ENTRY(bfs_entry) entries;
+ TAILQ_ENTRY(bfs_entry)
+ entries;
};
/*
/* 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);
DLOG("Removing all existing marks on con = %p.\n", con);
mark_t *current;
- TAILQ_FOREACH(current, &(con->marks_head), marks) {
+ 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;
}
FREE(mark->name);
TAILQ_REMOVE(&(current->marks_head), mark, marks);
FREE(mark);
+
+ ipc_send_window_event("mark", current);
}
current->mark_changed = true;
FREE(mark->name);
TAILQ_REMOVE(&(current->marks_head), mark, marks);
FREE(mark);
+
+ ipc_send_window_event("mark", current);
break;
}
}
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
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;
}
_con_move_to_con(con, target, true, fix_coordinates, dont_warp, ignore_focus);
}
+/*
+ * 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) {
+ 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->name);
+ con_move_to_workspace(con, ws, false, false, false);
+}
+
/*
* Returns the orientation of the given container (for stacked containers,
* vertical orientation is used regardless of the actual orientation of the
*
*/
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);
* 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) {
DLOG("Creating new split container\n");
/* 1: create a new split container */
Con *new = con_new(NULL, NULL);
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;
+ } 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;
+ free(tm_dup);
+ break;
+ }
+
+ if (parent->layout == layout) {
+ current_layout_found = true;
+ }
}
- } else {
+
+ 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. */
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) {
(TAILQ_FIRST(&(con->nodes_head)) == child ? "" : " "), child_txt);
free(buf);
buf = tmp_buf;
+ free(child_txt);
}
/* 3) close the brackets */
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;
+}