"#aa0000",
"#00aa00",
"#0000aa",
- "#aa00aa"
-};
+ "#aa00aa"};
static void con_on_remove_child(Con *con);
new->name = strdup(colors[cnt]);
//uint32_t cp = get_colorpixel(colors[cnt]);
cnt++;
- if ((cnt % (sizeof(colors) / sizeof(char*))) == 0)
+ if ((cnt % (sizeof(colors) / sizeof(char *))) == 0)
cnt = 0;
TAILQ_INIT(&(new->floating_head));
/* 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;
} else {
if (!ignore_focus) {
/* Get the first tiling container in focus stack */
- TAILQ_FOREACH(loop, &(parent->focus_head), focused) {
+ TAILQ_FOREACH (loop, &(parent->focus_head), focused) {
if (loop->type == CT_FLOATING_CON)
continue;
current = loop;
DLOG("Inserting con = %p after last focused tiling 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:
* 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);
+ return (con != NULL && con->window != NULL && con->window->id != XCB_WINDOW_NONE && con_get_workspace(con) != NULL);
}
/**
TAILQ_REMOVE(&bfs_head, entry, entries);
free(entry);
- TAILQ_FOREACH(child, &(current->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(current->nodes_head), nodes) {
entry = smalloc(sizeof(struct bfs_entry));
entry->con = child;
TAILQ_INSERT_TAIL(&bfs_head, entry, entries);
}
- TAILQ_FOREACH(child, &(current->floating_head), floating_windows) {
+ TAILQ_FOREACH (child, &(current->floating_head), floating_windows) {
entry = smalloc(sizeof(struct bfs_entry));
entry->con = child;
TAILQ_INSERT_TAIL(&bfs_head, entry, entries);
*/
Con *con_by_window_id(xcb_window_t window) {
Con *con;
- TAILQ_FOREACH(con, &all_cons, all_cons)
+ TAILQ_FOREACH (con, &all_cons, all_cons)
if (con->window != NULL && con->window->id == window)
return con;
return NULL;
*/
Con *con_by_frame_id(xcb_window_t frame) {
Con *con;
- TAILQ_FOREACH(con, &all_cons, all_cons)
+ TAILQ_FOREACH (con, &all_cons, all_cons)
if (con->frame == frame)
return con;
return NULL;
//DLOG("searching con for window %p starting at con %p\n", window, con);
//DLOG("class == %s\n", window->class_class);
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
- TAILQ_FOREACH(match, &(child->swallow_head), matches) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (match, &(child->swallow_head), matches) {
if (!match_matches_window(match, window))
continue;
if (store_match != NULL)
return result;
}
- TAILQ_FOREACH(child, &(con->floating_head), floating_windows) {
- TAILQ_FOREACH(match, &(child->swallow_head), matches) {
+ TAILQ_FOREACH (child, &(con->floating_head), floating_windows) {
+ TAILQ_FOREACH (match, &(child->swallow_head), matches) {
if (!match_matches_window(match, window))
continue;
if (store_match != NULL)
Con *child;
int children = 0;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes)
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes)
children++;
return children;
// with a percentage set we have
double total = 0.0;
int children_with_percent = 0;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
if (child->percent > 0.0) {
total += child->percent;
++children_with_percent;
// if there were children without a percentage set, set to a value that
// will make those children proportional to all others
if (children_with_percent != children) {
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
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);
}
}
}
// 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)
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes)
child->percent = 1.0 / children;
} else if (total != 1.0) {
- TAILQ_FOREACH(child, &(con->nodes_head), nodes)
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes)
child->percent /= total;
}
}
* 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
/* 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,
* delete it so child windows won't be created on the old workspace. */
if (!con_is_leaf(con)) {
Con *child;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
if (!child->window)
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);
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);
return next;
do {
before = next;
- TAILQ_FOREACH(child, &(next->focus_head), focused) {
+ TAILQ_FOREACH (child, &(next->focus_head), focused) {
if (child->type == CT_FLOATING_CON)
continue;
* (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
* focused one. */
- TAILQ_FOREACH(current, &(con->focus_head), focused) {
+ TAILQ_FOREACH (current, &(con->focus_head), focused) {
if (current->type != CT_FLOATING_CON) {
most = current;
break;
* (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
* focused one. */
- TAILQ_FOREACH(current, &(con->focus_head), focused) {
+ TAILQ_FOREACH (current, &(con->focus_head), focused) {
if (current->type != CT_FLOATING_CON) {
most = current;
break;
/* 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)};
+ 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;
+ return result;
if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) {
result.x -= border_width;
result.height += border_width;
}
return result;
-
}
/*
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)
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
* 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);
}
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) {
if (con->layout == L_STACKED || con->layout == L_TABBED) {
uint32_t max_width = 0, max_height = 0, deco_height = 0;
Con *child;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
Rect min = con_minimum_size(child);
deco_height += child->deco_rect.height;
max_width = max(max_width, min.width);
}
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)
if (con_is_split(con)) {
uint32_t width = 0, height = 0;
Con *child;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
Rect min = con_minimum_size(child);
if (con->layout == L_SPLITH) {
width += min.width;
}
}
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",
* 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
/* We are not interested in floating windows since they can only be
* attached to a workspace → nodes_head instead of focus_head */
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
if (con_has_urgent_child(child))
return true;
}
/* 2) append representation of children */
Con *child;
- TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
char *child_txt = con_get_tree_representation(child);
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;
}
projects / i3 / i3 / blobdiff