Merge branch 'master' into floating_panes

There is a signature and functionality mismatch with the recent merge in
`layout_floating_pane` that has been fixed. It now more gracefully
handles inputs.

Makefile.am

@@ -102,6 +102,7 @@ dist_tmux_SOURCES = \
 	cmd-display-panes.c \
 	cmd-find-window.c \
 	cmd-find.c \
+	cmd-hide-pane.c \
 	cmd-if-shell.c \
 	cmd-join-pane.c \
 	cmd-kill-pane.c \

cmd-break-pane.c

@@ -60,6 +60,10 @@ cmd_break_pane_float(struct cmdq_item *item, struct args *args,
 		cmdq_error(item, "pane is already floating");
 		return (CMD_RETURN_ERROR);
 	}
+	if (window_pane_is_hidden(wp)) {
+		cmdq_error(item, "can't float a hidden pane");
+		return (CMD_RETURN_ERROR);
+	}
 	if (w->flags & WINDOW_ZOOMED) {
 		cmdq_error(item, "can't float a pane while window is zoomed");
 		return (CMD_RETURN_ERROR);

cmd-find.c

@@ -994,15 +994,20 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 	} else if (cmd_find_from_client(&current, cmdq_get_client(item),
 	    flags) == 0) {
 		fs->current = &current;
+		/* No active pane, window empty, return the window instead. */
+		if (current.wp == NULL) {
+			type = CMD_FIND_WINDOW;
+		}
 		log_debug("%s: current is from client", __func__);
 	} else {
 		if (~flags & CMD_FIND_QUIET)
 			cmdq_error(item, "no current target");
 		goto error;
 	}
+	/*
 	if (!cmd_find_valid_state(fs->current))
 		fatalx("invalid current find state");
-
+	*/
 	/* An empty or NULL target is the current. */
 	if (target == NULL || *target == '\0')
 		goto current;
@@ -1041,7 +1046,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 				fs->w = fs->wl->window;
 				fs->wp = fs->w->active;
 			}
-			break;
+			goto found;
 		}
 		if (fs->wp == NULL) {
 			if (~flags & CMD_FIND_QUIET)

cmd-hide-pane.c

@@ -0,0 +1,213 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2026 Michael Grant <mgrant@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+/*
+ * Hide or show panes.
+ */
+
+static enum cmd_retval cmd_hide_pane_exec(struct cmd *, struct cmdq_item *);
+static enum cmd_retval cmd_show_pane_exec(struct cmd *, struct cmdq_item *);
+
+const struct cmd_entry cmd_hide_pane_entry = {
+	.name = "hide-pane",
+	.alias = "hidep",
+
+	.args = { "at:", 0, 1, NULL },
+	.usage = "[-a] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_hide_pane_exec
+};
+
+const struct cmd_entry cmd_show_pane_entry = {
+	.name = "show-pane",
+	.alias = "showp",
+
+	.args = { "at:", 0, 1, NULL },
+	.usage = "[-a] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_pane_exec
+};
+
+static enum cmd_retval
+cmd_hide_pane_hide(struct window *w, struct window_pane *wp)
+{
+	struct window_pane	*wpp = NULL;
+	struct layout_cell	*lc = wp->layout_cell;
+
+	if (window_pane_is_hidden(wp))
+		return (CMD_RETURN_NORMAL);
+
+	if (wp == w->active) {
+		/* Find previous active pane. */
+		TAILQ_FOREACH(wpp, &w->last_panes, sentry) {
+			if (wpp != wp && window_pane_is_visible(wpp))
+				break;
+		}
+		if (wpp == NULL) {
+			TAILQ_FOREACH(wpp, &w->z_index, zentry) {
+				if (wpp != wp &&
+				    window_pane_is_visible(wpp))
+					break;
+			}
+		}
+	}
+
+	lc->flags |= LAYOUT_CELL_HIDDEN;
+
+	layout_remove_tile(w, lc);
+	layout_fix_offsets(w);
+	layout_fix_panes(w, NULL);
+
+	window_pane_stack_remove(&w->last_panes, wp);
+	if (wpp != NULL) {
+		window_set_active_pane(w, wpp, 1);
+	} else if (wp == w->active) {
+		/* No visible previous active pane; null active pane
+		 * to show dots background. */
+		w->active = NULL;
+		if (options_get_number(global_options, "focus-events"))
+			window_pane_update_focus(wp);
+		notify_window("window-pane-changed", w);
+		notify_window("window-layout-changed", w);
+		server_redraw_window(w);
+	} else {
+		notify_window("window-layout-changed", w);
+		server_redraw_window(w);
+	}
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cmd_hide_pane_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp, *active_pane = w->active;
+	u_int			 id;
+	char			*cause = NULL;
+	enum cmd_retval		 rv;
+
+	window_unzoom(w, 1);
+
+	if (args_has(args, 'a')) {
+		TAILQ_FOREACH(wp, &w->z_index, zentry) {
+			if (!window_pane_is_visible(wp) || wp == active_pane)
+				continue;
+			rv = cmd_hide_pane_hide(w, wp);
+			if (rv != CMD_RETURN_NORMAL)
+				return (rv);
+		}
+		return (CMD_RETURN_NORMAL);
+	} else {
+		wp = target->wp;
+		if (wp == NULL) {
+			id = args_strtonum_and_expand(args, 't', 0, INT_MAX,
+			    item, &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "%s target pane", cause);
+				return (CMD_RETURN_ERROR);
+			}
+			wp = window_pane_find_by_id(id);
+		}
+		if (wp == NULL) {
+			cmdq_error(item, "No target pane to hide.");
+			return (CMD_RETURN_ERROR);
+		}
+		return (cmd_hide_pane_hide(w, wp));
+	}
+}
+
+static enum cmd_retval
+cmd_hide_pane_show(struct window *w, struct window_pane *wp)
+{
+	struct layout_cell	*lc = wp->layout_cell;
+
+	if (!window_pane_is_hidden(wp))
+		return (CMD_RETURN_NORMAL);
+
+	lc->flags &= ~LAYOUT_CELL_HIDDEN;
+
+	layout_insert_tile(w, lc);
+	layout_fix_offsets(w);
+	layout_fix_panes(w, NULL);
+
+	window_set_active_pane(w, wp, 1);
+
+	notify_window("window-layout-changed", w);
+	server_redraw_window(w);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cmd_show_pane_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp;
+	u_int			 id;
+	char			*cause = NULL;
+	enum cmd_retval		 rv;
+
+	window_unzoom(w, 1);
+
+	if (args_has(args, 'a')) {
+		TAILQ_FOREACH(wp, &w->z_index, zentry) {
+			if (!window_pane_is_visible(wp))
+				continue;
+			rv = cmd_hide_pane_show(w, wp);
+			if (rv != CMD_RETURN_NORMAL)
+				return (rv);
+		}
+		return (CMD_RETURN_NORMAL);
+	} else {
+		wp = target->wp;
+		if (wp == NULL) {
+			id = args_strtonum_and_expand(args, 't', 0, INT_MAX,
+			    item, &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "%s target pane", cause);
+				return (CMD_RETURN_ERROR);
+			}
+			wp = window_pane_find_by_id(id);
+		}
+		if (wp == NULL) {
+			cmdq_error(item, "No target pane to show.");
+			return (CMD_RETURN_ERROR);
+		}
+		return (cmd_hide_pane_show(w, wp));
+	}
+}

cmd-join-pane.c

@@ -363,6 +363,45 @@ cmd_join_pane_zindex(struct cmdq_item *item, struct winlink *wl,
 	return (CMD_RETURN_NORMAL);
 }
 
+static enum cmd_retval
+cmd_join_pane_tile(struct cmdq_item *item, struct args *args, struct window *w,
+    struct window_pane *wp)
+{
+	struct layout_cell	*lc = wp->layout_cell;
+
+	if (!window_pane_is_floating(wp)) {
+		cmdq_error(item, "pane is not floating");
+		return (CMD_RETURN_ERROR);
+	}
+	if (window_pane_is_hidden(wp)) {
+		cmdq_error(item, "can't tile a hidden pane");
+		return (CMD_RETURN_ERROR);
+	}
+	if (w->flags & WINDOW_ZOOMED) {
+		cmdq_error(item, "can't tile a pane while window is zoomed");
+		return (CMD_RETURN_ERROR);
+	}
+
+	layout_save_size(lc);
+	lc->flags &= ~LAYOUT_CELL_FLOATING;
+	if (layout_insert_tile(w, lc) == 0) {
+		cmdq_error(item, "no space for a new pane");
+		return (CMD_RETURN_ERROR);
+	}
+
+	TAILQ_REMOVE(&w->z_index, wp, zentry);
+	TAILQ_INSERT_TAIL(&w->z_index, wp, zentry);
+
+	if (!args_has(args, 'd'))
+		window_set_active_pane(w, wp, 1);
+	layout_fix_offsets(w);
+	layout_fix_panes(w, NULL);
+	notify_window("window-layout-changed", w);
+	server_redraw_window(w);
+
+	return (CMD_RETURN_NORMAL);
+}
+
 static enum cmd_retval
 cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
@@ -377,7 +416,7 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 	const char		*s;
 	char			*cause = NULL;
 	int			 flags = 0, dst_idx;
-	struct layout_cell	*lc;
+	struct layout_cell	*lc, *src_lc;
 
 	dst_s = target->s;
 	dst_wl = target->wl;
@@ -408,9 +447,13 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 
 	src_wl = source->wl;
 	src_wp = source->wp;
+	src_lc = src_wp->layout_cell;
 	src_w = src_wl->window;
 	server_unzoom_window(src_w);
 
+	if (!args_has(args, 't') && window_pane_is_floating(src_wp))
+		return (cmd_join_pane_tile(item, args, src_w, src_wp));
+
 	if (src_wp == dst_wp) {
 		cmdq_error(item, "source and target panes must be different");
 		return (CMD_RETURN_ERROR);
@@ -422,6 +465,12 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
+	if (window_pane_is_floating(src_wp)) {
+		lc->saved_sx = src_lc->sx;
+		lc->saved_sy = src_lc->sy;
+		lc->saved_xoff = src_lc->xoff;
+		lc->saved_yoff = src_lc->yoff;
+	}
 
 	layout_close_pane(src_wp);
 

cmd-swap-pane.c

@@ -79,12 +79,6 @@ cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 	if (src_wp == dst_wp)
 		goto out;
 
-	if (window_pane_is_floating(src_wp) ||
-	    window_pane_is_floating(dst_wp)) {
-		cmdq_error(item, "cannot swap floating panes");
-		return (CMD_RETURN_ERROR);
-	}
-
 	server_client_remove_pane(src_wp);
 	server_client_remove_pane(dst_wp);
 

cmd.c

@@ -69,6 +69,7 @@ extern const struct cmd_entry cmd_load_buffer_entry;
 extern const struct cmd_entry cmd_lock_client_entry;
 extern const struct cmd_entry cmd_lock_server_entry;
 extern const struct cmd_entry cmd_lock_session_entry;
+extern const struct cmd_entry cmd_hide_pane_entry;
 extern const struct cmd_entry cmd_move_pane_entry;
 extern const struct cmd_entry cmd_move_window_entry;
 extern const struct cmd_entry cmd_new_pane_entry;
@@ -106,6 +107,7 @@ extern const struct cmd_entry cmd_show_environment_entry;
 extern const struct cmd_entry cmd_show_hooks_entry;
 extern const struct cmd_entry cmd_show_messages_entry;
 extern const struct cmd_entry cmd_show_options_entry;
+extern const struct cmd_entry cmd_show_pane_entry;
 extern const struct cmd_entry cmd_show_prompt_history_entry;
 extern const struct cmd_entry cmd_show_window_options_entry;
 extern const struct cmd_entry cmd_source_file_entry;
@@ -163,6 +165,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_lock_client_entry,
 	&cmd_lock_server_entry,
 	&cmd_lock_session_entry,
+	&cmd_hide_pane_entry,
 	&cmd_move_pane_entry,
 	&cmd_move_window_entry,
 	&cmd_new_pane_entry,
@@ -200,6 +203,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_show_hooks_entry,
 	&cmd_show_messages_entry,
 	&cmd_show_options_entry,
+	&cmd_show_pane_entry,
 	&cmd_show_prompt_history_entry,
 	&cmd_show_window_options_entry,
 	&cmd_source_file_entry,

format.c

@@ -2169,6 +2169,20 @@ format_cb_pane_height(struct format_tree *ft)
 	return (NULL);
 }
 
+/* Callback for pane_hidden_flag. */
+static void *
+format_cb_pane_hidden_flag(struct format_tree *ft)
+{
+	struct window_pane	*wp = ft->wp;
+
+	if (wp != NULL) {
+		if (window_pane_is_hidden(wp))
+			return (xstrdup("1"));
+		return (xstrdup("0"));
+	}
+	return (NULL);
+}
+
 /* Callback for pane_id. */
 static void *
 format_cb_pane_id(struct format_tree *ft)
@@ -3474,6 +3488,9 @@ static const struct format_table_entry format_table[] = {
 	{ "pane_height", FORMAT_TABLE_STRING,
 	  format_cb_pane_height
 	},
+	{ "pane_hidden_flag", FORMAT_TABLE_STRING,
+	  format_cb_pane_hidden_flag
+	},
 	{ "pane_id", FORMAT_TABLE_STRING,
 	  format_cb_pane_id
 	},

key-bindings.c

@@ -64,7 +64,7 @@
 	" ''" \
 	" '#{?#{&&:#{!:#{pane_floating_flag}},#{>:#{window_panes},1}},Swap Up,}' 'u' {swap-pane -U}" \
 	" '#{?#{&&:#{!:#{pane_floating_flag}},#{>:#{window_panes},1}},Swap Down,}' 'd' {swap-pane -D}" \
-	" '#{?#{!:#{pane_floating_flag}},#{?pane_marked_set,,-}Swap Marked,}' 's' {swap-pane}" \
+	" '#{?pane_marked_set,,-}Swap Marked' 's' {swap-pane}" \
 	" ''" \
 	" 'Kill' 'X' {kill-pane}" \
 	" 'Respawn' 'R' {respawn-pane -k}" \
@@ -350,6 +350,8 @@ key_bindings_init(void)
 {
 	static const char *const defaults[] = {
 		/* Prefix keys. */
+		"bind -N 'Hide pane' _ { hide-pane }",
+
 		"bind -N 'Send the prefix key' C-b { send-prefix }",
 		"bind -N 'Rotate through the panes' C-o { rotate-window }",
 		"bind -N 'Suspend the current client' C-z { suspend-client }",
@@ -362,6 +364,7 @@ key_bindings_init(void)
 		"bind -N 'Kill current window' & { confirm-before -p\"kill-window #W? (y/n)\" kill-window }",
 		"bind -N 'Prompt for window index to select' \"'\" { command-prompt -T window-target -pindex { select-window -t ':%%' } }",
 		"bind -N 'New floating pane' * { new-pane }",
+		"bind -N 'Toggle pane between floating and tiled' @ { if -F '#{pane_floating_flag}' { join-pane } { break-pane -W } }",
 		"bind -N 'Switch to previous client' ( { switch-client -p }",
 		"bind -N 'Switch to next client' ) { switch-client -n }",
 		"bind -N 'Rename current window' , { command-prompt -I'#W' { rename-window -- '%%' } }",
@@ -473,7 +476,7 @@ key_bindings_init(void)
 		"bind -n M-MouseDrag1Border { move-pane -M }",
 
 		/* Mouse button 1 down on status line. */
-		"bind -n MouseDown1Status { switch-client -t= }",
+		"bind -n MouseDown1Status { if -F '#{&&:#{pane_active},#{!#{pane_hidden_flag}}}' { hide-pane -t= } { switch-client -t= } }",
 		"bind -n C-MouseDown1Status { swap-window -t@ }",
 
 		/* Mouse button 1 down on default pane-border-format */

layout.c

@@ -53,6 +53,7 @@ static u_int	layout_new_pane_size(struct window *, u_int,
 		    u_int);
 static int	layout_set_size_check(struct window *, struct layout_cell *,
 		    enum layout_type, int);
+static int	layout_cell_has_tiled_child(struct layout_cell *);
 static void	layout_resize_child_cells(struct window *,
 		    struct layout_cell *);
 
@@ -209,6 +210,16 @@ layout_set_size(struct layout_cell *lc, u_int sx, u_int sy, int xoff, int yoff)
 	lc->yoff = yoff;
 }
 
+void
+layout_save_size(struct layout_cell *lc)
+{
+	lc->saved_sx = lc->sx;
+	lc->saved_sy = lc->sy;
+
+	lc->saved_xoff = lc->xoff;
+	lc->saved_yoff = lc->yoff;
+}
+
 /* Make a cell a leaf cell. */
 void
 layout_make_leaf(struct layout_cell *lc, struct window_pane *wp)
@@ -444,7 +455,8 @@ layout_fix_panes(struct window *w, struct window_pane *skip)
 	status = window_get_pane_status(w);
 
 	TAILQ_FOREACH(wp, &w->panes, entry) {
-		if ((lc = wp->layout_cell) == NULL || wp == skip)
+		if ((lc = wp->layout_cell) == NULL || wp == skip ||
+		    !window_pane_is_visible(wp))
 			continue;
 
 		old_xoff = wp->xoff;
@@ -698,7 +710,11 @@ layout_destroy_cell(struct window *w, struct layout_cell *lc,
 	struct layout_cell	*lcother = NULL, *lcparent;
 	int			 change;
 
-	/* If no parent, this is the last pane in a window. */
+	/*
+	 * If no parent, this is either a floating pane or the last
+	 * pane so window close is imminent and there is no need to
+	 * resize anything.
+	 */
 	lcparent = lc->parent;
 	if (lcparent == NULL) {
 		if (lc->wp != NULL)
@@ -737,6 +753,7 @@ out:
 		TAILQ_REMOVE(&lcparent->cells, lc, entry);
 
 		lc->parent = lcparent->parent;
+
 		if (lc->parent == NULL) {
 			if (layout_cell_is_tiled(lc)) {
 				lc->xoff = 0;
@@ -789,7 +806,7 @@ layout_resize(struct window *w, u_int sx, u_int sy)
 	 * out proportionately - this should leave the layout fitting the new
 	 * window size.
 	 */
-	if (lc->type == LAYOUT_WINDOWPANE && (lc->flags & LAYOUT_CELL_FLOATING))
+	if (!layout_cell_is_tiled(lc))
 		return;
 	xchange = sx - lc->sx;
 	xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT);

options-table.c

@@ -1437,6 +1437,28 @@ const struct options_table_entry options_table[] = {
 	  .text = "Character used to fill unused parts of window."
 	},
 
+	{ .name = "floating-pane-border-style",
+	  .type = OPTIONS_TABLE_STRING,
+	  .scope = OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE,
+	  .default_str = "default",
+	  .flags = OPTIONS_TABLE_IS_STYLE,
+	  .separator = ",",
+	  .text = "Default border style for floating panes. "
+		  "Overrides pane-border-style for floating panes unless "
+		  "a per-pane style is set."
+	},
+
+	{ .name = "floating-pane-style",
+	  .type = OPTIONS_TABLE_STRING,
+	  .scope = OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE,
+	  .default_str = "default",
+	  .flags = OPTIONS_TABLE_IS_STYLE,
+	  .separator = ",",
+	  .text = "Default content style for floating panes. "
+		  "Overrides window-style for floating panes unless "
+		  "a per-pane style is set."
+	},
+
 	{ .name = "main-pane-height",
 	  .type = OPTIONS_TABLE_STRING,
 	  .scope = OPTIONS_TABLE_WINDOW,

screen-write.c

@@ -147,6 +147,9 @@ screen_write_set_client_cb(struct tty_ctx *ttyctx, struct client *c)
 	if (wp->layout_cell == NULL)
 		return (0);
 
+	if (window_pane_is_hidden(wp))
+		return (0);
+
 	if (wp->flags & (PANE_REDRAW|PANE_DROP))
 		return (-1);
 	if (c->flags & CLIENT_REDRAWWINDOW) {
@@ -2225,8 +2228,11 @@ screen_write_collect_clear(struct screen_write_ctx *ctx, u_int y, u_int n)
 	struct screen_write_cline	*cl;
 	u_int				 i;
 
+	log_debug("%s: clearing rows %u..%u", __func__, y, y + n - 1);
 	for (i = y; i < y + n; i++) {
 		cl = &ctx->s->write_list[i];
+		if (!TAILQ_EMPTY(&cl->items))
+			log_debug("%s: row %u had items!", __func__, i);
 		TAILQ_CONCAT(&screen_write_citem_freelist, &cl->items, entry);
 	}
 }
@@ -2241,8 +2247,8 @@ screen_write_collect_scroll(struct screen_write_ctx *ctx, u_int bg)
 	char				*saved;
 	struct screen_write_citem	*ci;
 
-	log_debug("%s: at %u,%u (region %u-%u)", __func__, s->cx, s->cy,
-	    s->rupper, s->rlower);
+	log_debug("%s: at %u,%u (region %u-%u) cy=%u", __func__, s->cx, s->cy,
+	    s->rupper, s->rlower, s->cy);
 
 	screen_write_collect_clear(ctx, s->rupper, 1);
 	saved = ctx->s->write_list[s->rupper].data;
@@ -3084,9 +3090,14 @@ screen_write_sixelimage(struct screen_write_ctx *ctx, struct sixel_image *si,
 	}
 	screen_write_collect_flush(ctx, 0, __func__);
 
-	screen_write_initctx(ctx, &ttyctx, 0, 0);
+	screen_write_initctx(ctx, &ttyctx, 0, 1);
 	ttyctx.image = image_store(s, si);
 
+	if ((ttyctx.flags & TTY_CTX_PANE_OBSCURED) && ctx->wp != NULL) {
+		ctx->wp->flags |= PANE_REDRAW;
+		return;
+	}
+
 	tty_write(tty_cmd_sixelimage, &ttyctx);
 
 	screen_write_cursormove(ctx, 0, cy + y, 0);

tmux.1

@@ -292,6 +292,8 @@ Rename the current session.
 Split the current pane into two, left and right.
 .It &
 Kill the current window.
+.It @
+Toggle the current pane between floating and tiled.
 .It \[aq]
 Prompt for a window index to select.
 .It \&(
@@ -3249,6 +3251,21 @@ is omitted and a marked pane is present (see
 .Ic select\-pane
 .Fl m ) ,
 the marked pane is used rather than the current pane.
+.Pp
+If
+.Ar dst\-pane
+is not specified and
+.Ar src\-pane
+is floating, return the pane back to the tiled layout.
+Half the space from the nearest tiled pane in the layout tree is given to
+.Ar src\-pane .
+The floating position and sizes are saved so they can be restored if
+.Ar src\-pane
+is floated again.
+If
+.Fl d
+is given, the active pane is not changed.
+The pane must be floating, not hidden, and the window must not be zoomed.
 .Tg killp
 .It Xo Ic kill\-pane
 .Op Fl a
@@ -3417,6 +3434,23 @@ or
 (time).
 .Fl r
 reverses the sort order.
+.Tg hidep
+.It Xo Ic hide\-pane
+.Op Fl a
+.Op Fl t Ar target\-pane
+.Xc
+.D1 Pq alias: Ic hidep
+Hide
+.Ar target\-pane
+from the tiled layout without closing it.
+The pane continues to run but is no longer visible and does not occupy any
+screen space.
+Hidden panes are shown in the status line and can be restored with
+.Ic show\-pane .
+With
+.Fl a ,
+all visible panes in the window are hidden.
+The pane must not already be hidden.
 .Tg movep
 .It Xo Ic move\-pane
 .Op Fl bdfhMv
@@ -4146,6 +4180,17 @@ is omitted and a marked pane is present (see
 .Ic select\-pane
 .Fl m ) ,
 the window containing the marked pane is used rather than the current window.
+.Tg showp
+.It Xo Ic show\-pane
+.Op Fl t Ar target\-pane
+.Xc
+.D1 Pq alias: Ic showp
+Restore a hidden
+.Ar target\-pane
+to the tiled layout.
+Space is redistributed equally among all visible panes at the same layout
+level after the pane is restored.
+The pane must be hidden.
 .Tg unlinkw
 .It Xo Ic unlink\-window
 .Op Fl k
@@ -5617,6 +5662,42 @@ Set clock hour format.
 .It Ic fill\-character Ar character
 Set the character used to fill areas of the terminal unused by a window.
 .Pp
+.It Ic floating\-pane\-border\-style Ar style
+Set the default border style for all floating panes in the window.
+This overrides
+.Ic pane-border-style
+for floating panes.
+A per-pane style set with
+.Fl S
+on the
+.Ic new\-pane
+command or with
+.Ic set-option Fl p
+takes priority over this option.
+For how to specify
+.Ar style ,
+see the
+.Sx STYLES
+section.
+.Pp
+.It Ic floating\-pane\-style Ar style
+Set the default content style for all floating panes in the window.
+This overrides
+.Ic window-style
+for floating panes.
+A per-pane style set with
+.Fl s
+on the
+.Ic new\-pane
+command or with
+.Ic select-pane Fl P
+takes priority over this option.
+For how to specify
+.Ar style ,
+see the
+.Sx STYLES
+section.
+.Pp
 .It Ic main\-pane\-height Ar height
 .It Ic main\-pane\-width Ar width
 Set the width or height of the main (left or top) pane in the
@@ -7076,6 +7157,7 @@ The following variables are available, where appropriate:
 .It Li "pane_left" Ta "" Ta "Left of pane"
 .It Li "pane_marked" Ta "" Ta "1 if this is the marked pane"
 .It Li "pane_marked_set" Ta "" Ta "1 if a marked pane is set"
+.It Li "pane_hidden_flag" Ta "" Ta "1 if pane is hidden"
 .It Li "pane_mode" Ta "" Ta "Name of pane mode, if any"
 .It Li "pane_path" Ta "" Ta "Path of pane (can be set by application)"
 .It Li "pane_pid" Ta "" Ta "PID of first process in pane"

tmux.h

@@ -1277,6 +1277,7 @@ struct window_pane {
 	int		 yoff;
 
 	int		 flags;
+	int		 saved_flags;
 #define PANE_REDRAW 0x1
 #define PANE_DROP 0x2
 #define PANE_FOCUSED 0x4
@@ -1507,7 +1508,8 @@ TAILQ_HEAD(layout_cells, layout_cell);
 struct layout_cell {
 	enum layout_type type;
 
-#define LAYOUT_CELL_FLOATING 0x1
+#define LAYOUT_CELL_FLOATING	0x1
+#define LAYOUT_CELL_HIDDEN	0x2
 	int		 flags;
 
 	struct layout_cell *parent;
@@ -3664,6 +3666,7 @@ int		 window_pane_get_pane_status(struct window_pane *);
 struct style_range *window_pane_status_get_range(struct window_pane *, u_int,
 		     u_int);
 int		 window_pane_is_floating(struct window_pane *);
+int		 window_pane_is_hidden(struct window_pane *);
 
 /* window-border.c */
 void		 window_get_border_cell(struct window *, struct window_pane *,
@@ -3687,10 +3690,13 @@ void		 layout_free_cell(struct layout_cell *, int);
 void		 layout_print_cell(struct layout_cell *, const char *, u_int);
 void		 layout_destroy_cell(struct window *, struct layout_cell *,
 		     struct layout_cell **);
+void		 layout_hide_cell(struct window *, struct layout_cell *);
+void		 layout_show_cell(struct window *, struct layout_cell *);
 void		 layout_resize_layout(struct window *, struct layout_cell *,
 		     enum layout_type, int, int);
 struct layout_cell *layout_search_by_border(struct layout_cell *, u_int, u_int);
 void             layout_set_size(struct layout_cell *, u_int, u_int, int, int);
+void             layout_save_size(struct layout_cell *);
 void		 layout_make_leaf(struct layout_cell *, struct window_pane *);
 void		 layout_make_node(struct layout_cell *, enum layout_type);
 void		 layout_fix_zindexes(struct window *, struct layout_cell *);

tty.c

@@ -2156,20 +2156,169 @@ tty_cmd_rawstring(struct tty *tty, const struct tty_ctx *ctx)
 }
 
 #ifdef ENABLE_SIXEL
+/*
+ * Render one sub-rectangle of a sixel image at tty position (dst_x, dst_y).
+ * Caller must have set tty->flags |= TTY_NOBLOCK and called tty_region_off
+ * and tty_margin_off.  After the call, tty->cx and tty->cy are UINT_MAX
+ * because the cursor position after a sixel DCS sequence is terminal-defined.
+ */
+static void
+tty_sixel_subrect(struct tty *tty, struct sixel_image *si,
+    u_int src_i, u_int src_j, u_int src_rx, u_int src_ry,
+    u_int dst_x, u_int dst_y)
+{
+	struct sixel_image	*sub;
+	char			*data;
+	size_t			 size;
+
+	if (src_rx == 0 || src_ry == 0)
+		return;
+	sub = sixel_scale(si, tty->xpixel, tty->ypixel,
+	    src_i, src_j, src_rx, src_ry, 0);
+	if (sub == NULL)
+		return;
+	data = sixel_print(sub, si, &size);
+	sixel_free(sub);
+	if (data == NULL)
+		return;
+	tty_cursor(tty, dst_x, dst_y);
+	tty_add(tty, data, size);
+	tty->cx = tty->cy = UINT_MAX;
+	free(data);
+}
+
+/*
+ * Render the clamped region of sixel image si, split into sub-rectangles
+ * that avoid cells obscured by floating panes above this one.
+ *
+ * Row breakpoints are computed from each floating pane's top/bottom border
+ * row.  Between breakpoints the visible column ranges are constant, so each
+ * strip is rendered with one set of sub-rectangles.  When no floating panes
+ * overlap the sixel the loop produces a single strip and one sub-rect equal
+ * to the full clamped rectangle.
+ *
+ * i, j  : source cell offset (top-left of visible portion after viewport clip)
+ * rx, ry: rendered size in cells
+ * x, y  : tty destination position
+ */
+static void
+tty_sixelimage_draw(struct tty *tty, const struct tty_ctx *ctx,
+    struct sixel_image *si, u_int i, u_int j, u_int rx, u_int ry,
+    u_int x, u_int y)
+{
+	struct window_pane	*wp, *fp;
+	struct window		*w;
+	struct visible_ranges	*vr;
+	struct visible_range	*ri;
+	u_int			 sixel_wx0, sixel_wx1, sixel_y0;
+	u_int			 breaks[64], nb, b, s, tmp;
+	u_int			 strip_start, strip_end, strip_h;
+	u_int			 seg_wx0, seg_wx1, seg_w;
+	u_int			 src_i2, src_j2, dst_x2;
+	int			 fp_tb, fp_bb1, r_top, r_bot;
+
+	tty->flags |= TTY_NOBLOCK;
+	tty_region_off(tty);
+	tty_margin_off(tty);
+
+	wp = ctx->arg;
+	if (wp == NULL) {
+		/* Overlay/popup: no pane context, render the full clamped rect. */
+		tty_sixel_subrect(tty, si, i, j, rx, ry, x, y);
+		tty_invalidate(tty);
+		return;
+	}
+
+	/*
+	 * sixel_y0 is the window y-coordinate of the first rendered row.
+	 * Derived from tty_clamp_area: y = ctx->yoff + ocy + j - ctx->woy,
+	 * so y + ctx->woy = ctx->yoff + ocy + j.
+	 */
+	w = wp->window;
+	sixel_wx0 = x + ctx->wox;
+	sixel_wx1 = sixel_wx0 + rx;
+	sixel_y0  = y + ctx->woy;
+
+	nb = 0;
+	breaks[nb++] = 0;
+	breaks[nb++] = ry;
+
+	TAILQ_FOREACH(fp, &w->z_index, zentry) {
+		if (!window_pane_is_floating(fp))
+			continue;
+		fp_tb  = (int)((fp->yoff > 0) ? fp->yoff - 1 : 0);
+		fp_bb1 = (int)fp->yoff + (int)fp->sy + 1;
+		r_top  = fp_tb  - (int)sixel_y0;
+		r_bot  = fp_bb1 - (int)sixel_y0;
+		if (r_top > 0 && (u_int)r_top < ry && nb < 62)
+			breaks[nb++] = (u_int)r_top;
+		if (r_bot > 0 && (u_int)r_bot < ry && nb < 62)
+			breaks[nb++] = (u_int)r_bot;
+	}
+
+	/* Sort breakpoints (insertion sort; small array). */
+	for (b = 1; b < nb; b++) {
+		tmp = breaks[b];
+		s = b;
+		while (s > 0 && breaks[s - 1] > tmp) {
+			breaks[s] = breaks[s - 1];
+			s--;
+		}
+		breaks[s] = tmp;
+	}
+
+	if (nb > 2)
+		log_debug("%s: sixel %%%u clipped around floating panes",
+		    __func__, wp->id);
+
+	for (b = 0; b + 1 < nb; b++) {
+		strip_start = breaks[b];
+		strip_end   = breaks[b + 1];
+		if (strip_end == strip_start)
+			continue;
+		strip_h = strip_end - strip_start;
+
+		vr = screen_redraw_get_visible_ranges(wp, ctx->xoff,
+		    sixel_y0 + strip_start, wp->sx, NULL);
+
+		for (s = 0; s < vr->used; s++) {
+			ri = &vr->ranges[s];
+			if (ri->nx == 0)
+				continue;
+			seg_wx0 = ri->px;
+			seg_wx1 = ri->px + ri->nx;
+			if (seg_wx0 < sixel_wx0)
+				seg_wx0 = sixel_wx0;
+			if (seg_wx1 > sixel_wx1)
+				seg_wx1 = sixel_wx1;
+			if (seg_wx1 <= seg_wx0)
+				continue;
+			seg_w  = seg_wx1 - seg_wx0;
+			src_i2 = i + (seg_wx0 - sixel_wx0);
+			src_j2 = j + strip_start;
+			dst_x2 = seg_wx0 - ctx->wox;
+			tty_sixel_subrect(tty, si, src_i2, src_j2,
+			    seg_w, strip_h, dst_x2, y + strip_start);
+		}
+	}
+
+	tty_invalidate(tty);
+}
+
 void
 tty_cmd_sixelimage(struct tty *tty, const struct tty_ctx *ctx)
 {
 	struct image		*im = ctx->image;
 	struct sixel_image	*si = im->data;
-	struct sixel_image	*new;
 	char			*data;
 	size_t			 size;
 	u_int			 cx = ctx->ocx, cy = ctx->ocy, sx, sy;
 	u_int			 i, j, x, y, rx, ry;
-	int			 fallback = 0;
+	int			 fallback;
 
+	fallback = 0;
 	if ((~tty->term->flags & TERM_SIXEL) &&
-            !tty_term_has(tty->term, TTYC_SXL))
+	    !tty_term_has(tty->term, TTYC_SXL))
 		fallback = 1;
 	if (tty->xpixel == 0 || tty->ypixel == 0)
 		fallback = 1;
@@ -2180,30 +2329,20 @@ tty_cmd_sixelimage(struct tty *tty, const struct tty_ctx *ctx)
 		return;
 	log_debug("%s: clamping to %u,%u-%u,%u", __func__, i, j, rx, ry);
 
-	if (fallback == 1) {
+	if (fallback) {
 		data = xstrdup(im->fallback);
 		size = strlen(data);
-	} else {
-		new = sixel_scale(si, tty->xpixel, tty->ypixel, i, j, rx, ry, 0);
-		if (new == NULL)
-			return;
-
-		data = sixel_print(new, si, &size);
-	}
-	if (data != NULL) {
-		log_debug("%s: %zu bytes: %s", __func__, size, data);
+		tty->flags |= TTY_NOBLOCK;
 		tty_region_off(tty);
 		tty_margin_off(tty);
 		tty_cursor(tty, x, y);
-
-		tty->flags |= TTY_NOBLOCK;
 		tty_add(tty, data, size);
 		tty_invalidate(tty);
 		free(data);
+		return;
 	}
 
-	if (fallback == 0)
-		sixel_free(new);
+	tty_sixelimage_draw(tty, ctx, si, i, j, rx, ry, x, y);
 }
 #endif
 
@@ -3121,7 +3260,6 @@ tty_style_changed(struct window_pane *wp)
 {
 	struct options		*oo = wp->options;
 	struct format_tree	*ft;
-	struct style		*sy;
 
 	log_debug("%%%u: style changed", wp->id);
 	wp->flags &= ~PANE_STYLECHANGED;
@@ -3130,12 +3268,14 @@ tty_style_changed(struct window_pane *wp)
 	format_defaults(ft, NULL, NULL, NULL, wp);
 
 	tty_window_default_style(&wp->cached_active_gc, wp);
-	sy = style_add(&wp->cached_active_gc, oo, "window-active-style", ft);
-	wp->cached_active_dim = sy->dim;
+	style_add(&wp->cached_active_gc, oo, "window-active-style", ft);
+	if (window_pane_is_floating(wp))
+		style_add(&wp->cached_active_gc, oo, "floating-pane-style", ft);
 
 	tty_window_default_style(&wp->cached_gc, wp);
-	sy = style_add(&wp->cached_gc, oo, "window-style", ft);
-	wp->cached_dim = sy->dim;
+	style_add(&wp->cached_gc, oo, "window-style", ft);
+	if (window_pane_is_floating(wp))
+		style_add(&wp->cached_active_gc, oo, "floating-pane-style", ft);
 
 	format_free(ft);
 }

window-tree.c

@@ -345,7 +345,7 @@ window_tree_build_window(struct session *s, struct winlink *wl,
 
 	if (data->type == WINDOW_TREE_SESSION ||
 	    data->type == WINDOW_TREE_WINDOW)
-		expanded = 0;
+		expanded = window_has_floating_panes(wl->window);
 	else
 		expanded = 1;
 	mti = mode_tree_add(data->data, parent, item, (uint64_t)wl, name, text,

window.c

@@ -554,7 +554,8 @@ window_pane_update_focus(struct window_pane *wp)
 int
 window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 {
-	struct window_pane *lastwp;
+	struct window_pane	*lastwp;
+	struct layout_cell	*lc;
 
 	log_debug("%s: pane %%%u", __func__, wp->id);
 
@@ -568,8 +569,19 @@ window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 	window_pane_stack_push(&w->last_panes, lastwp);
 
 	w->active = wp;
-	w->active->active_point = next_active_point++;
-	w->active->flags |= PANE_CHANGED;
+	wp->active_point = next_active_point++;
+	wp->flags |= PANE_CHANGED;
+	lc = wp->layout_cell;
+
+	if (window_pane_is_hidden(wp)) {
+		lc->flags &= ~LAYOUT_CELL_HIDDEN;
+		layout_insert_tile(w, lc);
+		layout_fix_offsets(w);
+		layout_fix_panes(w, NULL);
+	}
+	notify_window("window-layout-changed", w);
+	server_redraw_window(w);
+
 
 	if (options_get_number(global_options, "focus-events")) {
 		window_pane_update_focus(lastwp);
@@ -755,8 +767,6 @@ window_zoom(struct window_pane *wp)
 
 	if (w->flags & WINDOW_ZOOMED)
 		return (-1);
-	if (window_count_panes(w, 1) == 1)
-		return (-1);
 
 	if (w->active != wp)
 		window_set_active_pane(w, wp, 1);
@@ -863,26 +873,41 @@ window_add_pane(struct window *w, struct window_pane *other, u_int hlimit,
 void
 window_lost_pane(struct window *w, struct window_pane *wp)
 {
+	struct window_pane	*wpp, *twpp;
+
 	log_debug("%s: @%u pane %%%u", __func__, w->id, wp->id);
 
 	if (wp == marked_pane.wp)
 		server_clear_marked();
 
 	window_pane_stack_remove(&w->last_panes, wp);
-	if (wp == w->active) {
-		w->active = TAILQ_FIRST(&w->last_panes);
-		if (w->active == NULL) {
-			w->active = TAILQ_PREV(wp, window_panes, entry);
-			if (w->active == NULL)
-				w->active = TAILQ_NEXT(wp, entry);
-		}
-		if (w->active != NULL) {
-			window_pane_stack_remove(&w->last_panes, w->active);
-			w->active->flags |= PANE_CHANGED;
-			notify_window("window-pane-changed", w);
-			window_update_focus(w);
+	if (wp != w->active)
+		return;
+
+	/* Try to find a good fit. */
+	wpp = TAILQ_FIRST(&w->last_panes);
+	if (wpp == NULL || window_pane_is_hidden(wpp)) {
+		wpp = TAILQ_PREV(wp, window_panes, entry);
+		if (wpp == NULL || window_pane_is_hidden(wpp))
+			wpp = TAILQ_NEXT(wp, entry);
+	}
+	/* Try to find any fit. */
+	if (wpp == NULL || window_pane_is_hidden(wpp)) {
+		TAILQ_FOREACH_SAFE(wpp, &w->panes, entry, twpp) {
+			if (wpp != wp && !window_pane_is_hidden(wpp))
+				break;
 		}
 	}
+	if (wpp != NULL && window_pane_is_hidden(wpp))
+		wpp = NULL;
+
+	w->active = wpp;
+	if (w->active != NULL) {
+		window_pane_stack_remove(&w->last_panes, w->active);
+		w->active->flags |= PANE_CHANGED;
+		notify_window("window-pane-changed", w);
+		window_update_focus(w);
+	}
 	redraw_invalidate_scene(w);
 }
 
@@ -1045,6 +1070,9 @@ window_pane_printable_flags(struct window_pane *wp)
 		flags[pos++] = 'Z';
 	if (window_pane_is_floating(wp))
 		flags[pos++] = 'F';
+	if (window_pane_is_hidden(wp))
+		flags[pos++] = 'm';
+
 	flags[pos] = '\0';
 	return (flags);
 }
@@ -1689,8 +1717,11 @@ window_pane_key(struct window_pane *wp, struct client *c, struct session *s,
 int
 window_pane_is_visible(struct window_pane *wp)
 {
+	if (window_pane_is_hidden(wp))
+		return (0);
 	if (~wp->window->flags & WINDOW_ZOOMED)
 		return (1);
+
 	return (wp == wp->window->active);
 }
 
@@ -2539,9 +2570,11 @@ window_pane_get_pane_status(struct window_pane *wp)
 int
 window_pane_is_floating(struct window_pane *wp)
 {
-	struct layout_cell	*lc = wp->layout_cell;
+	return (wp->layout_cell->flags & LAYOUT_CELL_FLOATING);
+}
 
-	if (lc == NULL || (lc->flags & LAYOUT_CELL_FLOATING) == 0)
-		return (0);
-	return (1);
+int
+window_pane_is_hidden(struct window_pane *wp)
+{
+	return (wp->layout_cell->flags & LAYOUT_CELL_HIDDEN);
 }