bindsym $mod+m move position mouse
-------------------------------------------------------
+=== Sticky floating windows
+
+If you want a window to stick to the glass, i.e., have it stay on screen even
+if you switch to another workspace, you can use the +sticky+ command. For
+example, this can be useful for notepads, a media player or a video chat
+window.
+
+Note that while any window can be made sticky through this command, it will
+only take effect if the window is floating.
+
+*Syntax*:
+----------------------------
+sticky enable|disable|toggle
+----------------------------
+
+*Examples*:
+------------------------------------------------------
+# make a terminal sticky that was started as a notepad
+for_window [instance=notepad] sticky enable
+------------------------------------------------------
+
=== Changing (named) workspaces/moving to workspaces
To change to a specific workspace, use the +workspace+ command, followed by the
xmacro(_NET_WM_NAME)
xmacro(_NET_WM_VISIBLE_NAME)
xmacro(_NET_WM_MOVERESIZE)
+xmacro(_NET_WM_STATE_STICKY)
xmacro(_NET_WM_STATE_FULLSCREEN)
xmacro(_NET_WM_STATE_DEMANDS_ATTENTION)
xmacro(_NET_WM_STATE_MODAL)
*/
void cmd_fullscreen(I3_CMD, char *action, char *fullscreen_mode);
+/**
+ * Implementation of 'sticky enable|disable|toggle'.
+ *
+ */
+void cmd_sticky(I3_CMD, char *action);
+
/**
* Implementation of 'move <direction> [<pixels> [px]]'.
*
*/
bool con_is_hidden(Con *con);
+/**
+ * Returns whether the container or any of its children is sticky.
+ *
+ */
+bool con_is_sticky(Con *con);
+
/**
* Returns true if this node has regular or floating children.
*
* The dont_warp flag disables pointer warping and will be set when this
* function is called while dragging a floating window.
*
+ * If ignore_focus is set, the container will be moved without modifying focus
+ * at all.
+ *
* TODO: is there a better place for this function?
*
*/
-void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp);
+void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates,
+ bool dont_warp, bool ignore_focus);
/**
* Moves the given container to the given mark.
TAILQ_HEAD(swallow_head, Match) swallow_head;
fullscreen_mode_t fullscreen_mode;
+
+ /* Whether this window should stick to the glass. This corresponds to
+ * the _NET_WM_STATE_STICKY atom and will only be respected if the
+ * window is floating. */
+ bool sticky;
+
/* layout is the layout of this container: one of split[v|h], stacked or
* tabbed. Special containers in the tree (above workspaces) have special
* layouts like dockarea or output.
*/
void ewmh_update_client_list_stacking(xcb_window_t *stack, int num_windows);
+/**
+ * Set or remove _NET_WM_STATE_STICKY on the window.
+ *
+ */
+void ewmh_update_sticky(xcb_window_t window, bool sticky);
+
/**
* Set up the EWMH hints on the root window.
*
*
*/
Output *get_output_from_string(Output *current_output, const char *output_str);
+
+/**
+ * Iterates over all outputs and pushes sticky windows to the currently visible
+ * workspace on that output.
+ *
+ */
+void output_push_sticky_windows(void);
'kill' -> KILL
'open' -> call cmd_open()
'fullscreen' -> FULLSCREEN
+ 'sticky' -> STICKY
'split' -> SPLIT
'floating' -> FLOATING
'mark' -> MARK
end
-> call cmd_fullscreen("toggle", "output")
+# sticky enable|disable|toggle
+state STICKY:
+ action = 'enable', 'disable', 'toggle'
+ -> call cmd_sticky($action)
+
# split v|h|vertical|horizontal
state SPLIT:
direction = 'horizontal', 'vertical', 'v', 'h'
TAILQ_FOREACH(current, &owindows, owindows) {
DLOG("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, ws, true, false);
+ con_move_to_workspace(current->con, ws, true, false, false);
}
cmd_output->needs_tree_render = true;
TAILQ_FOREACH(current, &owindows, owindows) {
DLOG("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, ws, true, false);
+ con_move_to_workspace(current->con, ws, true, false, false);
}
cmd_output->needs_tree_render = true;
TAILQ_FOREACH(current, &owindows, owindows) {
DLOG("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, ws, true, false);
+ con_move_to_workspace(current->con, ws, true, false, false);
}
cmd_output->needs_tree_render = true;
TAILQ_FOREACH(current, &owindows, owindows) {
DLOG("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, workspace, true, false);
+ con_move_to_workspace(current->con, workspace, true, false, false);
}
cmd_output->needs_tree_render = true;
TAILQ_FOREACH(current, &owindows, owindows) {
DLOG("matching: %p / %s\n", current->con, current->con->name);
- con_move_to_workspace(current->con, ws, true, false);
+ con_move_to_workspace(current->con, ws, true, false, false);
}
cmd_output->needs_tree_render = true;
ysuccess(true);
}
+/*
+ * Implementation of 'sticky enable|disable|toggle'.
+ *
+ */
+void cmd_sticky(I3_CMD, char *action) {
+ DLOG("%s sticky on window\n", action);
+ HANDLE_EMPTY_MATCH;
+
+ owindow *current;
+ TAILQ_FOREACH(current, &owindows, owindows) {
+ if (current->con->window == NULL) {
+ ELOG("only containers holding a window can be made sticky, skipping con = %p\n", current->con);
+ continue;
+ }
+ DLOG("setting sticky for container = %p / %s\n", current->con, current->con->name);
+
+ bool sticky = false;
+ if (strcmp(action, "enable") == 0)
+ sticky = true;
+ else if (strcmp(action, "disable") == 0)
+ sticky = false;
+ else if (strcmp(action, "toggle") == 0)
+ sticky = !current->con->sticky;
+
+ current->con->sticky = sticky;
+ ewmh_update_sticky(current->con->window->id, sticky);
+ }
+
+ /* A window we made sticky might not be on a visible workspace right now, so we need to make
+ * sure it gets pushed to the front now. */
+ output_push_sticky_windows();
+
+ cmd_output->needs_tree_render = true;
+ ysuccess(true);
+}
+
/*
* Implementation of 'move <direction> [<pixels> [px]]'.
*
return false;
}
+/*
+ * Returns whether the container or any of its children is sticky.
+ *
+ */
+bool con_is_sticky(Con *con) {
+ if (con->sticky)
+ return true;
+
+ Con *child;
+ TAILQ_FOREACH(child, &(con->nodes_head), nodes) {
+ if (con_is_sticky(child))
+ return true;
+ }
+
+ 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).
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) {
+static bool _con_move_to_con(Con *con, Con *target, bool behind_focused, bool fix_coordinates, bool dont_warp, bool ignore_focus) {
Con *orig_target = target;
/* Prevent moving if this would violate the fullscreen focus restrictions. */
Con *child;
while (!TAILQ_EMPTY(&(source_ws->floating_head))) {
child = TAILQ_FIRST(&(source_ws->floating_head));
- con_move_to_workspace(child, target_ws, true, true);
+ con_move_to_workspace(child, target_ws, true, true, false);
}
/* If there are no non-floating children, ignore the workspace. */
/* 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(target_ws)) {
+ if (!ignore_focus && workspace_is_visible(target_ws)) {
workspace_show(target_ws);
/* Don’t warp if told so (when dragging floating windows with the
* 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(target_ws) && !fullscreen) {
+ * we don’t focus when there is a fullscreen con on that workspace. We
+ * also don't do it if the caller requested to ignore focus. */
+ if (!ignore_focus && !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. */
/* Descend focus stack in case focus_next is a workspace which can
* occur if we move to the same workspace. Also show current workspace
* to ensure it is focused. */
- workspace_show(current_ws);
+ if (!ignore_focus)
+ workspace_show(current_ws);
/* 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)
+ if (!ignore_focus && source_ws == current_ws)
con_focus(con_descend_focused(focus_next));
/* 8. If anything within the container is associated with a startup sequence,
/* 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);
+ con_move_to_workspace(con, con_get_workspace(target), true, false, false);
return true;
}
return false;
}
- return _con_move_to_con(con, target, false, true, false);
+ return _con_move_to_con(con, target, false, true, false, false);
}
/*
* The dont_warp flag disables pointer warping and will be set when this
* function is called while dragging a floating window.
*
+ * If ignore_focus is set, the container will be moved without modifying focus
+ * at all.
+ *
* TODO: is there a better place for this function?
*
*/
-void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp) {
+void con_move_to_workspace(Con *con, Con *workspace, bool fix_coordinates, bool dont_warp, bool ignore_focus) {
assert(workspace->type == CT_WORKSPACE);
Con *source_ws = con_get_workspace(con);
}
Con *target = con_descend_focused(workspace);
- _con_move_to_con(con, target, true, fix_coordinates, dont_warp);
+ _con_move_to_con(con, target, true, fix_coordinates, dont_warp, ignore_focus);
}
/*
stack);
}
+/*
+ * Set or remove _NET_WM_STATE_STICKY on the window.
+ *
+ */
+void ewmh_update_sticky(xcb_window_t window, bool sticky) {
+ uint32_t values[1];
+ unsigned int num = 0;
+
+ if (sticky)
+ values[num++] = A__NET_WM_STATE_STICKY;
+
+ xcb_change_property(conn, XCB_PROP_MODE_REPLACE, window, A__NET_WM_STATE, XCB_ATOM_ATOM, 32, num, values);
+}
+
/*
* Set up the EWMH hints on the root window.
*
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A__NET_WM_NAME, A_UTF8_STRING, 8, strlen("i3"), "i3");
/* only send the first 31 atoms (last one is _NET_CLOSE_WINDOW) increment that number when adding supported atoms */
- xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A__NET_SUPPORTED, XCB_ATOM_ATOM, 32, /* number of atoms */ 31, supported_atoms);
+ xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root, A__NET_SUPPORTED, XCB_ATOM_ATOM, 32, /* number of atoms */ 32, supported_atoms);
/* We need to map this window to be able to set the input focus to it if no other window is available to be focused. */
xcb_map_window(conn, ewmh_window);
Con *content = output_get_content(output->con);
Con *ws = TAILQ_FIRST(&(content->focus_head));
DLOG("Moving con %p / %s to workspace %p / %s\n", con, con->name, ws, ws->name);
- con_move_to_workspace(con, ws, false, true);
+ con_move_to_workspace(con, ws, false, true, false);
con_focus(con_descend_focused(con));
return true;
}
if (event->type == A__NET_WM_STATE) {
if (event->format != 32 ||
(event->data.data32[1] != A__NET_WM_STATE_FULLSCREEN &&
- event->data.data32[1] != A__NET_WM_STATE_DEMANDS_ATTENTION)) {
+ event->data.data32[1] != A__NET_WM_STATE_DEMANDS_ATTENTION &&
+ event->data.data32[1] != A__NET_WM_STATE_STICKY)) {
DLOG("Unknown atom in clientmessage of type %d\n", event->data.data32[1]);
return;
}
con_set_urgency(con, false);
else if (event->data.data32[0] == _NET_WM_STATE_TOGGLE)
con_set_urgency(con, !con->urgent);
+ } else if (event->data.data32[1] == A__NET_WM_STATE_STICKY) {
+ DLOG("Received a client message to modify _NET_WM_STATE_STICKY.\n");
+ if (event->data.data32[0] == _NET_WM_STATE_ADD)
+ con->sticky = true;
+ else if (event->data.data32[0] == _NET_WM_STATE_REMOVE)
+ con->sticky = false;
+ else if (event->data.data32[0] == _NET_WM_STATE_TOGGLE)
+ con->sticky = !con->sticky;
+
+ DLOG("New sticky status for con = %p is %i.\n", con, con->sticky);
+ output_push_sticky_windows();
}
tree_render();
ystr("fullscreen_mode");
y(integer, con->fullscreen_mode);
+ ystr("sticky");
+ y(bool, con->sticky);
+
ystr("floating");
switch (con->floating) {
case FLOATING_AUTO_OFF:
to_focus = json_node;
}
+ if (strcasecmp(last_key, "sticky") == 0)
+ json_node->sticky = val;
+
if (parsing_swallows) {
if (strcasecmp(last_key, "restart_mode") == 0)
current_swallow->restart_mode = val;
want_floating = true;
}
+ if (xcb_reply_contains_atom(state_reply, A__NET_WM_STATE_STICKY))
+ nc->sticky = true;
+
FREE(state_reply);
FREE(type_reply);
return output;
}
+
+/*
+ * Iterates over all outputs and pushes sticky windows to the currently visible
+ * workspace on that output.
+ *
+ */
+void output_push_sticky_windows(void) {
+ Con *output;
+ TAILQ_FOREACH(output, &(croot->nodes_head), nodes) {
+ Con *workspace, *visible_ws = NULL;
+ GREP_FIRST(visible_ws, output_get_content(output), workspace_is_visible(child));
+
+ /* We use this loop instead of TAILQ_FOREACH to avoid problems if the
+ * sticky window was the last window on that workspace as moving it in
+ * this case will close the workspace. */
+ for (workspace = TAILQ_FIRST(&(output_get_content(output)->nodes_head));
+ workspace != TAILQ_END(&(output_get_content(output)->nodes_head));) {
+ Con *current_ws = workspace;
+ workspace = TAILQ_NEXT(workspace, nodes);
+
+ /* Since moving the windows actually removes them from the list of
+ * floating windows on this workspace, here too we need to use
+ * another loop than TAILQ_FOREACH. */
+ Con *child;
+ for (child = TAILQ_FIRST(&(current_ws->floating_head));
+ child != TAILQ_END(&(current_ws->floating_head));) {
+ Con *current = child;
+ child = TAILQ_NEXT(child, floating_windows);
+
+ if (con_is_sticky(current))
+ con_move_to_workspace(current, visible_ws, true, false, true);
+ }
+ }
+ }
+}
/* 2: Send the window to the __i3_scratch workspace, mainting its
* coordinates and not warping the pointer. */
- con_move_to_workspace(con, __i3_scratch, true, true);
+ con_move_to_workspace(con, __i3_scratch, true, true, false);
/* 3: If this is the first time this window is used as a scratchpad, we set
* the scratchpad_state to SCRATCHPAD_FRESH. The window will then be
floating->scratchpad_state != SCRATCHPAD_NONE) {
DLOG("Found a visible scratchpad window on another workspace,\n");
DLOG("moving it to this workspace: con = %p\n", walk_con);
- con_move_to_workspace(walk_con, focused_ws, true, false);
+ con_move_to_workspace(walk_con, focused_ws, true, false, false);
return;
}
}
}
/* 1: Move the window from __i3_scratch to the current workspace. */
- con_move_to_workspace(con, active, true, false);
+ con_move_to_workspace(con, active, true, false, false);
/* 2: Adjust the size if this window was not adjusted yet. */
if (con->scratchpad_state == SCRATCHPAD_FRESH) {
/* Update the EWMH hints */
ewmh_update_current_desktop();
+
+ /* Push any sticky windows to the now visible workspace. */
+ output_push_sticky_windows();
}
/*
my $expected = {
fullscreen_mode => 0,
+ sticky => $ignore,
nodes => $ignore,
window => undef,
name => 'root',
################################################################################
is(parser_calls('unknown_literal'),
- "ERROR: Expected one of these tokens: <end>, '[', 'move', 'exec', 'exit', 'restart', 'reload', 'shmlog', 'debuglog', 'border', 'layout', 'append_layout', 'workspace', 'focus', 'kill', 'open', 'fullscreen', 'split', 'floating', 'mark', 'unmark', 'resize', 'rename', 'nop', 'scratchpad', 'title_format', 'mode', 'bar'\n" .
+ "ERROR: Expected one of these tokens: <end>, '[', 'move', 'exec', 'exit', 'restart', 'reload', 'shmlog', 'debuglog', 'border', 'layout', 'append_layout', 'workspace', 'focus', 'kill', 'open', 'fullscreen', 'sticky', 'split', 'floating', 'mark', 'unmark', 'resize', 'rename', 'nop', 'scratchpad', 'title_format', 'mode', 'bar'\n" .
"ERROR: Your command: unknown_literal\n" .
"ERROR: ^^^^^^^^^^^^^^^",
'error for unknown literal ok');
--- /dev/null
+#!perl
+# vim:ts=4:sw=4:expandtab
+#
+# Please read the following documents before working on tests:
+# • http://build.i3wm.org/docs/testsuite.html
+# (or docs/testsuite)
+#
+# • http://build.i3wm.org/docs/lib-i3test.html
+# (alternatively: perldoc ./testcases/lib/i3test.pm)
+#
+# • http://build.i3wm.org/docs/ipc.html
+# (or docs/ipc)
+#
+# • http://onyxneon.com/books/modern_perl/modern_perl_a4.pdf
+# (unless you are already familiar with Perl)
+#
+# Tests sticky windows.
+# Ticket: #1455
+use i3test;
+
+my ($ws, $focused);
+
+###############################################################################
+# 1: Given a sticky tiling container, when the workspace is switched, then
+# nothing happens.
+###############################################################################
+fresh_workspace;
+open_window(wm_class => 'findme');
+cmd 'sticky enable';
+$ws = fresh_workspace;
+
+is(@{get_ws($ws)->{nodes}}, 0, 'tiling sticky container did not move');
+is(@{get_ws($ws)->{floating_nodes}}, 0, 'tiling sticky container did not move');
+cmd '[class="findme"] kill';
+
+###############################################################################
+# 2: Given a sticky floating container, when the workspace is switched, then
+# the container moves to the new workspace.
+###############################################################################
+$ws = fresh_workspace;
+open_floating_window(wm_class => 'findme');
+$focused = get_focused($ws);
+cmd 'sticky enable';
+$ws = fresh_workspace;
+
+is(@{get_ws($ws)->{floating_nodes}}, 1, 'floating sticky container moved to new workspace');
+is(get_focused($ws), $focused, 'sticky container has focus');
+cmd '[class="findme"] kill';
+
+###############################################################################
+# 3: Given two sticky floating containers, when the workspace is switched,
+# then both containers move to the new workspace.
+###############################################################################
+fresh_workspace;
+open_floating_window(wm_class => 'findme');
+cmd 'sticky enable';
+open_floating_window(wm_class => 'findme');
+cmd 'sticky enable';
+$ws = fresh_workspace;
+
+is(@{get_ws($ws)->{floating_nodes}}, 2, 'multiple sticky windows can be used at the same time');
+cmd '[class="findme"] kill';
+
+###############################################################################
+# 4: Given a sticky floating container and a tiling container on the target
+# workspace, when the workspace is switched, then the tiling container is
+# focused.
+###############################################################################
+$ws = fresh_workspace;
+open_window;
+$focused = get_focused($ws);
+fresh_workspace;
+open_floating_window(wm_class => 'findme');
+cmd 'sticky enable';
+cmd 'workspace ' . $ws;
+
+is(get_focused($ws), $focused, 'the tiling container has focus');
+cmd '[class="findme"] kill';
+
+###############################################################################
+# 5: Given a floating container on a non-visible workspace, when the window
+# is made sticky, then the window immediately jumps to the currently
+# visible workspace.
+###############################################################################
+fresh_workspace;
+open_floating_window(wm_class => 'findme');
+cmd 'mark sticky';
+$ws = fresh_workspace;
+cmd '[con_mark=sticky] sticky enable';
+
+is(@{get_ws($ws)->{floating_nodes}}, 1, 'the sticky window jumps to the front');
+cmd '[class="findme"] kill';
+
+###############################################################################
+
+done_testing;
projects / i3 / i3 / commitdiff