*
*/
#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);
/*
* Create a new container (and attach it to the given parent, if not NULL).
- * This function initializes the data structures and creates the appropriate
- * X11 IDs using x_con_init().
+ * This function only initializes the data structures.
*
*/
-Con *con_new(Con *parent, i3Window *window) {
+Con *con_new_skeleton(Con *parent, i3Window *window) {
Con *new = scalloc(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;
- 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;
if (window)
- x_con_init(new, window->depth);
+ new->depth = window->depth;
else
- x_con_init(new, XCB_COPY_FROM_PARENT);
+ new->depth = XCB_COPY_FROM_PARENT;
+ DLOG("opening window\n");
TAILQ_INIT(&(new->floating_head));
TAILQ_INIT(&(new->nodes_head));
return new;
}
+/* A wrapper for con_new_skeleton, to retain the old con_new behaviour
+ *
+ */
+Con *con_new(Con *parent, i3Window *window) {
+ Con *new = con_new_skeleton(parent, window);
+ x_con_init(new, new->depth);
+ 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
/* 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;
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:
con->urgent = false;
con_update_parents_urgency(con);
workspace_update_urgent_flag(con_get_workspace(con));
+ ipc_send_window_event("urgent", 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.
*
* 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
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;
}
Con *con_by_frame_id(xcb_window_t frame) {
Con *con;
TAILQ_FOREACH(con, &all_cons, all_cons)
- if (con->frame == frame)
- return con;
+ if (con->frame == frame)
+ return con;
return NULL;
}
int children = 0;
TAILQ_FOREACH(child, &(con->nodes_head), nodes)
- children++;
+ children++;
return children;
}
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);
}
}
}
// 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;
}
}
/*
- * Toggles fullscreen mode for the given container. Fullscreen mode will not be
- * entered when there already is a fullscreen container on this workspace.
+ * Toggles fullscreen mode for the given container. If there already is a
+ * fullscreen container on this workspace, fullscreen will be disabled and then
+ * enabled for the container the user wants to have in fullscreen mode.
*
*/
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 */
A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values);
}
+/*
+ * Enables fullscreen mode for the given container, if necessary.
+ *
+ * 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.
+ *
+ * Other fullscreen containers will be disabled first, if they hide the new
+ * one.
+ *
+ */
+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_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);
+}
+
/*
* Moves the given container to the currently focused container on the given
* workspace.
* 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. */
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);
}
CALL(parent, on_remove_child);
+
+ ipc_send_window_event("move", con);
}
/*
* 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 */
* (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
* (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
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)};
+ 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;
+
if (borders_to_hide & ADJ_LEFT_SCREEN_EDGE) {
result.x -= border_width;
result.width += border_width;
result.height += border_width;
}
return result;
-
}
/*
/* 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;
}
/*
* new split container before).
*
*/
-void con_set_layout(Con *con, int layout) {
+void con_set_layout(Con *con, layout_t layout) {
DLOG("con_set_layout(%p, %d), con->type = %d\n",
con, layout, con->type);
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");
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);
}
* not be closed when the last child was removed */
if (con->type == CT_OUTPUT ||
con->type == CT_ROOT ||
- con->type == CT_DOCKAREA) {
- DLOG("not handling, type = %d\n", con->type);
+ con->type == CT_DOCKAREA ||
+ (con->parent != NULL && con->parent->type == CT_OUTPUT)) {
+ DLOG("not handling, type = %d, name = %s\n", con->type, con->name);
return;
}
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;
}
con_force_split_parents_redraw(con);
+ con->urgent = con_has_urgent_child(con);
+ con_update_parents_urgency(con);
/* TODO: check if this container would swallow any other client and
* don’t close it automatically. */
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) {
}
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)
}
}
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
}
}
+/*
+ * Set urgency flag to the container, all the parent containers and the workspace.
+ *
+ */
+void con_set_urgency(Con *con, bool urgent) {
+ if (focused == con) {
+ DLOG("Ignoring urgency flag for current client\n");
+ con->window->urgent.tv_sec = 0;
+ con->window->urgent.tv_usec = 0;
+ return;
+ }
+
+ if (con->urgency_timer == NULL) {
+ con->urgent = urgent;
+ } else
+ DLOG("Discarding urgency WM_HINT because timer is running\n");
+
+ //CLIENT_LOG(con);
+ if (con->window) {
+ if (con->urgent) {
+ gettimeofday(&con->window->urgent, NULL);
+ } else {
+ con->window->urgent.tv_sec = 0;
+ con->window->urgent.tv_usec = 0;
+ }
+ }
+
+ con_update_parents_urgency(con);
+
+ 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);
+ }
+}
+
/*
* Create a string representing the subtree under 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;
}
projects / i3 / i3 / blobdiff