2.9 now.

Thomas Sattler.

CHANGES

@@ -1,3 +1,226 @@
+CHANGES FROM 2.8 to 2.9
+
+* Attempt to preserve horizontal cursor position as well as vertical with
+  reflow.
+
+* Rewrite main-vertical and horizontal and change layouts to better handle the
+  case where all panes won't fit into the window size, reduce problems with
+  pane border status lines and fix other bugs mostly found by Thomas Sattler.
+
+* Add format variables for the default formats in the various modes
+  (tree_mode_format and so on) and add a -a flag to display-message to list
+  variables with values.
+
+* Add a -v flag to display-message to show verbose messages as the format is
+  parsed, this allows formats to be debugged
+
+* Add support for HPA (\033[`).
+
+* Add support for origin mode (\033[?6h).
+
+* No longer clear history on RIS.
+
+* Extend the #[] style syntax and use that together with previous format
+  changes to allow the status line to be entirely configured with a single
+  option.
+
+  Now that it is possible to configure their content, enable the existing code
+  that lets the status line be multiple lines in height. The status option can
+  now take a value of 2, 3, 4 or 5 (as well as the previous on or off) to
+  configure more than one line. The new status-format array option configures
+  the format of each line, the default just references the existing status-*
+  options, although some of the more obscure status options may be eliminated
+  in time.
+
+  Additions to the #[] syntax are: "align" to specify alignment (left, centre,
+  right), "list" for the window list and "range" to configure ranges of text
+  for the mouse bindings.
+
+  The "align" keyword can also be used to specify alignment of entries in tree
+  mode and the pane status lines.
+
+* Add E: and T: format modifiers to expand a format twice (useful to expand the
+  value of an option).
+
+* The individual -fg, -bg and -attr options have been removed; they
+  were superseded by -style options in tmux 1.9.
+
+* Allow more than one mode to be opened in a pane. Modes are kept on a stack
+  and retrieved if the same mode is entered again. Exiting the active mode goes
+  back to the previous one.
+
+* When showing command output in copy mode, call it view mode instead (affects
+  pane_mode format).
+
+* Add -b to display-panes like run-shell.
+
+* Handle UTF-8 in word-separators option.
+
+* New "terminal" colour allowing options to use the terminal default colour
+  rather than inheriting the default from a parent option.
+
+* Do not move the cursor in copy mode when the mouse wheel is used.
+
+* Use the same working directory rules for jobs as new windows rather than
+  always starting in the user's home.
+
+* Allow panes to be one line or column in size.
+
+* Go to last line when goto-line number is out of range in copy mode.
+
+* Yank previously cut text if any with C-y in the command prompt, only use the
+  buffer if no text has been cut.
+
+* Add q: format modifier to quote shell special characters.
+
+* Add StatusLeft and StatusRight mouse locations (keys such as
+  MouseDown1StatusLeft) for the status-left and status-right areas of the
+  status line.
+
+* Add -Z to find-window.
+
+* Support for windows larger than the client. This adds two new options,
+  window-size and default-size, and a new command, resize-window. The
+  force-width and force-height options and the session_width and session_height
+  formats have been removed.
+
+  The new window-size option tells tmux how to work out the size of windows:
+  largest means it picks the size of the largest session, smallest the smallest
+  session (similar to the old behaviour) and manual means that it does not
+  automatically resize windows. aggressive-resize modifies the choice of
+  session for largest and smallest as it did before.
+
+  If a window is in a session attached to a client that is too small, only part
+  of the window is shown. tmux attempts to keep the cursor visible, so the part
+  of the window displayed is changed as the cursor moves (with a small delay,
+  to try and avoid excess redrawing when applications redraw status lines or
+  similar that are not currently visible).
+
+  Drawing windows which are larger than the client is not as efficient as those
+  which fit, particularly when the cursor moves, so it is recommended to avoid
+  using this on slow machines or networks (set window-size to smallest or
+  manual).
+
+  The resize-window command can be used to resize a window manually. If it is
+  used, the window-size option is automatically set to manual for the window
+  (undo this with "setw -u window-size"). resize-window works in a similar way
+  to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a
+  sets the window to the size of the smallest client (what it would be if
+  window-size was smallest) and -A the largest.
+
+  For the same behaviour as force-width or force-height, use resize-window -x
+  or -y.
+
+  If the global window-size option is set to manual, the default-size option is
+  used for new windows. If -x or -y is used with new-session, that sets the
+  default-size option for the new session.
+
+  The maximum size of a window is 10000x10000. But expect applications to
+  complain and higher memory use if making a window that big. The minimum size
+  is the size required for the current layout including borders.
+
+  The refresh-client command can be used to pan around a window, -U -D -L -R
+  moves up, down, left or right and -c returns to automatic cursor
+  tracking. The position is reset when the current window is changed.
+
+CHANGES FROM 2.7 to 2.8
+
+* Make display-panes block the client until a pane is chosen or it
+  times out.
+
+* Clear history on RIS like most other terminals do.
+
+* Add an "Any" key to run a command if a key is pressed that is not
+  bound in the current key table.
+
+* Expand formats in load-buffer and save-buffer.
+
+* Add a rectangle_toggle format.
+
+* Add set-hook -R to run a hook immediately.
+
+* Add README.ja.
+
+* Add pane focus hooks.
+
+* Allow any punctuation as separator for s/x/y not only /.
+
+* Improve resizing with the mouse (fix resizing the wrong pane in some
+  layouts, and allow resizing multiple panes at the same time).
+
+* Allow , and } to be escaped in formats as #, and #}.
+
+* Add KRB5CCNAME to update-environment.
+
+* Change meaning of -c to display-message so the client is used if it
+  matches the session given to -t.
+
+* Fixes to : form of SGR.
+
+* Add x and X to choose-tree to kill sessions, windows or panes.
+
+CHANGES FROM 2.6 TO 2.7
+
+* Remove EVENT_* variables from environment on platforms where tmux uses them
+  so they do not pass on to panes.
+
+* Fixes for hooks at server exit.
+
+* Remove SGR 10 (was equivalent to SGR 0 but no other terminal seems to do
+  this).
+
+* Expand formats in window and session names.
+
+* Add -Z flag to choose-tree, choose-client, choose-buffer to automatically
+  zoom the pane when the mode is entered and unzoom when it exits, assuming the
+  pane is not already zoomed. This is now part of the default key bindings.
+
+* Add C-g to exit modes with emacs keys.
+
+* Add exit-empty option to exit server if no sessions (defaults to on).
+
+* Show if a filter is present in choose modes.
+
+* Add pipe-pane -I to to connect stdin of the child process.
+
+* Performance improvements for reflow.
+
+* Use RGB terminfo(5) capability to detect RGB colour terminals (the existing
+  Tc extension remains unchanged).
+
+* Support for ISO colon-separated SGR sequences.
+
+* Add select-layout -E to spread panes out evenly (bound to E key).
+
+* Support wide characters properly when reflowing.
+
+* Pass PWD to new panes as a hint to shells, as well as calling chdir().
+
+* Performance improvements for the various choose modes.
+
+* Only show first member of session groups in tree mode (-G flag to choose-tree
+  to show all).
+
+* Support %else in config files to match %if; from Brad Town in GitHub issue
+  1071.
+
+* Fix "kind" terminfo(5) capability to be S-Down not S-Up.
+
+* Add a box around the preview label in tree mode.
+
+* Show exit status and time in the remain-on-exit pane text; from Timo
+  Boettcher in GitHub issue 1103.
+
+* Correctly use pane-base-index in tree mode.
+
+* Change the allow-rename option default to off.
+
+* Support for xterm(1) title stack escape sequences (GitHub issue 1075 from
+  Brad Town).
+
+* Correctly remove padding cells to fix a UTF-8 display problem (GitHub issue
+  1090).
+
 CHANGES FROM 2.5 TO 2.6, 05 October 2017
 
 * Add select-pane -T to set pane title.
@@ -193,7 +416,7 @@ CHANGES FROM 2.4 TO 2.5, 09 May 2017
 
 * Do not redraw a client unless we realistically think it can accept the data -
   defer redraws until the client has nothing else waiting to write.
- 
+
 CHANGES FROM 2.3 TO 2.4, 20 April 2017
 
 Incompatible Changes
@@ -479,7 +702,7 @@ Normal Changes
 ==============
 
 * Fix crash due to uninitialized lastwp member of layout_cell
-* Fix -fg/-bg/-style with 256 colour terminals.  
+* Fix -fg/-bg/-style with 256 colour terminals.
 
 CHANGES FROM 1.8 TO 1.9, 20 February 2014
 
@@ -837,7 +1060,7 @@ CHANGES FROM 1.2 TO 1.3, 18 July 2010
 * Run job commands explicitly in the global environment (which can be modified
   with setenv -g), rather than with the environment tmux started with.
 * Use the machine's hostname as the default title, instead of an empty string.
-* Prevent double free if the window option remain-on-exit is set. 
+* Prevent double free if the window option remain-on-exit is set.
 * Key string conversions rewritten.
 * Mark zombie windows as dead in the choose-window list.
 * Tiled layout added.
@@ -939,7 +1162,7 @@ CHANGES FROM 1.0 TO 1.1, 05 November 2009
 * New lock-client (alias lockc), and lock-session (alias locks) commands to
   lock a particular client, or all clients attached to a session.
 * Support C-n/C-p/C-v/M-v with emacs keys in choice mode.
-* Use : for goto line rather than g in vi mode. 
+* Use : for goto line rather than g in vi mode.
 * Try to guess which client to use when no target client was specified. Finds
   the current session, and if only one client is present, use it. Otherwise,
   return the most recently used client.
@@ -1070,7 +1293,7 @@ The list of older changes is below.
 
 * main-horizontal layout and main-pane-height option to match vertical.
 * New window option main-pane-width to set the width of the large left pane with
-  main-vertical (was left-vertical) layout. 
+  main-vertical (was left-vertical) layout.
 * Lots of layout cleanup. manual layout is now manual-vertical.
 
 16 May 2009

CONTRIBUTING

@@ -18,7 +18,7 @@ This should include at least the output of:
     $ uname -sp && tmux -V && echo $TERM
 
 Please do not report bugs (crashes, incorrect behaviour) without reproducing on
-a tmux built from Git master.
+a tmux built from the latest code in Git.
 
 Note that TERM inside tmux must be a variant of screen or tmux (for example:
 screen or screen-256color, tmux or tmux-256color). Please ensure this is the

Makefile.am

@@ -6,7 +6,7 @@ CLEANFILES = tmux.1.mdoc tmux.1.man
 
 # Distribution tarball options.
 EXTRA_DIST = \
-	CHANGES README COPYING example_tmux.conf compat/*.[ch] \
+	CHANGES README README.ja COPYING example_tmux.conf compat/*.[ch] \
 	osdep-*.c mdoc2man.awk tmux.1
 
 # Preprocessor flags.
@@ -100,6 +100,7 @@ dist_tmux_SOURCES = \
 	cmd-rename-session.c \
 	cmd-rename-window.c \
 	cmd-resize-pane.c \
+	cmd-resize-window.c \
 	cmd-respawn-pane.c \
 	cmd-respawn-window.c \
 	cmd-rotate-window.c \
@@ -131,6 +132,7 @@ dist_tmux_SOURCES = \
 	control.c \
 	environ.c \
 	format.c \
+	format-draw.c \
 	grid-view.c \
 	grid.c \
 	hooks.c \
@@ -195,7 +197,7 @@ install-exec-hook:
 			>$(srcdir)/tmux.1.mdoc; \
 	else \
 		sed -e "s|@SYSCONFDIR@|$(sysconfdir)|g" $(srcdir)/tmux.1| \
-			$(AWK) -f$(srcdir)/mdoc2man.awk >$(srcdir)/tmux.1.man; \
+			$(AWK) -f $(srcdir)/mdoc2man.awk >$(srcdir)/tmux.1.man; \
 	fi
 	$(mkdir_p) $(DESTDIR)$(mandir)/man1
 	$(INSTALL_DATA) $(srcdir)/tmux.1.@MANFORMAT@ \

README

@@ -1,8 +1,8 @@
 Welcome to tmux!
 
-tmux is a "terminal multiplexer", it enables a number of terminals (or windows)
-to be accessed and controlled from a single terminal. tmux is intended to be a
-simple, modern, BSD-licensed alternative to programs such as GNU screen.
+tmux is a terminal multiplexer: it enables a number of terminals to be created,
+accessed, and controlled from a single screen. tmux may be detached from a
+screen and continue running in the background, then later reattached.
 
 This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.
 
@@ -43,11 +43,6 @@ the source tree with:
 
 A small example configuration in example_tmux.conf.
 
-A vim(1) syntax file is available at:
-
-	https://github.com/ericpruitt/tmux.vim
-	https://raw.githubusercontent.com/ericpruitt/tmux.vim/master/vim/syntax/tmux.vim
-
 And a bash(1) completion file at:
 
 	https://github.com/imomaliev/tmux-bash-completion

README.ja

@@ -0,0 +1,62 @@
+tmuxへようこそ!
+
+tmuxはターミナルマルチプレクサーです。複数のターミナルを一つのスクリーン内に作成し、操作することができます。
+バックグラウンドで処理を実行中に一度スクリーンから離れて後から復帰することも可能です。
+
+OpenBSD、FreeBSD、NetBSD、Linux、OS X、Solarisで実行できます。
+
+tmuxはlibevent 2.x.に依存します。 下記からダウンロードしてください。
+
+	http://libevent.org
+
+また、ncursesも必要です。こちらからどうぞ。
+
+	http://invisible-island.net/ncurses/
+
+tarballでのtmuxのビルドとインストール方法。
+
+	$ ./configure && make
+	$ sudo make install
+
+tmuxはutmp(5)をアップデートするためにutempterを使うことができます。もしインストール済みであればオプション「--enable-utempter」をつけて実行してください。
+
+リポジトリから最新バージョンを手に入れるためには下記を実行。
+
+	$ git clone https://github.com/tmux/tmux.git
+	$ cd tmux
+	$ sh autogen.sh
+	$ ./configure && make
+
+(ビルドのためにはlibevent、ncurses libraries、headersに加えて、C compiler、make、autoconf、automake、pkg-configが必要です。)
+
+詳しい情報はhttp://git-scm.comをご覧ください。修正はメール<tmux-users@googlegroups.com>宛、もしくはhttps://github.com/tmux/tmux/issuesにて受け付けています。
+
+tmuxのドキュメントについてはtmux.1マニュアルをご覧ください。こちらのコマンドで参照可能です。
+
+	$ nroff -mdoc tmux.1|less
+
+サンプル設定は本リポジトリのexample_tmux.confに
+また、bash-completionファイルは下記にあります。
+
+	https://github.com/imomaliev/tmux-bash-completion
+
+「-v」や「-vv」を指定することでデバッグモードでの起動が可能です。カレントディレクトリにサーバーやクライアントのログファイルが生成されます。
+
+議論やバグレポート用のメーリングリストにはこちらから参加可能です。
+
+	https://groups.google.com/forum/#!forum/tmux-users
+
+gitコミットについての連絡先
+
+	https://groups.google.com/forum/#!forum/tmux-git
+
+購読は<tmux-users+subscribe@googlegroups.com>までメールをお願いします。
+
+バグレポートや機能追加(特にコードへの貢献)は大歓迎です。こちらにご連絡ください。
+
+	tmux-users@googlegroups.com
+
+本ファイル、CHANGES、 FAQ、SYNCINGそしてTODOはISC licenseで保護されています。
+その他のファイルのライセンスや著作権については、ファイルの上部に明記されています。
+
+-- Nicholas Marriott <nicholas.marriott@gmail.com>

TODO

@@ -16,13 +16,11 @@
 	* way to set socket path from config file
 
 - format improvements:
-	* option to quote format (#{q:session_name})
 	* some way to pad # stuff with spaces
 	* formats to show if a window is linked into multiple sessions, into
 	  multiple attached sessions, and is the active window in multiple
 	  attached sessions?
 	* comparison operators like < and > (for #{version}?)
-	* %else statement in config file
 
 - improve monitor-*:
 	* straighten out rules for multiple clients
@@ -31,7 +29,7 @@
 	* perhaps monitor /all/ panes in the window not just one
 
 - improve mouse support:
-	* bind commands to mouse in different areas? 
+	* bind commands to mouse in different areas?
 	* commands executed when clicking on a pattern (URL)
 
 - warts on current naming:
@@ -49,6 +47,12 @@
 	* improve word and line selection in copy mode (for example when
 	  dragging it should select by word. compare how xterm works. GitHub
 	  issue 682)
+	* key to search for word under cursor (GitHub issue 1240)
+	* when entering copy mode, should copy grid so that input does not
+	  need to be suspended
+	* allow the prefix for automatic buffers to be specified as part of the
+	  key binding to allow session buffers or similar (GitHub issue 1501)
+	* copy-pipe should be synchronous (GitHub issue 1517)
 
 - layout stuff
 	* way to tag a layout as a number/name
@@ -60,7 +64,6 @@
 	  not attached to a cell at all. this could be the time to introduce
 	  panelink to replace layout_cell
 	* way to set hints/limits about pane size for resizing
-	* panning over window (window larger than visible)
 	* a mode where one application can cross two panes (ie x|y, width =
 	  COLUMNS/2 but height = ROWS * 2)
 	* separate active panes for different clients
@@ -108,23 +111,51 @@
 	* marks in history, automatically add (move?) one when pane is changed
 	* this doesn't work, need pane reference count probably:
 	  bind -n DoubleClick3Status confirm-before -p "kill-window #I? (y/n)" kill-window
-	* respawn -c flag same as neww etc
 	* marker lines in history (GitHub issue 1042)
-	* tree mode stuff: predefined filters, tag-all key, ...
+	* tree mode stuff: make command prompt (:) common code so all modes get it,
+	  predefined filters, tag-all key, ...
+	* drag panes and windows around to move/swap them in choose mode
+	* flag to specify environment to new-window, split-window,
+          new-session (issue 1498)
+	* multiple column panes (issue 1503)
+	* support for ZERO WIDTH JOINER U+200D
+	* individual pane synchronize-panes (with pane options?); issue 1638
 
 - hooks
 	* more hooks for various things
 	* finish after hooks for special commands. these do not have a hook at
-          the moment:
+	  the moment:
 		 attach-session detach-client kill-server respawn-window
 		 swap-window break-pane find-window kill-session rotate-window
 		 switch-client choose-tree if-shell kill-window run-shell
 		 wait-for command-prompt join-pane move-window source-file
 		 confirm-before kill-pane respawn-pane swap-pane
-          at the moment AFTERHOOK uses current only if target is not valid,
-          but target is ALWAYS valid - it should use current if no -t flag?
-          then select-* could use AFTERHOOK
+	  at the moment AFTERHOOK uses current only if target is not valid,
+	  but target is ALWAYS valid - it should use current if no -t flag?
+	  then select-* could use AFTERHOOK
 	* multiple hooks with the same name?
 	* finish hooks for notifys
 	* for session_closed, if no sessions at all, perhaps fake up a
-          temporary one
+	  temporary one
+
+- pan
+	* tty_window_offset should try to keep as much off active pane
+	  visible as possible
+	* rather than centering cursor it might be better if only
+	  moved offset when it gets close to an edge?
+
+----
+
+TODO soonish maybe:
+
+- Store hooks as options, issue 1619.
+- Support buffer prefixes, issue 1501.
+- copy-pipe should be synchronous, issue 1517.
+- -E flag to pass environment to new-*, issue 1498.
+- Copy mode searching is slow when there is a big history, issue 1545.
+- Grid "block" stuff, issue 1269. Can be used potentially for compression of
+  history (bit silly really though), reflow performance (can reflow blocks on
+  demand). It would possibly be good if history-limit could be global and
+  collected LRU.
+- Command aliases should be able to override builtin commands in order to add
+  default flags (some mechanism needed to avoid recursion). GitHub issue 1630.

alerts.c

@@ -200,8 +200,10 @@ alerts_check_bell(struct window *w)
 		 * not check WINLINK_BELL).
 		 */
 		s = wl->session;
-		if (s->curw != wl)
+		if (s->curw != wl) {
 			wl->flags |= WINLINK_BELL;
+			server_status_session(s);
+		}
 		if (!alerts_action_applies(wl, "bell-action"))
 			continue;
 		notify_winlink("alert-bell", wl);
@@ -234,8 +236,10 @@ alerts_check_activity(struct window *w)
 		if (wl->flags & WINLINK_ACTIVITY)
 			continue;
 		s = wl->session;
-		if (s->curw != wl)
+		if (s->curw != wl) {
 			wl->flags |= WINLINK_ACTIVITY;
+			server_status_session(s);
+		}
 		if (!alerts_action_applies(wl, "activity-action"))
 			continue;
 		notify_winlink("alert-activity", wl);
@@ -268,8 +272,10 @@ alerts_check_silence(struct window *w)
 		if (wl->flags & WINLINK_SILENCE)
 			continue;
 		s = wl->session;
-		if (s->curw != wl)
+		if (s->curw != wl) {
 			wl->flags |= WINLINK_SILENCE;
+			server_status_session(s);
+		}
 		if (!alerts_action_applies(wl, "silence-action"))
 			continue;
 		notify_winlink("alert-silence", wl);

attributes.c

@@ -25,13 +25,13 @@
 const char *
 attributes_tostring(int attr)
 {
-	static char	buf[128];
+	static char	buf[512];
 	size_t		len;
 
 	if (attr == 0)
 		return ("none");
 
-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s",
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s",
 	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
 	    (attr & GRID_ATTR_DIM) ? "dim," : "",
 	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
@@ -39,7 +39,11 @@ attributes_tostring(int attr)
 	    (attr & GRID_ATTR_REVERSE) ? "reverse," : "",
 	    (attr & GRID_ATTR_HIDDEN) ? "hidden," : "",
 	    (attr & GRID_ATTR_ITALICS) ? "italics," : "",
-	    (attr & GRID_ATTR_STRIKETHROUGH) ? "strikethrough," : "");
+	    (attr & GRID_ATTR_STRIKETHROUGH) ? "strikethrough," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_2) ? "double-underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_3) ? "curly-underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_4) ? "dotted-underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_5) ? "dashed-underscore," : "");
 	if (len > 0)
 		buf[len - 1] = '\0';
 
@@ -52,6 +56,25 @@ attributes_fromstring(const char *str)
 	const char	delimiters[] = " ,|";
 	int		attr;
 	size_t		end;
+	u_int		i;
+	struct {
+		const char*	name;
+		int		attr;
+	} table[] = {
+		{ "bright", GRID_ATTR_BRIGHT },
+		{ "bold", GRID_ATTR_BRIGHT },
+		{ "dim", GRID_ATTR_DIM },
+		{ "underscore", GRID_ATTR_UNDERSCORE },
+		{ "blink", GRID_ATTR_BLINK },
+		{ "reverse", GRID_ATTR_REVERSE },
+		{ "hidden", GRID_ATTR_HIDDEN },
+		{ "italics", GRID_ATTR_ITALICS },
+		{ "strikethrough", GRID_ATTR_STRIKETHROUGH },
+		{ "double-underscore", GRID_ATTR_UNDERSCORE_2 },
+		{ "curly-underscore", GRID_ATTR_UNDERSCORE_3 },
+		{ "dotted-underscore", GRID_ATTR_UNDERSCORE_4 },
+		{ "dashed-underscore", GRID_ATTR_UNDERSCORE_5 }
+	};
 
 	if (*str == '\0' || strcspn(str, delimiters) == 0)
 		return (-1);
@@ -64,24 +87,15 @@ attributes_fromstring(const char *str)
 	attr = 0;
 	do {
 		end = strcspn(str, delimiters);
-		if ((end == 6 && strncasecmp(str, "bright", end) == 0) ||
-		    (end == 4 && strncasecmp(str, "bold", end) == 0))
-			attr |= GRID_ATTR_BRIGHT;
-		else if (end == 3 && strncasecmp(str, "dim", end) == 0)
-			attr |= GRID_ATTR_DIM;
-		else if (end == 10 && strncasecmp(str, "underscore", end) == 0)
-			attr |= GRID_ATTR_UNDERSCORE;
-		else if (end == 5 && strncasecmp(str, "blink", end) == 0)
-			attr |= GRID_ATTR_BLINK;
-		else if (end == 7 && strncasecmp(str, "reverse", end) == 0)
-			attr |= GRID_ATTR_REVERSE;
-		else if (end == 6 && strncasecmp(str, "hidden", end) == 0)
-			attr |= GRID_ATTR_HIDDEN;
-		else if (end == 7 && strncasecmp(str, "italics", end) == 0)
-			attr |= GRID_ATTR_ITALICS;
-		else if (end == 13 && strncasecmp(str, "strikethrough", end) == 0)
-			attr |= GRID_ATTR_STRIKETHROUGH;
-		else
+		for (i = 0; i < nitems(table); i++) {
+			if (end != strlen(table[i].name))
+				continue;
+			if (strncasecmp(str, table[i].name, end) == 0) {
+				attr |= table[i].attr;
+				break;
+			}
+		}
+		if (i == nitems(table))
 			return (-1);
 		str += end + strspn(str + end, delimiters);
 	} while (*str != '\0');

cfg.c

@@ -26,6 +26,18 @@
 
 #include "tmux.h"
 
+/* Condition for %if, %elif, %else and %endif. */
+struct cfg_cond {
+	size_t			line;		/* line number of %if */
+	int			met;		/* condition was met */
+	int			skip;		/* skip later %elif/%else */
+	int			saw_else;	/* saw a %else */
+
+	TAILQ_ENTRY(cfg_cond)	entry;
+};
+TAILQ_HEAD(cfg_conds, cfg_cond);
+
+struct client		 *cfg_client;
 static char		 *cfg_file;
 int			  cfg_finished;
 static char		**cfg_causes;
@@ -83,7 +95,7 @@ start_cfg(void)
 	 * command queue is currently empty and our callback will be at the
 	 * front - we need to get in before MSG_COMMAND.
 	 */
-	c = TAILQ_FIRST(&clients);
+	cfg_client = c = TAILQ_FIRST(&clients);
 	if (c != NULL) {
 		cfg_item = cmdq_get_callback(cfg_client_done, NULL);
 		cmdq_append(c, cfg_item);
@@ -101,6 +113,124 @@ start_cfg(void)
 	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }
 
+static int
+cfg_check_condition(const char *path, size_t line, const char *p, int *skip)
+{
+	struct format_tree	*ft;
+	char			*s;
+	int			 result;
+
+	while (isspace((u_char)*p))
+		p++;
+	if (p[0] == '\0') {
+		cfg_add_cause("%s:%zu: invalid condition", path, line);
+		*skip = 1;
+		return (0);
+	}
+
+	ft = format_create(NULL, NULL, FORMAT_NONE, FORMAT_NOJOBS);
+	s = format_expand(ft, p);
+	result = format_true(s);
+	free(s);
+	format_free(ft);
+
+	*skip = result;
+	return (result);
+}
+
+static void
+cfg_handle_if(const char *path, size_t line, struct cfg_conds *conds,
+    const char *p)
+{
+	struct cfg_cond	*cond;
+	struct cfg_cond	*parent = TAILQ_FIRST(conds);
+
+	/*
+	 * Add a new condition. If a previous condition exists and isn't
+	 * currently met, this new one also can't be met.
+	 */
+	cond = xcalloc(1, sizeof *cond);
+	cond->line = line;
+	if (parent == NULL || parent->met)
+		cond->met = cfg_check_condition(path, line, p, &cond->skip);
+	else
+		cond->skip = 1;
+	cond->saw_else = 0;
+	TAILQ_INSERT_HEAD(conds, cond, entry);
+}
+
+static void
+cfg_handle_elif(const char *path, size_t line, struct cfg_conds *conds,
+    const char *p)
+{
+	struct cfg_cond	*cond = TAILQ_FIRST(conds);
+
+	/*
+	 * If a previous condition exists and wasn't met, check this
+	 * one instead and change the state.
+	 */
+	if (cond == NULL || cond->saw_else)
+		cfg_add_cause("%s:%zu: unexpected %%elif", path, line);
+	else if (!cond->skip)
+		cond->met = cfg_check_condition(path, line, p, &cond->skip);
+	else
+		cond->met = 0;
+}
+
+static void
+cfg_handle_else(const char *path, size_t line, struct cfg_conds *conds)
+{
+	struct cfg_cond	*cond = TAILQ_FIRST(conds);
+
+	/*
+	 * If a previous condition exists and wasn't met and wasn't already
+	 * %else, use this one instead.
+	 */
+	if (cond == NULL || cond->saw_else) {
+		cfg_add_cause("%s:%zu: unexpected %%else", path, line);
+		return;
+	}
+	cond->saw_else = 1;
+	cond->met = !cond->skip;
+	cond->skip = 1;
+}
+
+static void
+cfg_handle_endif(const char *path, size_t line, struct cfg_conds *conds)
+{
+	struct cfg_cond	*cond = TAILQ_FIRST(conds);
+
+	/*
+	 * Remove previous condition if one exists.
+	 */
+	if (cond == NULL) {
+		cfg_add_cause("%s:%zu: unexpected %%endif", path, line);
+		return;
+	}
+	TAILQ_REMOVE(conds, cond, entry);
+	free(cond);
+}
+
+static void
+cfg_handle_directive(const char *p, const char *path, size_t line,
+    struct cfg_conds *conds)
+{
+	int	n = 0;
+
+	while (p[n] != '\0' && !isspace((u_char)p[n]))
+		n++;
+	if (strncmp(p, "%if", n) == 0)
+		cfg_handle_if(path, line, conds, p + n);
+	else if (strncmp(p, "%elif", n) == 0)
+		cfg_handle_elif(path, line, conds, p + n);
+	else if (strcmp(p, "%else") == 0)
+		cfg_handle_else(path, line, conds);
+	else if (strcmp(p, "%endif") == 0)
+		cfg_handle_endif(path, line, conds);
+	else
+		cfg_add_cause("%s:%zu: invalid directive: %s", path, line, p);
+}
+
 int
 load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
 {
@@ -108,11 +238,13 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
 	const char		 delim[3] = { '\\', '\\', '\0' };
 	u_int			 found = 0;
 	size_t			 line = 0;
-	char			*buf, *cause1, *p, *q, *s;
+	char			*buf, *cause1, *p, *q;
 	struct cmd_list		*cmdlist;
 	struct cmdq_item	*new_item;
-	int			 condition = 0;
-	struct format_tree	*ft;
+	struct cfg_cond		*cond, *cond1;
+	struct cfg_conds	 conds;
+
+	TAILQ_INIT(&conds);
 
 	log_debug("loading %s", path);
 	if ((f = fopen(path, "rb")) == NULL) {
@@ -136,33 +268,12 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
 		while (q != p && isspace((u_char)*q))
 			*q-- = '\0';
 
-		if (condition != 0 && strcmp(p, "%endif") == 0) {
-			condition = 0;
+		if (*p == '%') {
+			cfg_handle_directive(p, path, line, &conds);
 			continue;
 		}
-		if (strncmp(p, "%if ", 4) == 0) {
-			if (condition != 0) {
-				cfg_add_cause("%s:%zu: nested %%if", path,
-				    line);
-				continue;
-			}
-			ft = format_create(NULL, NULL, FORMAT_NONE,
-			    FORMAT_NOJOBS);
-
-			s = p + 3;
-			while (isspace((u_char)*s))
-				s++;
-			s = format_expand(ft, s);
-			if (*s != '\0' && (s[0] != '0' || s[1] != '\0'))
-				condition = 1;
-			else
-				condition = -1;
-			free(s);
-
-			format_free(ft);
-			continue;
-		}
-		if (condition == -1)
+		cond = TAILQ_FIRST(&conds);
+		if (cond != NULL && !cond->met)
 			continue;
 
 		cmdlist = cmd_string_parse(p, path, line, &cause1);
@@ -176,8 +287,6 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
 		}
 		free(buf);
 
-		if (cmdlist == NULL)
-			continue;
 		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
 		if (item != NULL)
 			cmdq_insert_after(item, new_item);
@@ -189,6 +298,12 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
 	}
 	fclose(f);
 
+	TAILQ_FOREACH_REVERSE_SAFE(cond, &conds, cfg_conds, entry, cond1) {
+		cfg_add_cause("%s:%zu: unterminated %%if", path, cond->line);
+		TAILQ_REMOVE(&conds, cond, entry);
+		free(cond);
+	}
+
 	return (found);
 }
 
@@ -225,15 +340,17 @@ cfg_print_causes(struct cmdq_item *item)
 void
 cfg_show_causes(struct session *s)
 {
-	struct window_pane	*wp;
-	u_int			 i;
+	struct window_pane		*wp;
+	struct window_mode_entry	*wme;
+	u_int				 i;
 
 	if (s == NULL || cfg_ncauses == 0)
 		return;
 	wp = s->curw->window->active;
 
-	window_pane_set_mode(wp, &window_copy_mode, NULL, NULL);
-	window_copy_init_for_output(wp);
+	wme = TAILQ_FIRST(&wp->modes);
+	if (wme == NULL || wme->mode != &window_view_mode)
+		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
 	for (i = 0; i < cfg_ncauses; i++) {
 		window_copy_add(wp, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);

client.c

@@ -17,11 +17,10 @@
  */
 
 #include <sys/types.h>
-#include <sys/file.h>
 #include <sys/socket.h>
-#include <sys/stat.h>
 #include <sys/un.h>
 #include <sys/wait.h>
+#include <sys/file.h>
 
 #include <errno.h>
 #include <event.h>
@@ -223,7 +222,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 	const char		*ttynam, *cwd;
 	pid_t			 ppid;
 	enum msgtype		 msg;
-	char			*cause, path[PATH_MAX];
+	char			*cause;
 	struct termios		 tio, saved_tio;
 	size_t			 size;
 
@@ -278,10 +277,8 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 	client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);
 
 	/* Save these before pledge(). */
-	if ((cwd = getcwd(path, sizeof path)) == NULL) {
-		if ((cwd = find_home()) == NULL)
-			cwd = "/";
-	}
+	if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
+		cwd = "/";
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";
 
@@ -338,6 +335,10 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		size = 0;
 		for (i = 0; i < argc; i++)
 			size += strlen(argv[i]) + 1;
+		if (size > MAX_IMSGSIZE - (sizeof *data)) {
+			fprintf(stderr, "command too long\n");
+			return (1);
+		}
 		data = xmalloc((sizeof *data) + size);
 
 		/* Prepare command for server. */
@@ -449,6 +450,7 @@ client_write(int fd, const char *data, size_t size)
 {
 	ssize_t	used;
 
+	log_debug("%s: %.*s", __func__, (int)size, data);
 	while (size != 0) {
 		used = write(fd, data, size);
 		if (used == -1) {

cmd-attach-session.c

@@ -100,6 +100,7 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 		s->cwd = format_single(item, cflag, c, s, wl, wp);
 	}
 
+	c->last_session = c->session;
 	if (c->session != NULL) {
 		if (dflag) {
 			TAILQ_FOREACH(c_loop, &clients, entry) {
@@ -114,6 +115,7 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 		c->session = s;
 		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
 			server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
 		status_timer_start(c);
 		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);
@@ -141,6 +143,7 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 
 		c->session = s;
 		server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
 		status_timer_start(c);
 		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);

cmd-break-pane.c

@@ -76,7 +76,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 	window_lost_pane(w, wp);
 	layout_close_pane(wp);
 
-	w = wp->window = window_create(dst_s->sx, dst_s->sy);
+	w = wp->window = window_create(w->sx, w->sy);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
 

cmd-capture-pane.c

@@ -41,7 +41,7 @@ const struct cmd_entry cmd_capture_pane_entry = {
 
 	.args = { "ab:CeE:JpPqS:t:", 0, 0 },
 	.usage = "[-aCeJpPq] " CMD_BUFFER_USAGE " [-E end-line] "
-		 "[-S start-line]" CMD_TARGET_PANE_USAGE,
+		 "[-S start-line] " CMD_TARGET_PANE_USAGE,
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -199,8 +199,7 @@ cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 	size_t			 len;
 
 	if (self->entry == &cmd_clear_history_entry) {
-		if (wp->mode == &window_copy_mode)
-			window_pane_reset_mode(wp);
+		window_pane_reset_mode_all(wp);
 		grid_clear_history(wp->base.grid);
 		return (CMD_RETURN_NORMAL);
 	}

cmd-choose-tree.c

@@ -30,9 +30,9 @@ const struct cmd_entry cmd_choose_tree_entry = {
 	.name = "choose-tree",
 	.alias = NULL,
 
-	.args = { "F:f:NO:st:w", 0, 1 },
-	.usage = "[-Nsw] [-F format] [-f filter] [-O sort-order] "
-	         CMD_TARGET_PANE_USAGE,
+	.args = { "F:Gf:NO:st:wZ", 0, 1 },
+	.usage = "[-GNsw] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE " [template]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -44,9 +44,9 @@ const struct cmd_entry cmd_choose_client_entry = {
 	.name = "choose-client",
 	.alias = NULL,
 
-	.args = { "F:f:NO:t:", 0, 1 },
+	.args = { "F:f:NO:t:Z", 0, 1 },
 	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
-	         CMD_TARGET_PANE_USAGE,
+	         CMD_TARGET_PANE_USAGE " [template]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -58,9 +58,9 @@ const struct cmd_entry cmd_choose_buffer_entry = {
 	.name = "choose-buffer",
 	.alias = NULL,
 
-	.args = { "F:f:NO:t:", 0, 1 },
+	.args = { "F:f:NO:t:Z", 0, 1 },
 	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
-	         CMD_TARGET_PANE_USAGE,
+	         CMD_TARGET_PANE_USAGE " [template]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 

cmd-copy-mode.c

@@ -60,7 +60,6 @@ cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 	struct client		*c = item->client;
 	struct session		*s;
 	struct window_pane	*wp = item->target.wp;
-	int			 flag;
 
 	if (args_has(args, 'M')) {
 		if ((wp = cmd_mouse_pane(&shared->mouse, &s, NULL)) == NULL)
@@ -74,18 +73,11 @@ cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (wp->mode != &window_copy_mode) {
-		flag = window_pane_set_mode(wp, &window_copy_mode, NULL, NULL);
-		if (flag != 0)
-			return (CMD_RETURN_NORMAL);
-		window_copy_init_from_pane(wp, args_has(self->args, 'e'));
-	}
-	if (args_has(args, 'M')) {
-		if (wp->mode != NULL && wp->mode != &window_copy_mode)
-			return (CMD_RETURN_NORMAL);
+	if (window_pane_set_mode(wp, &window_copy_mode, NULL, args) != 0)
+		return (CMD_RETURN_NORMAL);
+	if (args_has(args, 'M'))
 		window_copy_start_drag(c, &shared->mouse);
-	}
-	if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
+	if (args_has(self->args, 'u'))
 		window_copy_pageup(wp, 0);
 
 	return (CMD_RETURN_NORMAL);

cmd-display-message.c

@@ -39,8 +39,8 @@ const struct cmd_entry cmd_display_message_entry = {
 	.name = "display-message",
 	.alias = "display",
 
-	.args = { "c:pt:F:", 0, 1 },
-	.usage = "[-p] [-c target-client] [-F format] "
+	.args = { "ac:pt:F:v", 0, 1 },
+	.usage = "[-apv] [-c target-client] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -49,23 +49,31 @@ const struct cmd_entry cmd_display_message_entry = {
 	.exec = cmd_display_message_exec
 };
 
+static void
+cmd_display_message_each(const char *key, const char *value, void *arg)
+{
+	struct cmdq_item	*item = arg;
+
+	cmdq_print(item, "%s=%s", key, value);
+}
+
 static enum cmd_retval
 cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c;
+	struct client		*c, *target_c;
 	struct session		*s = item->target.s;
 	struct winlink		*wl = item->target.wl;
 	struct window_pane	*wp = item->target.wp;
 	const char		*template;
 	char			*msg;
 	struct format_tree	*ft;
+	int			 flags;
 
 	if (args_has(args, 'F') && args->argc != 0) {
 		cmdq_error(item, "only one of -F or argument must be given");
 		return (CMD_RETURN_ERROR);
 	}
-	c = cmd_find_client(item, args_get(args, 'c'), 1);
 
 	template = args_get(args, 'F');
 	if (args->argc != 0)
@@ -73,10 +81,31 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 	if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;
 
-	ft = format_create(item->client, item, FORMAT_NONE, 0);
-	format_defaults(ft, c, s, wl, wp);
+	/*
+	 * -c is intended to be the client where the message should be
+	 * displayed if -p is not given. But it makes sense to use it for the
+	 * formats too, assuming it matches the session. If it doesn't, use the
+	 * best client for the session.
+	 */
+	c = cmd_find_client(item, args_get(args, 'c'), 1);
+	if (c != NULL && c->session == s)
+		target_c = c;
+	else
+		target_c = cmd_find_best_client(s);
+	if (args_has(self->args, 'v'))
+		flags = FORMAT_VERBOSE;
+	else
+		flags = 0;
+	ft = format_create(item->client, item, FORMAT_NONE, flags);
+	format_defaults(ft, target_c, s, wl, wp);
 
-	msg = format_expand_time(ft, template, time(NULL));
+	if (args_has(args, 'a')) {
+		if (item != NULL)
+			format_each(ft, cmd_display_message_each, item);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	msg = format_expand_time(ft, template);
 	if (args_has(self->args, 'p'))
 		cmdq_print(item, "%s", msg);
 	else if (c != NULL)

cmd-display-panes.c

@@ -37,8 +37,8 @@ const struct cmd_entry cmd_display_panes_entry = {
 	.name = "display-panes",
 	.alias = "displayp",
 
-	.args = { "d:t:", 0, 1 },
-	.usage = "[-d duration] " CMD_TARGET_CLIENT_USAGE,
+	.args = { "bd:t:", 0, 1 },
+	.usage = "[-b] [-d duration] " CMD_TARGET_CLIENT_USAGE " [template]",
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_display_panes_exec
@@ -55,6 +55,7 @@ cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 
 	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
+	s = c->session;
 
 	if (c->identify_callback != NULL)
 		return (CMD_RETURN_NORMAL);
@@ -64,7 +65,10 @@ cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 		c->identify_callback_data = xstrdup(args->argv[0]);
 	else
 		c->identify_callback_data = xstrdup("select-pane -t '%%'");
-	s = c->session;
+	if (args_has(args, 'b'))
+		c->identify_callback_item = NULL;
+	else
+		c->identify_callback_item = item;
 
 	if (args_has(args, 'd')) {
 		delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause);
@@ -77,7 +81,9 @@ cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 		delay = options_get_number(s->options, "display-panes-time");
 	server_client_set_identify(c, delay);
 
-	return (CMD_RETURN_NORMAL);
+	if (args_has(args, 'b'))
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
 }
 
 static enum cmd_retval
@@ -96,34 +102,42 @@ cmd_display_panes_callback(struct client *c, struct window_pane *wp)
 {
 	struct cmd_list		*cmdlist;
 	struct cmdq_item	*new_item;
-	char			*template, *cmd, *expanded, *cause;
+	char			*cmd, *expanded, *cause;
 
-	template = c->identify_callback_data;
 	if (wp == NULL)
 		goto out;
+
 	xasprintf(&expanded, "%%%u", wp->id);
-	cmd = cmd_template_replace(template, expanded, 1);
+	cmd = cmd_template_replace(c->identify_callback_data, expanded, 1);
 
 	cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
-	if (cmdlist == NULL) {
-		if (cause != NULL) {
-			new_item = cmdq_get_callback(cmd_display_panes_error,
-			    cause);
-		} else
-			new_item = NULL;
-	} else {
+	if (cmdlist == NULL && cause != NULL)
+		new_item = cmdq_get_callback(cmd_display_panes_error, cause);
+	else if (cmdlist == NULL)
+		new_item = NULL;
+	else {
 		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
 		cmd_list_free(cmdlist);
 	}
 
-	if (new_item != NULL)
-		cmdq_append(c, new_item);
+	if (new_item != NULL) {
+		if (c->identify_callback_item != NULL)
+			cmdq_insert_after(c->identify_callback_item, new_item);
+		else
+			cmdq_append(c, new_item);
+	}
 
 	free(cmd);
 	free(expanded);
 
 out:
+	if (c->identify_callback_item != NULL) {
+		c->identify_callback_item->flags &= ~CMDQ_WAITING;
+		c->identify_callback_item = NULL;
+	}
+
 	free(c->identify_callback_data);
 	c->identify_callback_data = NULL;
+
 	c->identify_callback = NULL;
 }

cmd-find-window.c

@@ -32,8 +32,8 @@ const struct cmd_entry cmd_find_window_entry = {
 	.name = "find-window",
 	.alias = "findw",
 
-	.args = { "CNt:T", 1, 1 },
-	.usage = "[-CNT] " CMD_TARGET_PANE_USAGE " match-string",
+	.args = { "CNt:TZ", 1, 1 },
+	.usage = "[-CNTZ] " CMD_TARGET_PANE_USAGE " match-string",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -83,6 +83,8 @@ cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 		xasprintf(&filter, "#{m:*%s*,#{pane_title}}", s);
 
 	new_args = args_parse("", 1, &argv);
+	if (args_has(args, 'Z'))
+		args_set(new_args, 'Z', NULL);
 	args_set(new_args, 'f', filter);
 
 	window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);

cmd-find.c

@@ -34,6 +34,7 @@ static int	cmd_find_best_winlink_with_window(struct cmd_find_state *);
 
 static const char *cmd_find_map_table(const char *[][2], const char *);
 
+static void	cmd_find_log_state(const char *, struct cmd_find_state *);
 static int	cmd_find_get_session(struct cmd_find_state *, const char *);
 static int	cmd_find_get_window(struct cmd_find_state *, const char *, int);
 static int	cmd_find_get_window_with_session(struct cmd_find_state *,
@@ -82,6 +83,7 @@ cmd_find_try_TMUX(struct client *c)
 	char			 tmp[256];
 	long long		 pid;
 	u_int			 session;
+	struct session		*s;
 
 	envent = environ_find(c->environ, "TMUX");
 	if (envent == NULL)
@@ -91,8 +93,13 @@ cmd_find_try_TMUX(struct client *c)
 		return (NULL);
 	if (pid != getpid())
 		return (NULL);
-	log_debug("client %p TMUX %s (session @%u)", c, envent->value, session);
-	return (session_find_by_id(session));
+	log_debug("%s: client %p TMUX %s (session $%u)", __func__, c,
+	    envent->value, session);
+
+	s = session_find_by_id(session);
+	if (s != NULL)
+		log_debug("%s: session $%u still exists", __func__, s->id);
+	return (s);
 }
 
 /* Find pane containing client if any. */
@@ -105,9 +112,11 @@ cmd_find_inside_pane(struct client *c)
 		return (NULL);
 
 	RB_FOREACH(wp, window_pane_tree, &all_window_panes) {
-		if (strcmp(wp->tty, c->ttyname) == 0)
+		if (wp->fd != -1 && strcmp(wp->tty, c->ttyname) == 0)
 			break;
 	}
+	if (wp != NULL)
+		log_debug("%s: got pane %%%u (%s)", __func__, wp->id, wp->tty);
 	return (wp);
 }
 
@@ -121,12 +130,12 @@ cmd_find_client_better(struct client *c, struct client *than)
 }
 
 /* Find best client for session. */
-static struct client *
+struct client *
 cmd_find_best_client(struct session *s)
 {
 	struct client	*c_loop, *c;
 
-	if (s->flags & SESSION_UNATTACHED)
+	if (s->attached == 0)
 		s = NULL;
 
 	c = NULL;
@@ -150,10 +159,10 @@ cmd_find_session_better(struct session *s, struct session *than, int flags)
 	if (than == NULL)
 		return (1);
 	if (flags & CMD_FIND_PREFER_UNATTACHED) {
-		attached = (~than->flags & SESSION_UNATTACHED);
-		if (attached && (s->flags & SESSION_UNATTACHED))
+		attached = (than->attached != 0);
+		if (attached && s->attached == 0)
 			return (1);
-		else if (!attached && (~s->flags & SESSION_UNATTACHED))
+		else if (!attached && s->attached != 0)
 			return (0);
 	}
 	return (timercmp(&s->activity_time, &than->activity_time, >));
@@ -166,6 +175,8 @@ cmd_find_best_session(struct session **slist, u_int ssize, int flags)
 	struct session	 *s_loop, *s;
 	u_int		  i;
 
+	log_debug("%s: %u sessions to try", __func__, ssize);
+
 	s = NULL;
 	if (slist != NULL) {
 		for (i = 0; i < ssize; i++) {
@@ -189,6 +200,8 @@ cmd_find_best_session_with_window(struct cmd_find_state *fs)
 	u_int		  ssize;
 	struct session	 *s;
 
+	log_debug("%s: window is @%u", __func__, fs->w->id);
+
 	ssize = 0;
 	RB_FOREACH(s, sessions, &sessions) {
 		if (!session_has(s, fs->w))
@@ -210,7 +223,7 @@ fail:
 }
 
 /*
- * Find the best winlink for a window (the current if it contains the pane,
+ * Find the best winlink for a window (the current if it contains the window,
  * otherwise the first).
  */
 static int
@@ -218,6 +231,8 @@ cmd_find_best_winlink_with_window(struct cmd_find_state *fs)
 {
 	struct winlink	 *wl, *wl_loop;
 
+	log_debug("%s: window is @%u", __func__, fs->w->id);
+
 	wl = NULL;
 	if (fs->s->curw != NULL && fs->s->curw->window == fs->w)
 		wl = fs->s->curw;
@@ -389,7 +404,7 @@ cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)
 					return (-1);
 				fs->idx = s->curw->idx + n;
 			} else {
-				if (n < s->curw->idx)
+				if (n > s->curw->idx)
 					return (-1);
 				fs->idx = s->curw->idx - n;
 			}
@@ -436,15 +451,16 @@ cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)
 	if (window[0] != '+' && window[0] != '-') {
 		idx = strtonum(window, 0, INT_MAX, &errstr);
 		if (errstr == NULL) {
-			if (fs->flags & CMD_FIND_WINDOW_INDEX) {
-				fs->idx = idx;
-				return (0);
-			}
 			fs->wl = winlink_find_by_index(&fs->s->windows, idx);
 			if (fs->wl != NULL) {
+				fs->idx = fs->wl->idx;
 				fs->w = fs->wl->window;
 				return (0);
 			}
+			if (fs->flags & CMD_FIND_WINDOW_INDEX) {
+				fs->idx = idx;
+				return (0);
+			}
 		}
 	}
 
@@ -587,8 +603,6 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 
 	/* Try special characters. */
 	if (strcmp(pane, "!") == 0) {
-		if (fs->w->last == NULL)
-			return (-1);
 		fs->wp = fs->w->last;
 		if (fs->wp == NULL)
 			return (-1);
@@ -703,11 +717,11 @@ cmd_find_copy_state(struct cmd_find_state *dst, struct cmd_find_state *src)
 }
 
 /* Log the result. */
-void
+static void
 cmd_find_log_state(const char *prefix, struct cmd_find_state *fs)
 {
 	if (fs->s != NULL)
-		log_debug("%s: s=$%u", prefix, fs->s->id);
+		log_debug("%s: s=$%u %s", prefix, fs->s->id, fs->s->name);
 	else
 		log_debug("%s: s=none", prefix);
 	if (fs->wl != NULL) {
@@ -896,6 +910,9 @@ cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)
 				break;
 		}
 		if (wl != NULL) {
+			log_debug("%s: session $%u has pane %%%u", __func__,
+			    s->id, wp->id);
+
 			fs->s = s;
 			fs->wl = s->curw; /* use current session */
 			fs->w = fs->wl->window;
@@ -903,6 +920,9 @@ cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)
 
 			cmd_find_log_state(__func__, fs);
 			return (0);
+		} else {
+			log_debug("%s: session $%u does not have pane %%%u",
+			    __func__, s->id, wp->id);
 		}
 	}
 
@@ -912,16 +932,12 @@ cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)
 	 */
 	fs->w = wp->window;
 	if (cmd_find_best_session_with_window(fs) != 0) {
-		if (wp != NULL) {
-			/*
-			 * The window may have been destroyed but the pane
-			 * still on all_window_panes due to something else
-			 * holding a reference.
-			 */
-			goto unknown_pane;
-		}
-		cmd_find_clear_state(fs, 0);
-		return (-1);
+		/*
+		 * The window may have been destroyed but the pane
+		 * still on all_window_panes due to something else
+		 * holding a reference.
+		 */
+		goto unknown_pane;
 	}
 	fs->wl = fs->s->curw;
 	fs->w = fs->wl->window;
@@ -955,7 +971,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 {
 	struct mouse_event	*m;
 	struct cmd_find_state	 current;
-	char			*colon, *period, *copy = NULL;
+	char			*colon, *period, *copy = NULL, tmp[256];
 	const char		*session, *window, *pane, *s;
 	int			 window_only = 0, pane_only = 0;
 
@@ -972,11 +988,25 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 		s = "session";
 	else
 		s = "unknown";
-	if (target == NULL)
-		log_debug("%s: target none, type %s", __func__, s);
-	else
-		log_debug("%s: target %s, type %s", __func__, target, s);
-	log_debug("%s: item %p, flags %#x", __func__, item, flags);
+	*tmp = '\0';
+	if (flags & CMD_FIND_PREFER_UNATTACHED)
+		strlcat(tmp, "PREFER_UNATTACHED,", sizeof tmp);
+	if (flags & CMD_FIND_QUIET)
+		strlcat(tmp, "QUIET,", sizeof tmp);
+	if (flags & CMD_FIND_WINDOW_INDEX)
+		strlcat(tmp, "WINDOW_INDEX,", sizeof tmp);
+	if (flags & CMD_FIND_DEFAULT_MARKED)
+		strlcat(tmp, "DEFAULT_MARKED,", sizeof tmp);
+	if (flags & CMD_FIND_EXACT_SESSION)
+		strlcat(tmp, "EXACT_SESSION,", sizeof tmp);
+	if (flags & CMD_FIND_EXACT_WINDOW)
+		strlcat(tmp, "EXACT_WINDOW,", sizeof tmp);
+	if (flags & CMD_FIND_CANFAIL)
+		strlcat(tmp, "CANFAIL,", sizeof tmp);
+	if (*tmp != '\0')
+		tmp[strlen(tmp) - 1] = '\0';
+	log_debug("%s: target %s, type %s, item %p, flags %s", __func__,
+	    target == NULL ? "none" : target, s, item, tmp);
 
 	/* Clear new state. */
 	cmd_find_clear_state(fs, flags);
@@ -1116,9 +1146,16 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 	if (pane != NULL)
 		pane = cmd_find_map_table(cmd_find_pane_table, pane);
 
-	log_debug("%s: target %s (flags %#x): session=%s, window=%s, pane=%s",
-	    __func__, target, flags, session == NULL ? "none" : session,
-	    window == NULL ? "none" : window, pane == NULL ? "none" : pane);
+	if (session != NULL || window != NULL || pane != NULL) {
+		log_debug("%s: target %s is %s%s%s%s%s%s",
+		    __func__, target,
+		    session == NULL ? "" : "session ",
+		    session == NULL ? "" : session,
+		    window == NULL ? "" : "window ",
+		    window == NULL ? "" : window,
+		    pane == NULL ? "" : "pane ",
+		    pane == NULL ? "" : pane);
+	}
 
 	/* No pane is allowed if want an index. */
 	if (pane != NULL && (flags & CMD_FIND_WINDOW_INDEX)) {
@@ -1147,7 +1184,8 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 			/* This will fill in winlink and window. */
 			if (cmd_find_get_window_with_session(fs, window) != 0)
 				goto no_window;
-			fs->wp = fs->wl->window->active;
+			if (fs->wl != NULL) /* can be NULL if index only */
+				fs->wp = fs->wl->window->active;
 			goto found;
 		}
 
@@ -1187,7 +1225,8 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 		/* This will fill in session, winlink and window. */
 		if (cmd_find_get_window(fs, window, window_only) != 0)
 			goto no_window;
-		fs->wp = fs->wl->window->active;
+		if (fs->wl != NULL) /* can be NULL if index only */
+			fs->wp = fs->wl->window->active;
 		goto found;
 	}
 
@@ -1224,17 +1263,17 @@ found:
 
 no_session:
 	if (~flags & CMD_FIND_QUIET)
-		cmdq_error(item, "can't find session %s", session);
+		cmdq_error(item, "can't find session: %s", session);
 	goto error;
 
 no_window:
 	if (~flags & CMD_FIND_QUIET)
-		cmdq_error(item, "can't find window %s", window);
+		cmdq_error(item, "can't find window: %s", window);
 	goto error;
 
 no_pane:
 	if (~flags & CMD_FIND_QUIET)
-		cmdq_error(item, "can't find pane %s", pane);
+		cmdq_error(item, "can't find pane: %s", pane);
 	goto error;
 }
 
@@ -1304,7 +1343,7 @@ cmd_find_client(struct cmdq_item *item, const char *target, int quiet)
 
 	/* If no client found, report an error. */
 	if (c == NULL && !quiet)
-		cmdq_error(item, "can't find client %s", copy);
+		cmdq_error(item, "can't find client: %s", copy);
 
 	free(copy);
 	log_debug("%s: target %s, return %p", __func__, target, c);

cmd-if-shell.c

@@ -73,14 +73,6 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 	struct session			*s = item->target.s;
 	struct winlink			*wl = item->target.wl;
 	struct window_pane		*wp = item->target.wp;
-	const char			*cwd;
-
-	if (item->client != NULL && item->client->session == NULL)
-		cwd = item->client->cwd;
-	else if (s != NULL)
-		cwd = s->cwd;
-	else
-		cwd = NULL;
 
 	shellcmd = format_single(item, args->argv[0], c, s, wl, wp);
 	if (args_has(args, 'F')) {
@@ -128,8 +120,13 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 		cdata->item = NULL;
 	memcpy(&cdata->mouse, &shared->mouse, sizeof cdata->mouse);
 
-	job_run(shellcmd, s, cwd, NULL, cmd_if_shell_callback,
-	    cmd_if_shell_free, cdata);
+	if (job_run(shellcmd, s, server_client_get_cwd(item->client, s), NULL,
+	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0) == NULL) {
+		cmdq_error(item, "failed to run command: %s", shellcmd);
+		free(shellcmd);
+		free(cdata);
+		return (CMD_RETURN_ERROR);
+	}
 	free(shellcmd);
 
 	if (args_has(args, 'b'))
@@ -140,14 +137,16 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 static void
 cmd_if_shell_callback(struct job *job)
 {
-	struct cmd_if_shell_data	*cdata = job->data;
+	struct cmd_if_shell_data	*cdata = job_get_data(job);
 	struct client			*c = cdata->client;
 	struct cmd_list			*cmdlist;
 	struct cmdq_item		*new_item;
 	char				*cause, *cmd, *file = cdata->file;
 	u_int				 line = cdata->line;
+	int				 status;
 
-	if (!WIFEXITED(job->status) || WEXITSTATUS(job->status) != 0)
+	status = job_get_status(job);
+	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
 		cmd = cdata->cmd_else;
 	else
 		cmd = cdata->cmd_if;

cmd-kill-pane.c

@@ -47,9 +47,8 @@ cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 	struct winlink		*wl = item->target.wl;
 	struct window_pane	*loopwp, *tmpwp, *wp = item->target.wp;
 
-	server_unzoom_window(wl->window);
-
 	if (args_has(self->args, 'a')) {
+		server_unzoom_window(wl->window);
 		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
 			if (loopwp == wp)
 				continue;
@@ -60,13 +59,6 @@ cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (window_count_panes(wl->window) == 1) {
-		server_kill_window(wl->window);
-		recalculate_sizes();
-	} else {
-		layout_close_pane(wp);
-		window_remove_pane(wl->window, wp);
-		server_redraw_window(wl->window);
-	}
+	server_kill_pane(wp);
 	return (CMD_RETURN_NORMAL);
 }

cmd-list-keys.c

@@ -75,10 +75,14 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 
 	repeat = 0;
 	tablewidth = keywidth = 0;
-	RB_FOREACH(table, key_tables, &key_tables) {
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
+	table = key_bindings_first_table ();
+	while (table != NULL) {
+		if (tablename != NULL && strcmp(table->name, tablename) != 0) {
+			table = key_bindings_next_table(table);
 			continue;
-		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
+		}
+		bd = key_bindings_first(table);
+		while (bd != NULL) {
 			key = key_string_lookup_key(bd->key);
 
 			if (bd->flags & KEY_BINDING_REPEAT)
@@ -90,13 +94,20 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 			width = utf8_cstrwidth(key);
 			if (width > keywidth)
 				keywidth = width;
+
+			bd = key_bindings_next(table, bd);
 		}
+		table = key_bindings_next_table(table);
 	}
 
-	RB_FOREACH(table, key_tables, &key_tables) {
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
+	table = key_bindings_first_table ();
+	while (table != NULL) {
+		if (tablename != NULL && strcmp(table->name, tablename) != 0) {
+			table = key_bindings_next_table(table);
 			continue;
-		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
+		}
+		bd = key_bindings_first(table);
+		while (bd != NULL) {
 			key = key_string_lookup_key(bd->key);
 
 			if (!repeat)
@@ -122,7 +133,9 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 			free(cp);
 
 			cmdq_print(item, "bind-key %s", tmp);
+			bd = key_bindings_next(table, bd);
 		}
+		table = key_bindings_next_table(table);
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-list-sessions.c

@@ -30,8 +30,7 @@
 
 #define LIST_SESSIONS_TEMPLATE				\
 	"#{session_name}: #{session_windows} windows "	\
-	"(created #{t:session_created}) "		\
-	"[#{session_width}x#{session_height}]"		\
+	"(created #{t:session_created})"		\
 	"#{?session_grouped, (group ,}"			\
 	"#{session_group}#{?session_grouped,),}"	\
 	"#{?session_attached, (attached),}"

cmd-load-buffer.c

@@ -56,10 +56,14 @@ cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	struct cmd_load_buffer_data	*cdata;
-	struct client			*c = item->client;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = item->target.wp;
 	FILE				*f;
-	const char			*path, *bufname;
-	char				*pdata, *new_pdata, *cause, *file;
+	const char			*bufname;
+	char				*pdata = NULL, *new_pdata, *cause;
+	char				*path, *file;
 	size_t				 psize;
 	int				 ch, error;
 
@@ -67,8 +71,11 @@ cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(args, 'b'))
 		bufname = args_get(args, 'b');
 
-	path = args->argv[0];
+	path = format_single(item, args->argv[0], c, s, wl, wp);
 	if (strcmp(path, "-") == 0) {
+		free(path);
+		c = item->client;
+
 		cdata = xcalloc(1, sizeof *cdata);
 		cdata->item = item;
 
@@ -78,19 +85,21 @@ cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 		error = server_set_stdin_callback(c, cmd_load_buffer_callback,
 		    cdata, &cause);
 		if (error != 0) {
-			cmdq_error(item, "%s: %s", path, cause);
+			cmdq_error(item, "-: %s", cause);
 			free(cause);
+			free(cdata);
 			return (CMD_RETURN_ERROR);
 		}
 		return (CMD_RETURN_WAIT);
 	}
 
 	file = server_client_get_path(c, path);
+	free(path);
+
 	f = fopen(file, "rb");
 	if (f == NULL) {
 		cmdq_error(item, "%s: %s", file, strerror(errno));
-		free(file);
-		return (CMD_RETURN_ERROR);
+		goto error;
 	}
 
 	pdata = NULL;

cmd-new-session.c

@@ -71,16 +71,18 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	struct session		*s, *as, *groupwith;
 	struct window		*w;
 	struct environ		*env;
+	struct options		*oo;
 	struct termios		 tio, *tiop;
 	struct session_group	*sg;
-	const char		*newname, *errstr, *template, *group, *prefix;
-	const char		*path, *cmd, *cwd;
-	char		       **argv, *cause, *cp, *to_free = NULL;
+	const char		*errstr, *template, *group, *prefix;
+	const char		*path, *cmd, *tmp, *value;
+	char		       **argv, *cause, *cp, *newname, *cwd = NULL;
 	int			 detached, already_attached, idx, argc;
 	int			 is_control = 0;
-	u_int			 sx, sy;
+	u_int			 sx, sy, dsx = 80, dsy = 24;
 	struct environ_entry	*envent;
 	struct cmd_find_state	 fs;
+	enum cmd_retval		 retval;
 
 	if (self->entry == &cmd_has_session_entry) {
 		/*
@@ -95,20 +97,24 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);
 	}
 
-	newname = args_get(args, 's');
-	if (newname != NULL) {
+	newname = NULL;
+	if (args_has(args, 's')) {
+		newname = format_single(item, args_get(args, 's'), c, NULL,
+		    NULL, NULL);
 		if (!session_check_name(newname)) {
 			cmdq_error(item, "bad session name: %s", newname);
-			return (CMD_RETURN_ERROR);
+			goto error;
 		}
 		if ((as = session_find(newname)) != NULL) {
 			if (args_has(args, 'A')) {
-				return (cmd_attach_session(item,
+				retval = cmd_attach_session(item,
 				    newname, args_has(args, 'D'),
-				    0, NULL, args_has(args, 'E')));
+				    0, NULL, args_has(args, 'E'));
+				free(newname);
+				return (retval);
 			}
 			cmdq_error(item, "duplicate session: %s", newname);
-			return (CMD_RETURN_ERROR);
+			goto error;
 		}
 	}
 
@@ -149,14 +155,10 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		already_attached = 1;
 
 	/* Get the new session working directory. */
-	if (args_has(args, 'c')) {
-		cwd = args_get(args, 'c');
-		to_free = format_single(item, cwd, c, NULL, NULL, NULL);
-		cwd = to_free;
-	} else if (c != NULL && c->session == NULL && c->cwd != NULL)
-		cwd = c->cwd;
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, NULL, NULL, NULL);
 	else
-		cwd = ".";
+		cwd = xstrdup(server_client_get_cwd(c, NULL));
 
 	/*
 	 * If this is a new client, check for nesting and save the termios
@@ -188,31 +190,50 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		}
 	}
 
+	/* Get default session size. */
+	if (args_has(args, 'x')) {
+		tmp = args_get(args, 'x');
+		if (strcmp(tmp, "-") == 0) {
+			if (c != NULL)
+				dsx = c->tty.sx;
+		} else {
+			dsx = strtonum(tmp, 1, USHRT_MAX, &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "width %s", errstr);
+				goto error;
+			}
+		}
+	}
+	if (args_has(args, 'y')) {
+		tmp = args_get(args, 'y');
+		if (strcmp(tmp, "-") == 0) {
+			if (c != NULL)
+				dsy = c->tty.sy;
+		} else {
+			dsy = strtonum(tmp, 1, USHRT_MAX, &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "height %s", errstr);
+				goto error;
+			}
+		}
+	}
+
 	/* Find new session size. */
-	if (!detached) {
+	if (!detached && !is_control) {
 		sx = c->tty.sx;
 		sy = c->tty.sy;
-		if (!is_control &&
-		    sy > 0 &&
-		    options_get_number(global_s_options, "status"))
+		if (sy > 0 && options_get_number(global_s_options, "status"))
 			sy--;
 	} else {
-		sx = 80;
-		sy = 24;
-	}
-	if ((is_control || detached) && args_has(args, 'x')) {
-		sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(item, "width %s", errstr);
-			goto error;
-		}
-	}
-	if ((is_control || detached) && args_has(args, 'y')) {
-		sy = strtonum(args_get(args, 'y'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(item, "height %s", errstr);
-			goto error;
+		value = options_get_string(global_s_options, "default-size");
+		if (sscanf(value, "%ux%u", &sx, &sy) != 2) {
+			sx = 80;
+			sy = 24;
 		}
+		if (args_has(args, 'x'))
+			sx = dsx;
+		if (args_has(args, 'y'))
+			sy = dsy;
 	}
 	if (sx == 0)
 		sx = 1;
@@ -249,10 +270,15 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	if (c != NULL && !args_has(args, 'E'))
 		environ_update(global_s_options, c->environ, env);
 
+	/* Set up the options. */
+	oo = options_create(global_s_options);
+	if (args_has(args, 'x') || args_has(args, 'y'))
+		options_set_string(oo, "default-size", 0, "%ux%u", dsx, dsy);
+
 	/* Create the new session. */
 	idx = -1 - options_get_number(global_s_options, "base-index");
-	s = session_create(prefix, newname, argc, argv, path, cwd, env, tiop,
-	    idx, sx, sy, &cause);
+	s = session_create(prefix, newname, argc, argv, path, cwd, env, oo,
+	    tiop, idx, &cause);
 	environ_free(env);
 	if (s == NULL) {
 		cmdq_error(item, "create session failed: %s", cause);
@@ -261,10 +287,12 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	/* Set the initial window name if one given. */
-	if (argc >= 0 && args_has(args, 'n')) {
+	if (argc >= 0 && (tmp = args_get(args, 'n')) != NULL) {
+		cp = format_single(item, tmp, c, s, NULL, NULL);
 		w = s->curw->window;
-		window_set_name(w, args_get(args, 'n'));
+		window_set_name(w, cp);
 		options_set_number(w->options, "automatic-rename", 0);
+		free(cp);
 	}
 
 	/*
@@ -298,6 +326,7 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		c->session = s;
 		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
 			server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
 		status_timer_start(c);
 		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);
@@ -331,10 +360,12 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	cmd_find_from_session(&fs, s, 0);
 	hooks_insert(s->hooks, item, &fs, "after-new-session");
 
-	free(to_free);
+	free(cwd);
+	free(newname);
 	return (CMD_RETURN_NORMAL);
 
 error:
-	free(to_free);
+	free(cwd);
+	free(newname);
 	return (CMD_RETURN_ERROR);
 }

cmd-new-window.c

@@ -57,13 +57,13 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	struct winlink		*wl = item->target.wl;
 	struct client		*c = cmd_find_client(item, NULL, 1);
 	int			 idx = item->target.idx;
-	const char		*cmd, *path, *template, *cwd;
-	char		       **argv, *cause, *cp, *to_free = NULL;
+	const char		*cmd, *path, *template, *tmp;
+	char		       **argv, *cause, *cp, *cwd, *name;
 	int			 argc, detached;
 	struct environ_entry	*envent;
 	struct cmd_find_state	 fs;
 
-	if (args_has(args, 'a')) {
+	if (args_has(args, 'a') && wl != NULL) {
 		if ((idx = winlink_shuffle_up(s, wl)) == -1) {
 			cmdq_error(item, "no free window indexes");
 			return (CMD_RETURN_ERROR);
@@ -93,16 +93,16 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	if (envent != NULL)
 		path = envent->value;
 
-	if (args_has(args, 'c')) {
-		cwd = args_get(args, 'c');
-		to_free = format_single(item, cwd, c, s, NULL, NULL);
-		cwd = to_free;
-	} else if (item->client != NULL && item->client->session == NULL)
-		cwd = item->client->cwd;
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, s, NULL, NULL);
 	else
-		cwd = s->cwd;
+		cwd = xstrdup(server_client_get_cwd(item->client, s));
+
+	if ((tmp = args_get(args, 'n')) != NULL)
+		name = format_single(item, tmp, c, s, NULL, NULL);
+	else
+		name = NULL;
 
-	wl = NULL;
 	if (idx != -1)
 		wl = winlink_find_by_index(&s->windows, idx);
 	if (wl != NULL && args_has(args, 'k')) {
@@ -124,7 +124,7 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 
 	if (idx == -1)
 		idx = -1 - options_get_number(s->options, "base-index");
-	wl = session_new(s, args_get(args, 'n'), argc, argv, path, cwd, idx,
+	wl = session_new(s, name, argc, argv, path, cwd, idx,
 		&cause);
 	if (wl == NULL) {
 		cmdq_error(item, "create window failed: %s", cause);
@@ -149,10 +149,12 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	cmd_find_from_winlink(&fs, wl, 0);
 	hooks_insert(s->hooks, item, &fs, "after-new-window");
 
-	free(to_free);
+	free(name);
+	free(cwd);
 	return (CMD_RETURN_NORMAL);
 
 error:
-	free(to_free);
+	free(name);
+	free(cwd);
 	return (CMD_RETURN_ERROR);
 }

cmd-pipe-pane.c

@@ -35,6 +35,7 @@
 
 static enum cmd_retval	cmd_pipe_pane_exec(struct cmd *, struct cmdq_item *);
 
+static void cmd_pipe_pane_read_callback(struct bufferevent *, void *);
 static void cmd_pipe_pane_write_callback(struct bufferevent *, void *);
 static void cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
 
@@ -42,8 +43,8 @@ const struct cmd_entry cmd_pipe_pane_entry = {
 	.name = "pipe-pane",
 	.alias = "pipep",
 
-	.args = { "ot:", 0, 1 },
-	.usage = "[-o] " CMD_TARGET_PANE_USAGE " [command]",
+	.args = { "IOot:", 0, 1 },
+	.usage = "[-IOo] " CMD_TARGET_PANE_USAGE " [command]",
 
 	.target = { 't', CMD_FIND_PANE, 0 },
 
@@ -60,7 +61,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	struct session		*s = item->target.s;
 	struct winlink		*wl = item->target.wl;
 	char			*cmd;
-	int			 old_fd, pipe_fd[2], null_fd;
+	int			 old_fd, pipe_fd[2], null_fd, in, out;
 	struct format_tree	*ft;
 	sigset_t		 set, oldset;
 
@@ -90,6 +91,15 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(self->args, 'o') && old_fd != -1)
 		return (CMD_RETURN_NORMAL);
 
+	/* What do we want to do? Neither -I or -O is -O. */
+	if (args_has(self->args, 'I')) {
+		in = 1;
+		out = args_has(self->args, 'O');
+	} else {
+		in = 0;
+		out = 1;
+	}
+
 	/* Open the new pipe. */
 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_fd) != 0) {
 		cmdq_error(item, "socketpair error: %s", strerror(errno));
@@ -99,7 +109,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	/* Expand the command. */
 	ft = format_create(item->client, item, FORMAT_NONE, 0);
 	format_defaults(ft, c, s, wl, wp);
-	cmd = format_expand_time(ft, args->argv[0], time(NULL));
+	cmd = format_expand_time(ft, args->argv[0]);
 	format_free(ft);
 
 	/* Fork the child. */
@@ -118,19 +128,25 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[0]);
 
-		if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
-			_exit(1);
-		if (pipe_fd[1] != STDIN_FILENO)
-			close(pipe_fd[1]);
-
 		null_fd = open(_PATH_DEVNULL, O_WRONLY, 0);
-		if (dup2(null_fd, STDOUT_FILENO) == -1)
-			_exit(1);
+		if (out) {
+			if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
+				_exit(1);
+		} else {
+			if (dup2(null_fd, STDIN_FILENO) == -1)
+				_exit(1);
+		}
+		if (in) {
+			if (dup2(pipe_fd[1], STDOUT_FILENO) == -1)
+				_exit(1);
+			if (pipe_fd[1] != STDOUT_FILENO)
+				close(pipe_fd[1]);
+		} else {
+			if (dup2(null_fd, STDOUT_FILENO) == -1)
+				_exit(1);
+		}
 		if (dup2(null_fd, STDERR_FILENO) == -1)
 			_exit(1);
-		if (null_fd != STDOUT_FILENO && null_fd != STDERR_FILENO)
-			close(null_fd);
-
 		closefrom(STDERR_FILENO + 1);
 
 		execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
@@ -141,26 +157,53 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 		close(pipe_fd[1]);
 
 		wp->pipe_fd = pipe_fd[0];
-		wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
-
-		wp->pipe_event = bufferevent_new(wp->pipe_fd, NULL,
-		    cmd_pipe_pane_write_callback, cmd_pipe_pane_error_callback,
-		    wp);
-		bufferevent_enable(wp->pipe_event, EV_WRITE);
+		if (wp->fd != -1)
+			wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
+		else
+			wp->pipe_off = 0;
 
 		setblocking(wp->pipe_fd, 0);
+		wp->pipe_event = bufferevent_new(wp->pipe_fd,
+		    cmd_pipe_pane_read_callback,
+		    cmd_pipe_pane_write_callback,
+		    cmd_pipe_pane_error_callback,
+		    wp);
+		if (wp->pipe_event == NULL)
+			fatalx("out of memory");
+		if (out)
+			bufferevent_enable(wp->pipe_event, EV_WRITE);
+		if (in)
+			bufferevent_enable(wp->pipe_event, EV_READ);
 
 		free(cmd);
 		return (CMD_RETURN_NORMAL);
 	}
 }
 
+static void
+cmd_pipe_pane_read_callback(__unused struct bufferevent *bufev, void *data)
+{
+	struct window_pane	*wp = data;
+	struct evbuffer		*evb = wp->pipe_event->input;
+	size_t			 available;
+
+	available = EVBUFFER_LENGTH(evb);
+	log_debug("%%%u pipe read %zu", wp->id, available);
+
+	bufferevent_write(wp->event, EVBUFFER_DATA(evb), available);
+	evbuffer_drain(evb, available);
+
+	if (window_pane_destroy_ready(wp))
+		server_destroy_pane(wp, 1);
+}
+
 static void
 cmd_pipe_pane_write_callback(__unused struct bufferevent *bufev, void *data)
 {
 	struct window_pane	*wp = data;
 
 	log_debug("%%%u pipe empty", wp->id);
+
 	if (window_pane_destroy_ready(wp))
 		server_destroy_pane(wp, 1);
 }

cmd-queue.c

@@ -404,10 +404,11 @@ cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
 void
 cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = item->client;
-	struct window	*w;
-	va_list		 ap;
-	char		*tmp, *msg;
+	struct client			*c = item->client;
+	struct window_pane		*wp;
+	struct window_mode_entry	*wme;
+	va_list				 ap;
+	char				*tmp, *msg;
 
 	va_start(ap, fmt);
 
@@ -425,14 +426,11 @@ cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 		evbuffer_add(c->stdout_data, "\n", 1);
 		server_client_push_stdout(c);
 	} else {
-		w = c->session->curw->window;
-		if (w->active->mode != &window_copy_mode) {
-			window_pane_reset_mode(w->active);
-			window_pane_set_mode(w->active, &window_copy_mode, NULL,
-			    NULL);
-			window_copy_init_for_output(w->active);
-		}
-		window_copy_vadd(w->active, fmt, ap);
+		wp = c->session->curw->window->active;
+		wme = TAILQ_FIRST(&wp->modes);
+		if (wme == NULL || wme->mode != &window_view_mode)
+			window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+		window_copy_vadd(wp, fmt, ap);
 	}
 
 	va_end(ap);

cmd-refresh-client.c

@@ -18,6 +18,8 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+
 #include "tmux.h"
 
 /*
@@ -31,8 +33,8 @@ const struct cmd_entry cmd_refresh_client_entry = {
 	.name = "refresh-client",
 	.alias = "refresh",
 
-	.args = { "C:St:", 0, 0 },
-	.usage = "[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,
+	.args = { "cC:DlLRSt:U", 0, 1 },
+	.usage = "[-cDlLRSU] [-C size] " CMD_TARGET_CLIENT_USAGE " [adjustment]",
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_refresh_client_exec
@@ -43,23 +45,80 @@ cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct client	*c;
-	const char	*size;
-	u_int		 w, h;
+	struct tty	*tty;
+	struct window	*w;
+	const char	*size, *errstr;
+	u_int		 x, y, adjust;
 
 	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
+	tty = &c->tty;
 
-	if (args_has(args, 'C')) {
+	if (args_has(args, 'c') ||
+	    args_has(args, 'L') ||
+	    args_has(args, 'R') ||
+	    args_has(args, 'U') ||
+	    args_has(args, 'D'))
+	{
+		if (args->argc == 0)
+			adjust = 1;
+		else {
+			adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "adjustment %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
+		}
+
+		if (args_has(args, 'c'))
+		    c->pan_window = NULL;
+		else {
+			w = c->session->curw->window;
+			if (c->pan_window != w) {
+				c->pan_window = w;
+				c->pan_ox = tty->oox;
+				c->pan_oy = tty->ooy;
+			}
+			if (args_has(args, 'L')) {
+				if (c->pan_ox > adjust)
+					c->pan_ox -= adjust;
+				else
+					c->pan_ox = 0;
+			} else if (args_has(args, 'R')) {
+				c->pan_ox += adjust;
+				if (c->pan_ox > w->sx - tty->osx)
+					c->pan_ox = w->sx - tty->osx;
+			} else if (args_has(args, 'U')) {
+				if (c->pan_oy > adjust)
+					c->pan_oy -= adjust;
+				else
+					c->pan_oy = 0;
+			} else if (args_has(args, 'D')) {
+				c->pan_oy += adjust;
+				if (c->pan_oy > w->sy - tty->osy)
+					c->pan_oy = w->sy - tty->osy;
+			}
+		}
+		tty_update_client_offset(c);
+		server_redraw_client(c);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'l')) {
+		if (c->session != NULL)
+			tty_putcode_ptr2(&c->tty, TTYC_MS, "", "?");
+	} else if (args_has(args, 'C')) {
 		if ((size = args_get(args, 'C')) == NULL) {
 			cmdq_error(item, "missing size");
 			return (CMD_RETURN_ERROR);
 		}
-		if (sscanf(size, "%u,%u", &w, &h) != 2) {
+		if (sscanf(size, "%u,%u", &x, &y) != 2 &&
+		    sscanf(size, "%ux%u", &x, &y)) {
 			cmdq_error(item, "bad size argument");
 			return (CMD_RETURN_ERROR);
 		}
-		if (w < PANE_MINIMUM || w > 5000 ||
-		    h < PANE_MINIMUM || h > 5000) {
+		if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
+		    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
 			cmdq_error(item, "size too small or too big");
 			return (CMD_RETURN_ERROR);
 		}
@@ -67,16 +126,18 @@ cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "not a control client");
 			return (CMD_RETURN_ERROR);
 		}
-		tty_set_size(&c->tty, w, h);
+		tty_set_size(&c->tty, x, y);
 		c->flags |= CLIENT_SIZECHANGED;
 		recalculate_sizes();
-	} else if (args_has(args, 'S')) {
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'S')) {
 		c->flags |= CLIENT_STATUSFORCE;
 		server_status_client(c);
 	} else {
 		c->flags |= CLIENT_STATUSFORCE;
 		server_redraw_client(c);
 	}
-
 	return (CMD_RETURN_NORMAL);
 }

cmd-rename-session.c

@@ -46,26 +46,31 @@ const struct cmd_entry cmd_rename_session_entry = {
 static enum cmd_retval
 cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct session	*s = item->target.s;
-	const char	*newname;
+	struct args		*args = self->args;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	char			*newname;
 
-	newname = args->argv[0];
-	if (strcmp(newname, s->name) == 0)
+	newname = format_single(item, args->argv[0], c, s, NULL, NULL);
+	if (strcmp(newname, s->name) == 0) {
+		free(newname);
 		return (CMD_RETURN_NORMAL);
+	}
 
 	if (!session_check_name(newname)) {
 		cmdq_error(item, "bad session name: %s", newname);
+		free(newname);
 		return (CMD_RETURN_ERROR);
 	}
 	if (session_find(newname) != NULL) {
 		cmdq_error(item, "duplicate session: %s", newname);
+		free(newname);
 		return (CMD_RETURN_ERROR);
 	}
 
 	RB_REMOVE(sessions, &sessions, s);
 	free(s->name);
-	s->name = xstrdup(newname);
+	s->name = newname;
 	RB_INSERT(sessions, &sessions, s);
 
 	server_status_session(s);

cmd-rename-window.c

@@ -46,12 +46,17 @@ static enum cmd_retval
 cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
+	struct client	*c = cmd_find_client(item, NULL, 1);
+	struct session	*s = item->target.s;
 	struct winlink	*wl = item->target.wl;
+	char		*newname;
 
-	window_set_name(wl->window, args->argv[0]);
+	newname = format_single(item, args->argv[0], c, s, wl, NULL);
+	window_set_name(wl->window, newname);
 	options_set_number(wl->window->options, "automatic-rename", 0);
 
 	server_status_window(wl->window);
+	free(newname);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-resize-pane.c

@@ -91,9 +91,8 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 		}
 	}
 
-	if (args_has(self->args, 'x')) {
-		x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
-		    &cause);
+	if (args_has(args, 'x')) {
+		x = args_strtonum(args, 'x', PANE_MINIMUM, INT_MAX, &cause);
 		if (cause != NULL) {
 			cmdq_error(item, "width %s", cause);
 			free(cause);
@@ -101,9 +100,8 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		layout_resize_pane_to(wp, LAYOUT_LEFTRIGHT, x);
 	}
-	if (args_has(self->args, 'y')) {
-		y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
-		    &cause);
+	if (args_has(args, 'y')) {
+		y = args_strtonum(args, 'y', PANE_MINIMUM, INT_MAX, &cause);
 		if (cause != NULL) {
 			cmdq_error(item, "height %s", cause);
 			free(cause);
@@ -112,13 +110,13 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 		layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
 	}
 
-	if (args_has(self->args, 'L'))
+	if (args_has(args, 'L'))
 		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust, 1);
-	else if (args_has(self->args, 'R'))
+	else if (args_has(args, 'R'))
 		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust, 1);
-	else if (args_has(self->args, 'U'))
+	else if (args_has(args, 'U'))
 		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust, 1);
-	else if (args_has(self->args, 'D'))
+	else if (args_has(args, 'D'))
 		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust, 1);
 	server_redraw_window(wl->window);
 
@@ -129,14 +127,21 @@ static void
 cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
 {
 	struct winlink		*wl;
-	struct window_pane	*loop, *wp_x, *wp_y;
-	u_int			 y, ly, x, lx, sx, sy, ex, ey;
+	struct window		*w;
+	u_int			 y, ly, x, lx;
+	static const int         offsets[][2] = {
+	    { 0, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 },
+	};
+	struct layout_cell	*cells[nitems(offsets)], *lc;
+	u_int			 ncells = 0, i, j, resizes = 0;
+	enum layout_type	 type;
 
 	wl = cmd_mouse_window(m, NULL);
 	if (wl == NULL) {
 		c->tty.mouse_drag_update = NULL;
 		return;
 	}
+	w = wl->window;
 
 	y = m->y; x = m->x;
 	if (m->statusat == 0 && y > 0)
@@ -149,37 +154,37 @@ cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
 	else if (m->statusat > 0 && ly >= (u_int)m->statusat)
 		ly = m->statusat - 1;
 
-	wp_x = wp_y = NULL;
-	TAILQ_FOREACH(loop, &wl->window->panes, entry) {
-		if (!window_pane_visible(loop))
+	for (i = 0; i < nitems(cells); i++) {
+		lc = layout_search_by_border(w->layout_root, lx + offsets[i][0],
+		    ly + offsets[i][1]);
+		if (lc == NULL)
 			continue;
 
-		sx = loop->xoff;
-		if (sx != 0)
-			sx--;
-		ex = loop->xoff + loop->sx;
+		for (j = 0; j < ncells; j++) {
+			if (cells[j] == lc) {
+				lc = NULL;
+				break;
+			}
+		}
+		if (lc == NULL)
+			continue;
 
-		sy = loop->yoff;
-		if (sy != 0)
-			sy--;
-		ey = loop->yoff + loop->sy;
-
-		if ((lx == sx || lx == ex) &&
-		    (ly >= sy && ly <= ey) &&
-		    (wp_x == NULL || loop->sy > wp_x->sy))
-			wp_x = loop;
-		if ((ly == sy || ly == ey) &&
-		    (lx >= sx && lx <= ex) &&
-		    (wp_y == NULL || loop->sx > wp_y->sx))
-			wp_y = loop;
+		cells[ncells] = lc;
+		ncells++;
 	}
-	if (wp_x == NULL && wp_y == NULL) {
-		c->tty.mouse_drag_update = NULL;
+	if (ncells == 0)
 		return;
+
+	for (i = 0; i < ncells; i++) {
+		type = cells[i]->parent->type;
+		if (y != ly && type == LAYOUT_TOPBOTTOM) {
+			layout_resize_layout(w, cells[i], type, y - ly, 0);
+			resizes++;
+		} else if (x != lx && type == LAYOUT_LEFTRIGHT) {
+			layout_resize_layout(w, cells[i], type, x - lx, 0);
+			resizes++;
+		}
 	}
-	if (wp_x != NULL)
-		layout_resize_pane(wp_x, LAYOUT_LEFTRIGHT, x - lx, 0);
-	if (wp_y != NULL)
-		layout_resize_pane(wp_y, LAYOUT_TOPBOTTOM, y - ly, 0);
-	server_redraw_window(wl->window);
+	if (resizes != 0)
+		server_redraw_window(w);
 }

cmd-resize-window.c

@@ -0,0 +1,109 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2018 Nicholas Marriott <nicholas.marriott@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 "tmux.h"
+
+/*
+ * Increase or decrease window size.
+ */
+
+static enum cmd_retval	cmd_resize_window_exec(struct cmd *,
+			    struct cmdq_item *);
+
+const struct cmd_entry cmd_resize_window_entry = {
+	.name = "resize-window",
+	.alias = "resizew",
+
+	.args = { "aADLRt:Ux:y:", 0, 1 },
+	.usage = "[-aADLRU] [-x width] [-y height] " CMD_TARGET_WINDOW_USAGE " "
+		 "[adjustment]",
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_resize_window_exec
+};
+
+static enum cmd_retval
+cmd_resize_window_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct session		*s = item->target.s;
+	const char	       	*errstr;
+	char			*cause;
+	u_int			 adjust, sx, sy;
+
+	if (args->argc == 0)
+		adjust = 1;
+	else {
+		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
+		if (errstr != NULL) {
+			cmdq_error(item, "adjustment %s", errstr);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	sx = w->sx;
+	sy = w->sy;
+
+	if (args_has(args, 'x')) {
+		sx = args_strtonum(args, 'x', WINDOW_MINIMUM, WINDOW_MAXIMUM,
+		    &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "width %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+	if (args_has(args, 'y')) {
+		sy = args_strtonum(args, 'y', WINDOW_MINIMUM, WINDOW_MAXIMUM,
+		    &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "height %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	if (args_has(args, 'L')) {
+		if (sx >= adjust)
+			sx -= adjust;
+	} else if (args_has(args, 'R'))
+		sx += adjust;
+	else if (args_has(args, 'U')) {
+		if (sy >= adjust)
+			sy -= adjust;
+	} else if (args_has(args, 'D'))
+		sy += adjust;
+
+	if (args_has(args, 'A'))
+		default_window_size(s, w, &sx, &sy, WINDOW_SIZE_LARGEST);
+	else if (args_has(args, 'a'))
+		default_window_size(s, w, &sx, &sy, WINDOW_SIZE_SMALLEST);
+
+	options_set_number(w->options, "window-size", WINDOW_SIZE_MANUAL);
+	resize_window(w, sx, sy);
+
+	return (CMD_RETURN_NORMAL);
+}

cmd-respawn-pane.c

@@ -67,7 +67,7 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);
 	}
 
-	window_pane_reset_mode(wp);
+	window_pane_reset_mode_all(wp);
 	screen_reinit(&wp->base);
 	input_init(wp);
 

cmd-respawn-window.c

@@ -99,7 +99,7 @@ cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 	free(cwd);
 
 	layout_init(w, wp);
-	window_pane_reset_mode(wp);
+	window_pane_reset_mode_all(wp);
 	screen_reinit(&wp->base);
 	input_init(wp);
 	window_set_active_pane(w, wp);

cmd-run-shell.c

@@ -57,9 +57,10 @@ struct cmd_run_shell_data {
 static void
 cmd_run_shell_print(struct job *job, const char *msg)
 {
-	struct cmd_run_shell_data	*cdata = job->data;
+	struct cmd_run_shell_data	*cdata = job_get_data(job);
 	struct window_pane		*wp = NULL;
 	struct cmd_find_state		 fs;
+	struct window_mode_entry	*wme;
 
 	if (cdata->wp_id != -1)
 		wp = window_pane_find_by_id(cdata->wp_id);
@@ -75,10 +76,10 @@ cmd_run_shell_print(struct job *job, const char *msg)
 			return;
 	}
 
-	if (window_pane_set_mode(wp, &window_copy_mode, NULL, NULL) == 0)
-		window_copy_init_for_output(wp);
-	if (wp->mode == &window_copy_mode)
-		window_copy_add(wp, "%s", msg);
+	wme = TAILQ_FIRST(&wp->modes);
+	if (wme == NULL || wme->mode != &window_view_mode)
+		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+	window_copy_add(wp, "%s", msg);
 }
 
 static enum cmd_retval
@@ -90,14 +91,6 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 	struct session			*s = item->target.s;
 	struct winlink			*wl = item->target.wl;
 	struct window_pane		*wp = item->target.wp;
-	const char			*cwd;
-
-	if (item->client != NULL && item->client->session == NULL)
-		cwd = item->client->cwd;
-	else if (s != NULL)
-		cwd = s->cwd;
-	else
-		cwd = NULL;
 
 	cdata = xcalloc(1, sizeof *cdata);
 	cdata->cmd = format_single(item, args->argv[0], c, s, wl, wp);
@@ -110,8 +103,12 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 	if (!args_has(args, 'b'))
 		cdata->item = item;
 
-	job_run(cdata->cmd, s, cwd, NULL, cmd_run_shell_callback,
-	    cmd_run_shell_free, cdata);
+	if (job_run(cdata->cmd, s, server_client_get_cwd(item->client, s), NULL,
+	    cmd_run_shell_callback, cmd_run_shell_free, cdata, 0) == NULL) {
+		cmdq_error(item, "failed to run command: %s", cdata->cmd);
+		free(cdata);
+		return (CMD_RETURN_ERROR);
+	}
 
 	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
@@ -121,22 +118,23 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 static void
 cmd_run_shell_callback(struct job *job)
 {
-	struct cmd_run_shell_data	*cdata = job->data;
-	char				*cmd = cdata->cmd, *msg, *line;
+	struct cmd_run_shell_data	*cdata = job_get_data(job);
+	struct bufferevent		*event = job_get_event(job);
+	char				*cmd = cdata->cmd, *msg = NULL, *line;
 	size_t				 size;
-	int				 retcode;
+	int				 retcode, status;
 
 	do {
-		if ((line = evbuffer_readline(job->event->input)) != NULL) {
+		if ((line = evbuffer_readline(event->input)) != NULL) {
 			cmd_run_shell_print(job, line);
 			free(line);
 		}
 	} while (line != NULL);
 
-	size = EVBUFFER_LENGTH(job->event->input);
+	size = EVBUFFER_LENGTH(event->input);
 	if (size != 0) {
 		line = xmalloc(size + 1);
-		memcpy(line, EVBUFFER_DATA(job->event->input), size);
+		memcpy(line, EVBUFFER_DATA(event->input), size);
 		line[size] = '\0';
 
 		cmd_run_shell_print(job, line);
@@ -144,12 +142,12 @@ cmd_run_shell_callback(struct job *job)
 		free(line);
 	}
 
-	msg = NULL;
-	if (WIFEXITED(job->status)) {
-		if ((retcode = WEXITSTATUS(job->status)) != 0)
+	status = job_get_status(job);
+	if (WIFEXITED(status)) {
+		if ((retcode = WEXITSTATUS(status)) != 0)
 			xasprintf(&msg, "'%s' returned %d", cmd, retcode);
-	} else if (WIFSIGNALED(job->status)) {
-		retcode = WTERMSIG(job->status);
+	} else if (WIFSIGNALED(status)) {
+		retcode = WTERMSIG(status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
 	}
 	if (msg != NULL)

cmd-save-buffer.c

@@ -59,11 +59,13 @@ static enum cmd_retval
 cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = item->client;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
-	const char		*path, *bufname, *bufdata, *start, *end;
-	const char		*flags;
-	char			*msg, *file;
+	const char		*bufname, *bufdata, *start, *end, *flags;
+	char			*msg, *path, *file;
 	size_t			 size, used, msglen, bufsize;
 	FILE			*f;
 
@@ -83,10 +85,12 @@ cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 	bufdata = paste_buffer_data(pb, &bufsize);
 
 	if (self->entry == &cmd_show_buffer_entry)
-		path = "-";
+		path = xstrdup("-");
 	else
-		path = args->argv[0];
+		path = format_single(item, args->argv[0], c, s, wl, wp);
 	if (strcmp(path, "-") == 0) {
+		free(path);
+		c = item->client;
 		if (c == NULL) {
 			cmdq_error(item, "can't write to stdout");
 			return (CMD_RETURN_ERROR);
@@ -101,6 +105,8 @@ cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 		flags = "ab";
 
 	file = server_client_get_path(c, path);
+	free(path);
+
 	f = fopen(file, flags);
 	if (f == NULL) {
 		cmdq_error(item, "%s: %s", file, strerror(errno));

cmd-select-layout.c

@@ -33,10 +33,10 @@ const struct cmd_entry cmd_select_layout_entry = {
 	.name = "select-layout",
 	.alias = "selectl",
 
-	.args = { "nopt:", 0, 1 },
-	.usage = "[-nop] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
+	.args = { "Enopt:", 0, 1 },
+	.usage = "[-Enop] " CMD_TARGET_PANE_USAGE " [layout-name]",
 
-	.target = { 't', CMD_FIND_WINDOW, 0 },
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
@@ -71,14 +71,14 @@ const struct cmd_entry cmd_previous_layout_entry = {
 static enum cmd_retval
 cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct winlink	*wl = item->target.wl;
-	struct window	*w;
-	const char	*layoutname;
-	char		*oldlayout;
-	int		 next, previous, layout;
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp = item->target.wp;
+	const char		*layoutname;
+	char			*oldlayout;
+	int			 next, previous, layout;
 
-	w = wl->window;
 	server_unzoom_window(w);
 
 	next = self->entry == &cmd_next_layout_entry;
@@ -99,6 +99,11 @@ cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 		goto changed;
 	}
 
+	if (args_has(args, 'E')) {
+		layout_spread_out(wp);
+		goto changed;
+	}
+
 	if (!args_has(args, 'o')) {
 		if (args->argc == 0)
 			layout = w->lastlayout;
@@ -130,7 +135,9 @@ cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 
 changed:
 	free(oldlayout);
+	recalculate_sizes();
 	server_redraw_window(w);
+	notify_window("window-layout-changed", w);
 	return (CMD_RETURN_NORMAL);
 
 error:

cmd-select-pane.c

@@ -18,6 +18,9 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+#include <string.h>
+
 #include "tmux.h"
 
 /*
@@ -52,19 +55,52 @@ const struct cmd_entry cmd_last_pane_entry = {
 	.exec = cmd_select_pane_exec
 };
 
+static void
+cmd_select_pane_redraw(struct window *w)
+{
+	struct client	*c;
+
+	/*
+	 * Redraw entire window if it is bigger than the client (the
+	 * offset may change), otherwise just draw borders.
+	 */
+
+	TAILQ_FOREACH(c, &clients, entry) {
+		if (c->session == NULL)
+			continue;
+		if (c->session->curw->window == w && tty_window_bigger(&c->tty))
+			server_redraw_client(c);
+		else {
+			if (c->session->curw->window == w)
+				c->flags |= CLIENT_REDRAWBORDERS;
+			if (session_has(c->session, w))
+				c->flags |= CLIENT_REDRAWSTATUS;
+		}
+
+	}
+}
+
 static enum cmd_retval
 cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct cmd_find_state	*current = &item->shared->current;
+	struct client		*c = cmd_find_client(item, NULL, 1);
 	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
 	struct session		*s = item->target.s;
 	struct window_pane	*wp = item->target.wp, *lastwp, *markedwp;
+	struct style		*sy = &wp->style;
+	char			*pane_title;
 	const char		*style;
 
 	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
 		lastwp = w->last;
+		if (lastwp == NULL && window_count_panes(w) == 2) {
+			lastwp = TAILQ_PREV(w->active, window_panes, entry);
+			if (lastwp == NULL)
+				lastwp = TAILQ_NEXT(w->active, entry);
+		}
 		if (lastwp == NULL) {
 			cmdq_error(item, "no last pane");
 			return (CMD_RETURN_ERROR);
@@ -78,8 +114,7 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 			window_redraw_active_switch(w, lastwp);
 			if (window_set_active_pane(w, lastwp)) {
 				cmd_find_from_winlink(current, wl, 0);
-				server_status_window(w);
-				server_redraw_window_borders(w);
+				cmd_select_pane_redraw(w);
 			}
 		}
 		return (CMD_RETURN_NORMAL);
@@ -108,17 +143,16 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	if (args_has(self->args, 'P') || args_has(self->args, 'g')) {
-		if (args_has(args, 'P')) {
-			style = args_get(args, 'P');
-			if (style_parse(&grid_default_cell, &wp->colgc,
-			    style) == -1) {
+		if ((style = args_get(args, 'P')) != NULL) {
+			style_set(sy, &grid_default_cell);
+			if (style_parse(sy, &grid_default_cell, style) == -1) {
 				cmdq_error(item, "bad style: %s", style);
 				return (CMD_RETURN_ERROR);
 			}
 			wp->flags |= PANE_REDRAW;
 		}
 		if (args_has(self->args, 'g'))
-			cmdq_print(item, "%s", style_tostring(&wp->colgc));
+			cmdq_print(item, "%s", style_tostring(sy));
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -148,23 +182,22 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	if (args_has(self->args, 'T')) {
-	    screen_set_title(&wp->base, args_get(self->args, 'T'));
-	    server_status_window(wp->window);
+		pane_title = format_single(item, args_get(self->args, 'T'),
+		    c, s, wl, wp);
+		screen_set_title(&wp->base, pane_title);
+		server_status_window(wp->window);
+		free(pane_title);
+		return (CMD_RETURN_NORMAL);
 	}
 
 	if (wp == w->active)
 		return (CMD_RETURN_NORMAL);
 	server_unzoom_window(wp->window);
-	if (!window_pane_visible(wp)) {
-		cmdq_error(item, "pane not visible");
-		return (CMD_RETURN_ERROR);
-	}
 	window_redraw_active_switch(w, wp);
 	if (window_set_active_pane(w, wp)) {
 		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		hooks_insert(s->hooks, item, current, "after-select-pane");
-		server_status_window(w);
-		server_redraw_window_borders(w);
+		cmd_select_pane_redraw(w);
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-send-keys.c

@@ -58,21 +58,23 @@ const struct cmd_entry cmd_send_prefix_entry = {
 static void
 cmd_send_keys_inject(struct client *c, struct cmdq_item *item, key_code key)
 {
-	struct window_pane	*wp = item->target.wp;
-	struct session		*s = item->target.s;
-	struct key_table	*table;
-	struct key_binding	*bd, bd_find;
+	struct window_pane		*wp = item->target.wp;
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct window_mode_entry	*wme;
+	struct key_table		*table;
+	struct key_binding		*bd;
 
-	if (wp->mode == NULL || wp->mode->key_table == NULL) {
+	wme = TAILQ_FIRST(&wp->modes);
+	if (wme == NULL || wme->mode->key_table == NULL) {
 		if (options_get_number(wp->window->options, "xterm-keys"))
 			key |= KEYC_XTERM;
-		window_pane_key(wp, NULL, s, key, NULL);
+		window_pane_key(wp, NULL, s, wl, key, NULL);
 		return;
 	}
-	table = key_bindings_get_table(wp->mode->key_table(wp), 1);
+	table = key_bindings_get_table(wme->mode->key_table(wme), 1);
 
-	bd_find.key = (key & ~KEYC_XTERM);
-	bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find);
+	bd = key_bindings_get(table, key & ~KEYC_XTERM);
 	if (bd != NULL) {
 		table->references++;
 		key_bindings_dispatch(bd, item, c, NULL, &item->target);
@@ -83,17 +85,19 @@ cmd_send_keys_inject(struct client *c, struct cmdq_item *item, key_code key)
 static enum cmd_retval
 cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct client		*c = cmd_find_client(item, NULL, 1);
-	struct window_pane	*wp = item->target.wp;
-	struct session		*s = item->target.s;
-	struct mouse_event	*m = &item->shared->mouse;
-	struct utf8_data	*ud, *uc;
-	wchar_t			 wc;
-	int			 i, literal;
-	key_code		 key;
-	u_int			 np = 1;
-	char			*cause = NULL;
+	struct args			*args = self->args;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct window_pane		*wp = item->target.wp;
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct mouse_event		*m = &item->shared->mouse;
+	struct window_mode_entry	*wme = TAILQ_FIRST(&wp->modes);
+	struct utf8_data		*ud, *uc;
+	wchar_t				 wc;
+	int				 i, literal;
+	key_code			 key;
+	u_int				 np = 1;
+	char				*cause = NULL;
 
 	if (args_has(args, 'N')) {
 		np = args_strtonum(args, 'N', 1, UINT_MAX, &cause);
@@ -102,19 +106,23 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-		if (args_has(args, 'X') || args->argc == 0)
-			wp->modeprefix = np;
+		if (wme != NULL && (args_has(args, 'X') || args->argc == 0)) {
+			if (wme == NULL || wme->mode->command == NULL) {
+				cmdq_error(item, "not in a mode");
+				return (CMD_RETURN_ERROR);
+			}
+			wme->prefix = np;
+		}
 	}
 
 	if (args_has(args, 'X')) {
-		if (wp->mode == NULL || wp->mode->command == NULL) {
+		if (wme == NULL || wme->mode->command == NULL) {
 			cmdq_error(item, "not in a mode");
 			return (CMD_RETURN_ERROR);
 		}
 		if (!m->valid)
-			wp->mode->command(wp, c, s, args, NULL);
-		else
-			wp->mode->command(wp, c, s, args, m);
+			m = NULL;
+		wme->mode->command(wme, c, s, wl, args, m);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -124,7 +132,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "no mouse target");
 			return (CMD_RETURN_ERROR);
 		}
-		window_pane_key(wp, NULL, s, m->key, m);
+		window_pane_key(wp, NULL, s, wl, m->key, m);
 		return (CMD_RETURN_NORMAL);
 	}
 

cmd-set-hook.c

@@ -33,8 +33,8 @@ const struct cmd_entry cmd_set_hook_entry = {
 	.name = "set-hook",
 	.alias = NULL,
 
-	.args = { "gt:u", 1, 2 },
-	.usage = "[-gu] " CMD_TARGET_SESSION_USAGE " hook-name [command]",
+	.args = { "gRt:u", 1, 2 },
+	.usage = "[-gRu] " CMD_TARGET_SESSION_USAGE " hook-name [command]",
 
 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
@@ -101,18 +101,21 @@ cmd_set_hook_exec(struct cmd *self, struct cmdq_item *item)
 	else
 		cmd = args->argv[1];
 
+	if (cmd != NULL && (args_has(args, 'R') || args_has(args, 'u'))) {
+		cmdq_error(item, "no command allowed");
+		return (CMD_RETURN_ERROR);
+	}
+	if (args_has(args, 'R')) {
+		notify_hook(item, name);
+		return (CMD_RETURN_NORMAL);
+	}
 	if (args_has(args, 'u')) {
-		if (cmd != NULL) {
-			cmdq_error(item, "command passed to unset hook: %s",
-			    name);
-			return (CMD_RETURN_ERROR);
-		}
 		hooks_remove(hooks, name);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (cmd == NULL) {
-		cmdq_error(item, "no command to set hook: %s", name);
+		cmdq_error(item, "no command given");
 		return (CMD_RETURN_ERROR);
 	}
 	cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);

cmd-set-option.c

@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <fnmatch.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -80,6 +81,7 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	char				*name, *argument, *value = NULL, *cause;
 	const char			*target;
 	int				 window, idx, already, error, ambiguous;
+	struct style			*sy;
 
 	/* Expand argument. */
 	c = cmd_find_client(item, NULL, 1);
@@ -162,11 +164,9 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	parent = options_get(oo, name);
 
 	/* Check that array options and indexes match up. */
-	if (idx != -1) {
-		if (*name == '@' || options_array_size(parent, NULL) == -1) {
-			cmdq_error(item, "not an array: %s", argument);
-			goto fail;
-		}
+	if (idx != -1 && (*name == '@' || !options_isarray(parent))) {
+		cmdq_error(item, "not an array: %s", argument);
+		goto fail;
 	}
 
 	/* With -o, check this option is not already set. */
@@ -192,7 +192,9 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 		if (o == NULL)
 			goto out;
 		if (idx == -1) {
-			if (oo == global_options ||
+			if (*name == '@')
+				options_remove(o);
+			else if (oo == global_options ||
 			    oo == global_s_options ||
 			    oo == global_w_options)
 				options_default(oo, options_table_entry(o));
@@ -206,7 +208,7 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 			goto fail;
 		}
 		options_set_string(oo, name, append, "%s", value);
-	} else if (idx == -1 && options_array_size(parent, NULL) == -1) {
+	} else if (idx == -1 && !options_isarray(parent)) {
 		error = cmd_set_option_set(self, item, oo, parent, value);
 		if (error != 0)
 			goto fail;
@@ -246,6 +248,16 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 				tty_keys_build(&loop->tty);
 		}
 	}
+	if (strcmp(name, "status-fg") == 0 || strcmp(name, "status-bg") == 0) {
+		sy = options_get_style(oo, "status-style");
+		sy->gc.fg = options_get_number(oo, "status-fg");
+		sy->gc.bg = options_get_number(oo, "status-bg");
+	}
+	if (strcmp(name, "status-style") == 0) {
+		sy = options_get_style(oo, "status-style");
+		options_set_number(oo, "status-fg", sy->gc.fg);
+		options_set_number(oo, "status-bg", sy->gc.bg);
+	}
 	if (strcmp(name, "status") == 0 ||
 	    strcmp(name, "status-interval") == 0)
 		status_timer_start_all();
@@ -258,10 +270,10 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	if (strcmp(name, "pane-border-status") == 0) {
 		RB_FOREACH(w, windows, &windows)
-			layout_fix_panes(w, w->sx, w->sy);
+			layout_fix_panes(w);
 	}
 	RB_FOREACH(s, sessions, &sessions)
-		status_update_saved(s);
+		status_update_cache(s);
 
 	/*
 	 * Update sizes and redraw. May not always be necessary but do it
@@ -295,7 +307,8 @@ cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
 	int					 append = args_has(args, 'a');
 	struct options_entry			*o;
 	long long				 number;
-	const char				*errstr;
+	const char				*errstr, *new;
+	char					*old;
 	key_code				 key;
 
 	oe = options_table_entry(parent);
@@ -308,7 +321,16 @@ cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
 
 	switch (oe->type) {
 	case OPTIONS_TABLE_STRING:
+		old = xstrdup(options_get_string(oo, oe->name));
 		options_set_string(oo, oe->name, append, "%s", value);
+		new = options_get_string(oo, oe->name);
+		if (oe->pattern != NULL && fnmatch(oe->pattern, new, 0) != 0) {
+			options_set_string(oo, oe->name, 0, "%s", old);
+			free(old);
+			cmdq_error(item, "value is invalid: %s", value);
+			return (-1);
+		}
+		free(old);
 		return (0);
 	case OPTIONS_TABLE_NUMBER:
 		number = strtonum(value, oe->minimum, oe->maximum, &errstr);
@@ -331,16 +353,7 @@ cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
 			cmdq_error(item, "bad colour: %s", value);
 			return (-1);
 		}
-		o = options_set_number(oo, oe->name, number);
-		options_style_update_new(oo, o);
-		return (0);
-	case OPTIONS_TABLE_ATTRIBUTES:
-		if ((number = attributes_fromstring(value)) == -1) {
-			cmdq_error(item, "bad attributes: %s", value);
-			return (-1);
-		}
-		o = options_set_number(oo, oe->name, number);
-		options_style_update_new(oo, o);
+		options_set_number(oo, oe->name, number);
 		return (0);
 	case OPTIONS_TABLE_FLAG:
 		return (cmd_set_option_flag(item, oe, oo, value));
@@ -352,7 +365,6 @@ cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
 			cmdq_error(item, "bad style: %s", value);
 			return (-1);
 		}
-		options_style_update_old(oo, o);
 		return (0);
 	case OPTIONS_TABLE_ARRAY:
 		break;

cmd-show-messages.c

@@ -43,7 +43,6 @@ const struct cmd_entry cmd_show_messages_entry = {
 };
 
 static int	cmd_show_messages_terminals(struct cmdq_item *, int);
-static int	cmd_show_messages_jobs(struct cmdq_item *, int);
 
 static int
 cmd_show_messages_terminals(struct cmdq_item *item, int blank)
@@ -66,25 +65,6 @@ cmd_show_messages_terminals(struct cmdq_item *item, int blank)
 	return (n != 0);
 }
 
-static int
-cmd_show_messages_jobs(struct cmdq_item *item, int blank)
-{
-	struct job	*job;
-	u_int		 n;
-
-	n = 0;
-	LIST_FOREACH(job, &all_jobs, entry) {
-		if (blank) {
-			cmdq_print(item, "%s", "");
-			blank = 0;
-		}
-		cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]",
-		    n, job->cmd, job->fd, (long)job->pid, job->status);
-		n++;
-	}
-	return (n != 0);
-}
-
 static enum cmd_retval
 cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 {
@@ -103,7 +83,7 @@ cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 		done = 1;
 	}
 	if (args_has(args, 'J')) {
-		cmd_show_messages_jobs(item, blank);
+		job_print_summary(item, blank);
 		done = 1;
 	}
 	if (done)

cmd-show-options.c

@@ -88,20 +88,20 @@ static void
 cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
     struct options_entry *o, int idx)
 {
-	const char	*name;
-	const char	*value;
-	char		*tmp, *escaped;
-	u_int		 size, i;
+	struct options_array_item	*a;
+	const char			*name, *value;
+	char				*tmp, *escaped;
 
 	if (idx != -1) {
 		xasprintf(&tmp, "%s[%d]", options_name(o), idx);
 		name = tmp;
 	} else {
-		if (options_array_size(o, &size) != -1) {
-			for (i = 0; i < size; i++) {
-				if (options_array_get(o, i) == NULL)
-					continue;
-				cmd_show_options_print(self, item, o, i);
+		if (options_isarray(o)) {
+			a = options_array_first(o);
+			while (a != NULL) {
+				idx = options_array_item_index(a);
+				cmd_show_options_print(self, item, o, idx);
+				a = options_array_next(a);
 			}
 			return;
 		}
@@ -164,24 +164,22 @@ static enum cmd_retval
 cmd_show_options_all(struct cmd *self, struct cmdq_item *item,
     struct options *oo)
 {
-	struct options_entry			 *o;
+	struct options_entry			*o;
 	const struct options_table_entry	*oe;
-	u_int					 size, idx;
+	struct options_array_item		*a;
+	u_int					 idx;
 
 	o = options_first(oo);
 	while (o != NULL) {
 		oe = options_table_entry(o);
-		if (oe != NULL && oe->style != NULL) {
-			o = options_next(o);
-			continue;
-		}
-		if (options_array_size(o, &size) == -1)
+		if (!options_isarray(o))
 			cmd_show_options_print(self, item, o, -1);
 		else {
-			for (idx = 0; idx < size; idx++) {
-				if (options_array_get(o, idx) == NULL)
-					continue;
+			a = options_array_first(o);
+			while (a != NULL) {
+				idx = options_array_item_index(a);
 				cmd_show_options_print(self, item, o, idx);
+				a = options_array_next(a);
 			}
 		}
 		o = options_next(o);

cmd-source-file.c

@@ -60,7 +60,7 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 	if (*path == '/')
 		pattern = xstrdup(path);
 	else {
-		utf8_stravis(&tmp, server_client_get_cwd(c), VIS_GLOB);
+		utf8_stravis(&tmp, server_client_get_cwd(c, NULL), VIS_GLOB);
 		xasprintf(&pattern, "%s/%s", tmp, path);
 		free(tmp);
 	}

cmd-split-window.c

@@ -60,10 +60,10 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	struct window		*w = wl->window;
 	struct window_pane	*wp = item->target.wp, *new_wp = NULL;
 	struct environ		*env;
-	const char		*cmd, *path, *shell, *template, *cwd;
-	char		       **argv, *cause, *new_cause, *cp, *to_free = NULL;
+	const char		*cmd, *path, *shell, *template, *tmp;
+	char		       **argv, *cause, *new_cause, *cp, *cwd;
 	u_int			 hlimit;
-	int			 argc, size, percentage;
+	int			 argc, size, percentage, before;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
 	struct environ_entry	*envent;
@@ -85,18 +85,15 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 		argv = args->argv;
 	}
 
-	if (args_has(args, 'c')) {
-		cwd = args_get(args, 'c');
-		to_free = format_single(item, cwd, c, s, NULL, NULL);
-		cwd = to_free;
-	} else if (item->client != NULL && item->client->session == NULL)
-		cwd = item->client->cwd;
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, s, NULL, NULL);
 	else
-		cwd = s->cwd;
+		cwd = xstrdup(server_client_get_cwd(item->client, s));
 
 	type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'h'))
 		type = LAYOUT_LEFTRIGHT;
+	before = args_has(args, 'b');
 
 	size = -1;
 	if (args_has(args, 'l')) {
@@ -126,13 +123,12 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	if (*shell == '\0' || areshell(shell))
 		shell = _PATH_BSHELL;
 
-	lc = layout_split_pane(wp, type, size, args_has(args, 'b'),
-	    args_has(args, 'f'));
+	lc = layout_split_pane(wp, type, size, before, args_has(args, 'f'));
 	if (lc == NULL) {
 		cause = xstrdup("pane too small");
 		goto error;
 	}
-	new_wp = window_add_pane(w, wp, args_has(args, 'b'), hlimit);
+	new_wp = window_add_pane(w, wp, before, args_has(args, 'f'), hlimit);
 	layout_make_leaf(lc, new_wp);
 
 	path = NULL;
@@ -151,7 +147,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	environ_free(env);
 
-	layout_fix_panes(w, w->sx, w->sy);
+	layout_fix_panes(w);
 	server_redraw_window(w);
 
 	if (!args_has(args, 'd')) {
@@ -174,7 +170,7 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
 	hooks_insert(s->hooks, item, &fs, "after-split-window");
 
-	free(to_free);
+	free(cwd);
 	return (CMD_RETURN_NORMAL);
 
 error:
@@ -185,6 +181,6 @@ error:
 	cmdq_error(item, "create pane failed: %s", cause);
 	free(cause);
 
-	free(to_free);
+	free(cwd);
 	return (CMD_RETURN_ERROR);
 }

cmd-string.c

@@ -54,6 +54,22 @@ cmd_string_ungetc(size_t *p)
 	(*p)--;
 }
 
+static int
+cmd_string_unicode(wchar_t *wc, const char *s, size_t *p, char ch)
+{
+	int	size = (ch == 'u') ? 4 : 8;
+	u_int	tmp;
+
+	if (size == 4 && sscanf(s + *p, "%4x", &tmp) != 1)
+		return (-1);
+	if (size == 8 && sscanf(s + *p, "%8x", &tmp) != 1)
+		return (-1);
+	*p += size;
+
+	*wc = (wchar_t)tmp;
+	return (0);
+}
+
 int
 cmd_string_split(const char *s, int *rargc, char ***rargv)
 {
@@ -191,12 +207,11 @@ cmd_string_copy(char **dst, char *src, size_t *len)
 static char *
 cmd_string_string(const char *s, size_t *p, char endch, int esc)
 {
-	int	ch;
-	char   *buf, *t;
-	size_t	len;
-
-	buf = NULL;
-	len = 0;
+	int			ch;
+	wchar_t			wc;
+	struct utf8_data	ud;
+	char		       *buf = NULL, *t;
+	size_t			len = 0;
 
 	while ((ch = cmd_string_getc(s, p)) != endch) {
 		switch (ch) {
@@ -220,6 +235,18 @@ cmd_string_string(const char *s, size_t *p, char endch, int esc)
 			case 't':
 				ch = '\t';
 				break;
+			case 'u':
+			case 'U':
+				if (cmd_string_unicode(&wc, s, p, ch) != 0)
+					goto error;
+				if (utf8_split(wc, &ud) != UTF8_DONE)
+					goto error;
+				if (len >= SIZE_MAX - ud.size - 1)
+					goto error;
+				buf = xrealloc(buf, len + ud.size);
+				memcpy(buf + len, ud.data, ud.size);
+				len += ud.size;
+				continue;
 			}
 			break;
 		case '$':

cmd-swap-pane.c

@@ -105,8 +105,6 @@ cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 			window_set_active_pane(dst_w, src_wp);
 		} else {
 			tmp_wp = dst_wp;
-			if (!window_pane_visible(tmp_wp))
-				tmp_wp = src_wp;
 			window_set_active_pane(src_w, tmp_wp);
 		}
 	} else {

cmd-switch-client.c

@@ -113,8 +113,11 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 		if (item->client == NULL)
 			return (CMD_RETURN_NORMAL);
 		if (wl != NULL) {
-			if (wp != NULL)
+			server_unzoom_window(wl->window);
+			if (wp != NULL) {
+				window_redraw_active_switch(wp->window, wp);
 				window_set_active_pane(wp->window, wp);
+			}
 			session_set_current(s, wl);
 			cmd_find_from_session(&item->shared->current, s, 0);
 		}
@@ -128,6 +131,7 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 	c->session = s;
 	if (~item->shared->flags & CMDQ_SHARED_REPEAT)
 		server_client_set_key_table(c, NULL);
+	tty_update_client_offset(c);
 	status_timer_start(c);
 	notify_client("client-session-changed", c);
 	session_update_activity(s, NULL);

cmd-wait-for.c

@@ -170,7 +170,7 @@ cmd_wait_for_wait(struct cmdq_item *item, const char *name,
 	struct client		*c = item->client;
 	struct wait_item	*wi;
 
-	if (c == NULL || c->session != NULL) {
+	if (c == NULL) {
 		cmdq_error(item, "not able to wait");
 		return (CMD_RETURN_ERROR);
 	}
@@ -198,7 +198,7 @@ cmd_wait_for_lock(struct cmdq_item *item, const char *name,
 {
 	struct wait_item	*wi;
 
-	if (item->client == NULL || item->client->session != NULL) {
+	if (item->client == NULL) {
 		cmdq_error(item, "not able to lock");
 		return (CMD_RETURN_ERROR);
 	}

cmd.c

@@ -80,6 +80,7 @@ extern const struct cmd_entry cmd_refresh_client_entry;
 extern const struct cmd_entry cmd_rename_session_entry;
 extern const struct cmd_entry cmd_rename_window_entry;
 extern const struct cmd_entry cmd_resize_pane_entry;
+extern const struct cmd_entry cmd_resize_window_entry;
 extern const struct cmd_entry cmd_respawn_pane_entry;
 extern const struct cmd_entry cmd_respawn_window_entry;
 extern const struct cmd_entry cmd_rotate_window_entry;
@@ -166,6 +167,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_rename_session_entry,
 	&cmd_rename_window_entry,
 	&cmd_resize_pane_entry,
+	&cmd_resize_window_entry,
 	&cmd_respawn_pane_entry,
 	&cmd_respawn_window_entry,
 	&cmd_rotate_window_entry,
@@ -200,6 +202,15 @@ const struct cmd_entry *cmd_table[] = {
 	NULL
 };
 
+void
+cmd_log_argv(int argc, char **argv, const char *prefix)
+{
+	int	i;
+
+	for (i = 0; i < argc; i++)
+		log_debug("%s: argv[%d]=%s", prefix, i, argv[i]);
+}
+
 int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 {
@@ -208,6 +219,7 @@ cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 
 	if (argc == 0)
 		return (0);
+	cmd_log_argv(argc, argv, __func__);
 
 	*buf = '\0';
 	for (i = 0; i < argc; i++) {
@@ -240,9 +252,11 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 
 		arglen = strlen(buf) + 1;
 		(*argv)[i] = xstrdup(buf);
+
 		buf += arglen;
 		len -= arglen;
 	}
+	cmd_log_argv(argc, *argv, __func__);
 
 	return (0);
 }
@@ -304,31 +318,31 @@ cmd_stringify_argv(int argc, char **argv)
 static int
 cmd_try_alias(int *argc, char ***argv)
 {
-	struct options_entry	 *o;
-	int			  old_argc = *argc, new_argc;
-	char			**old_argv = *argv, **new_argv;
-	u_int			  size, idx;
-	int			  i;
-	size_t			  wanted;
-	const char		 *s, *cp = NULL;
+	struct options_entry		 *o;
+	struct options_array_item	 *a;
+	int				  old_argc = *argc, new_argc, i;
+	char				**old_argv = *argv, **new_argv;
+	size_t				  wanted;
+	const char			 *s, *cp = NULL;
 
 	o = options_get_only(global_options, "command-alias");
-	if (o == NULL || options_array_size(o, &size) == -1 || size == 0)
+	if (o == NULL)
 		return (-1);
-
 	wanted = strlen(old_argv[0]);
-	for (idx = 0; idx < size; idx++) {
-		s = options_array_get(o, idx);
-		if (s == NULL)
-			continue;
 
-		cp = strchr(s, '=');
-		if (cp == NULL || (size_t)(cp - s) != wanted)
-			continue;
-		if (strncmp(old_argv[0], s, wanted) == 0)
-			break;
+	a = options_array_first(o);
+	while (a != NULL) {
+		s = options_array_item_value(a);
+		if (s != NULL) {
+			cp = strchr(s, '=');
+			if (cp != NULL &&
+			    (size_t)(cp - s) == wanted &&
+			    strncmp(old_argv[0], s, wanted) == 0)
+				break;
+		}
+		a = options_array_next(a);
 	}
-	if (idx == size)
+	if (a == NULL)
 		return (-1);
 
 	if (cmd_string_split(cp + 1, &new_argc, &new_argv) != 0)
@@ -401,6 +415,7 @@ retry:
 		xasprintf(cause, "unknown command: %s", name);
 		return (NULL);
 	}
+	cmd_log_argv(argc, argv, entry->name);
 
 	args = args_parse(entry->args.template, argc, argv);
 	if (args == NULL)

colour.c

@@ -141,6 +141,8 @@ colour_tostring(int c)
 		return ("white");
 	case 8:
 		return ("default");
+	case 9:
+		return ("terminal");
 	case 90:
 		return ("brightblack");
 	case 91:
@@ -158,7 +160,7 @@ colour_tostring(int c)
 	case 97:
 		return ("brightwhite");
 	}
-	return (NULL);
+	return ("invalid");
 }
 
 /* Convert colour from string. */
@@ -188,6 +190,11 @@ colour_fromstring(const char *s)
 		return (n | COLOUR_FLAG_256);
 	}
 
+	if (strcasecmp(s, "default") == 0)
+		return (8);
+	if (strcasecmp(s, "terminal") == 0)
+		return (9);
+
 	if (strcasecmp(s, "black") == 0 || strcmp(s, "0") == 0)
 		return (0);
 	if (strcasecmp(s, "red") == 0 || strcmp(s, "1") == 0)
@@ -204,8 +211,6 @@ colour_fromstring(const char *s)
 		return (6);
 	if (strcasecmp(s, "white") == 0 || strcmp(s, "7") == 0)
 		return (7);
-	if (strcasecmp(s, "default") == 0 || strcmp(s, "8") == 0)
-		return (8);
 	if (strcasecmp(s, "brightblack") == 0 || strcmp(s, "90") == 0)
 		return (90);
 	if (strcasecmp(s, "brightred") == 0 || strcmp(s, "91") == 0)

compat.h

@@ -101,17 +101,17 @@ void	warnx(const char *, ...);
 #include <paths.h>
 #endif
 
-#ifdef HAVE_FORKPTY
 #ifdef HAVE_LIBUTIL_H
 #include <libutil.h>
 #endif
+
 #ifdef HAVE_PTY_H
 #include <pty.h>
 #endif
+
 #ifdef HAVE_UTIL_H
 #include <util.h>
 #endif
-#endif
 
 #ifdef HAVE_VIS
 #include <vis.h>

compat/getdtablecount.c

@@ -30,19 +30,12 @@ getdtablecount(void)
 {
 	char	path[PATH_MAX];
 	glob_t	g;
-	int	n;
+	int	n = 0;
 
 	if (snprintf(path, sizeof path, "/proc/%ld/fd/*", (long)getpid()) < 0)
 		fatal("snprintf overflow");
-	switch (glob(path, 0, NULL, &g)) {
-	case GLOB_NOMATCH:
-		return (0);
-	case 0:
-		break;
-	default:
-		fatal("glob(\"%s\") failed", path);
-	}
-	n = g.gl_pathc;
+	if (glob(path, 0, NULL, &g) == 0)
+		n = g.gl_pathc;
 	globfree(&g);
 	return (n);
 }

compat/imsg-buffer.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: imsg-buffer.c,v 1.10 2017/04/11 09:57:19 reyk Exp $	*/
+/*	$OpenBSD: imsg-buffer.c,v 1.11 2017/12/14 09:27:44 kettenis Exp $	*/
 
 /*
  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
@@ -29,9 +29,9 @@
 #include "compat.h"
 #include "imsg.h"
 
-int	ibuf_realloc(struct ibuf *, size_t);
-void	ibuf_enqueue(struct msgbuf *, struct ibuf *);
-void	ibuf_dequeue(struct msgbuf *, struct ibuf *);
+static int	ibuf_realloc(struct ibuf *, size_t);
+static void	ibuf_enqueue(struct msgbuf *, struct ibuf *);
+static void	ibuf_dequeue(struct msgbuf *, struct ibuf *);
 
 struct ibuf *
 ibuf_open(size_t len)
@@ -67,7 +67,7 @@ ibuf_dynamic(size_t len, size_t max)
 	return (buf);
 }
 
-int
+static int
 ibuf_realloc(struct ibuf *buf, size_t len)
 {
 	u_char	*b;
@@ -289,14 +289,14 @@ again:
 	return (1);
 }
 
-void
+static void
 ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
 {
 	TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
 	msgbuf->queued++;
 }
 
-void
+static void
 ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
 {
 	TAILQ_REMOVE(&msgbuf->bufs, buf, entry);

compat/imsg.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: imsg.c,v 1.15 2017/04/11 09:57:19 reyk Exp $	*/
+/*	$OpenBSD: imsg.c,v 1.16 2017/12/14 09:27:44 kettenis Exp $	*/
 
 /*
  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
@@ -30,7 +30,7 @@
 
 int	 imsg_fd_overhead = 0;
 
-int	 imsg_get_fd(struct imsgbuf *);
+static int	 imsg_get_fd(struct imsgbuf *);
 
 void
 imsg_init(struct imsgbuf *ibuf, int fd)
@@ -266,7 +266,7 @@ imsg_free(struct imsg *imsg)
 	freezero(imsg->data, imsg->hdr.len - IMSG_HEADER_SIZE);
 }
 
-int
+static int
 imsg_get_fd(struct imsgbuf *ibuf)
 {
 	int		 fd;

configure.ac

@@ -1,6 +1,6 @@
 # configure.ac
 
-AC_INIT(tmux, 2.6)
+AC_INIT([tmux], 2.9)
 AC_PREREQ([2.60])
 
 AC_CONFIG_AUX_DIR(etc)
@@ -35,7 +35,7 @@ AC_USE_SYSTEM_EXTENSIONS
 test "$sysconfdir" = '${prefix}/etc' && sysconfdir=/etc
 
 # Is this --enable-debug?
-test "x$VERSION" = xmaster && enable_debug=yes
+case "x$VERSION" in xnext*) enable_debug=yes;; esac
 AC_ARG_ENABLE(
 	debug,
 	AC_HELP_STRING(--enable-debug, enable debug build flags),
@@ -285,6 +285,7 @@ if test "x$found_b64_ntop" = xno; then
 	AC_MSG_RESULT(no)
 
 	AC_MSG_CHECKING(for b64_ntop with -lresolv)
+	OLD_LIBS="$LIBS"
 	LIBS="$LIBS -lresolv"
 	AC_TRY_LINK(
 		[
@@ -297,6 +298,7 @@ if test "x$found_b64_ntop" = xno; then
 		found_b64_ntop=no
 	)
 	if test "x$found_b64_ntop" = xno; then
+		LIBS="$OLD_LIBS"
 		AC_MSG_RESULT(no)
 	fi
 fi
@@ -476,6 +478,9 @@ if test "x$found_forkpty" = xyes; then
 fi
 AM_CONDITIONAL(NEED_FORKPTY, test "x$found_forkpty" = xno)
 
+# Look for kinfo_getfile in libutil.
+AC_SEARCH_LIBS(kinfo_getfile, [util util-freebsd])
+
 # Look for a suitable queue.h.
 AC_CHECK_DECL(
 	TAILQ_CONCAT,
@@ -608,13 +613,22 @@ case "$host_os" in
 	*solaris*)
 		AC_MSG_RESULT(sunos)
 		PLATFORM=sunos
-		MANFORMAT=man
+		case `/usr/bin/nroff --version 2>&1` in
+			*GNU*)
+				# Solaris 11.4 and later use GNU groff.
+				MANFORMAT=mdoc
+				;;
+			*)
+				# Solaris 2.0 to 11.3 use AT&T nroff.
+				MANFORMAT=man
+				;;
+		esac
 		;;
 	*hpux*)
 		AC_MSG_RESULT(hpux)
 		PLATFORM=hpux
 		;;
-	*cygwin*)
+	*cygwin*|*msys*)
 		AC_MSG_RESULT(cygwin)
 		PLATFORM=cygwin
 		;;

control-notify.c

@@ -47,6 +47,8 @@ control_notify_input(struct client *c, struct window_pane *wp,
 	 */
 	if (winlink_find_by_window(&c->session->windows, wp->window) != NULL) {
 		message = evbuffer_new();
+		if (message == NULL)
+			fatalx("out of memory");
 		evbuffer_add_printf(message, "%%output %%%u ", wp->id);
 		for (i = 0; i < len; i++) {
 			if (buf[i] < ' ' || buf[i] == '\\')

environ.c

@@ -174,22 +174,26 @@ environ_unset(struct environ *env, const char *name)
 void
 environ_update(struct options *oo, struct environ *src, struct environ *dst)
 {
-	struct environ_entry	*envent;
-	struct options_entry	*o;
-	u_int			 size, idx;
-	const char		*value;
+	struct environ_entry		*envent;
+	struct options_entry		*o;
+	struct options_array_item	*a;
+	const char			*value;
 
 	o = options_get(oo, "update-environment");
-	if (o == NULL || options_array_size(o, &size) == -1)
+	if (o == NULL)
 		return;
-	for (idx = 0; idx < size; idx++) {
-		value = options_array_get(o, idx);
-		if (value == NULL)
+	a = options_array_first(o);
+	while (a != NULL) {
+		value = options_array_item_value(a);
+		if (value == NULL) {
+			a = options_array_next(a);
 			continue;
+		}
 		if ((envent = environ_find(src, value)) == NULL)
 			environ_clear(dst, value);
 		else
 			environ_set(dst, envent->name, "%s", envent->value);
+		a = options_array_next(a);
 	}
 }
 

example_tmux.conf

@@ -49,11 +49,15 @@ bind F10 selectw -t:19
 bind F11 selectw -t:20
 bind F12 selectw -t:21
 
-# Keys to toggle monitoring activity in a window, and synchronize-panes
+# A key to toggle between smallest and largest sizes if a window is visible in
+# multiple places
+bind F set -w window-size
+
+# Keys to toggle monitoring activity in a window and the synchronize-panes option
 bind m set monitor-activity
 bind y set synchronize-panes\; display 'synchronize-panes #{?synchronize-panes,on,off}'
 
-# Create a single default session, because a session is created here, tmux
+# Create a single default session - because a session is created here, tmux
 # should be started with "tmux attach" rather than "tmux new"
 new -d -s0 -nirssi 'exec irssi'
 set -t0:0 monitor-activity on

format-draw.c

@@ -0,0 +1,892 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@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"
+
+/* Format range. */
+struct format_range {
+	u_int				 index;
+	struct screen			*s;
+
+	u_int				 start;
+	u_int				 end;
+
+	enum style_range_type		 type;
+	u_int				 argument;
+
+	TAILQ_ENTRY(format_range)	 entry;
+};
+TAILQ_HEAD(format_ranges, format_range);
+
+/* Does this range match this style? */
+static int
+format_is_type(struct format_range *fr, struct style *sy)
+{
+	if (fr->type != sy->range_type)
+		return (0);
+	if (fr->type == STYLE_RANGE_WINDOW &&
+	    fr->argument != sy->range_argument)
+		return (0);
+	return (1);
+}
+
+/* Free a range. */
+static void
+format_free_range(struct format_ranges *frs, struct format_range *fr)
+{
+	TAILQ_REMOVE(frs, fr, entry);
+	free(fr);
+}
+
+/* Fix range positions. */
+static void
+format_update_ranges(struct format_ranges *frs, struct screen *s, u_int offset,
+    u_int start, u_int width)
+{
+	struct format_range	*fr, *fr1;
+
+	if (frs == NULL)
+		return;
+
+	TAILQ_FOREACH_SAFE(fr, frs, entry, fr1) {
+		if (fr->s != s)
+			continue;
+
+		if (fr->end <= start || fr->start >= start + width) {
+			format_free_range(frs, fr);
+			continue;
+		}
+
+		if (fr->start < start)
+			fr->start = start;
+		if (fr->end > start + width)
+			fr->end = start + width;
+		if (fr->start == fr->end) {
+			format_free_range(frs, fr);
+			continue;
+		}
+
+		fr->start -= start;
+		fr->end -= start;
+
+		fr->start += offset;
+		fr->end += offset;
+	}
+}
+
+/* Draw a part of the format. */
+static void
+format_draw_put(struct screen_write_ctx *octx, u_int ocx, u_int ocy,
+    struct screen *s, struct format_ranges *frs, u_int offset, u_int start,
+    u_int width)
+{
+	/*
+	 * The offset is how far from the cursor on the target screen; start
+	 * and width how much to copy from the source screen.
+	 */
+	screen_write_cursormove(octx, ocx + offset, ocy, 0);
+	screen_write_fast_copy(octx, s, start, 0, width, 1);
+	format_update_ranges(frs, s, offset, start, width);
+}
+
+/* Draw list part of format. */
+static void
+format_draw_put_list(struct screen_write_ctx *octx,
+    u_int ocx, u_int ocy, u_int offset, u_int width, struct screen *list,
+    struct screen *list_left, struct screen *list_right, int focus_start,
+    int focus_end, struct format_ranges *frs)
+{
+	u_int	start, focus_centre;
+
+	/* If there is enough space for the list, draw it entirely. */
+	if (width >= list->cx) {
+		format_draw_put(octx, ocx, ocy, list, frs, offset, 0, width);
+		return;
+	}
+
+	/* The list needs to be trimmed. Try to keep the focus visible. */
+	focus_centre = focus_start + (focus_end - focus_start) / 2;
+	if (focus_centre < width / 2)
+		start = 0;
+	else
+		start = focus_centre - width / 2;
+	if (start + width > list->cx)
+		start = list->cx - width;
+
+	/* Draw <> markers at either side if needed. */
+	if (start != 0 && width > list_left->cx) {
+		screen_write_cursormove(octx, ocx + offset, ocy, 0);
+		screen_write_fast_copy(octx, list_left, 0, 0, list_left->cx, 1);
+		offset += list_left->cx;
+		start += list_left->cx;
+		width -= list_left->cx;
+	}
+	if (start + width < list->cx && width > list_right->cx) {
+		screen_write_cursormove(octx, ocx + offset + width - 1, ocy, 0);
+		screen_write_fast_copy(octx, list_right, 0, 0, list_right->cx,
+		    1);
+		width -= list_right->cx;
+	}
+
+	/* Draw the list screen itself. */
+	format_draw_put(octx, ocx, ocy, list, frs, offset, start, width);
+}
+
+/* Draw format with no list. */
+static void
+format_draw_none(struct screen_write_ctx *octx, u_int available, u_int ocx,
+    u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
+    struct format_ranges *frs)
+{
+	u_int	width_left, width_centre, width_right;
+
+	width_left = left->cx;
+	width_centre = centre->cx;
+	width_right = right->cx;
+
+	/*
+	 * Try to keep as much of the left and right as possible at the expense
+	 * of the centre.
+	 */
+	while (width_left + width_centre + width_right > available) {
+		if (width_centre > 0)
+			width_centre--;
+		else if (width_right > 0)
+			width_right--;
+		else
+			width_left--;
+	}
+
+	/* Write left. */
+	format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
+
+	/* Write right at available - width_right. */
+	format_draw_put(octx, ocx, ocy, right, frs,
+	    available - width_right,
+	    right->cx - width_right,
+	    width_right);
+
+	/*
+	 * Write centre halfway between
+	 *     width_left
+	 * and
+	 *     available - width_right.
+	 */
+	format_draw_put(octx, ocx, ocy, centre, frs,
+	    width_left
+	    + ((available - width_right) - width_left) / 2
+	    - width_centre / 2,
+	    centre->cx / 2 - width_centre / 2,
+	    width_centre);
+}
+
+/* Draw format with list on the left. */
+static void
+format_draw_left(struct screen_write_ctx *octx, u_int available, u_int ocx,
+    u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
+    struct screen *list, struct screen *list_left, struct screen *list_right,
+    struct screen *after, int focus_start, int focus_end,
+    struct format_ranges *frs)
+{
+	u_int			width_left, width_centre, width_right;
+	u_int			width_list, width_after;
+	struct screen_write_ctx	ctx;
+
+	width_left = left->cx;
+	width_centre = centre->cx;
+	width_right = right->cx;
+	width_list = list->cx;
+	width_after = after->cx;
+
+	/*
+	 * Trim first the centre, then the list, then the right, then after the
+	 * list, then the left.
+	 */
+	while (width_left +
+	    width_centre +
+	    width_right +
+	    width_list +
+	    width_after > available) {
+		if (width_centre > 0)
+			width_centre--;
+		else if (width_list > 0)
+			width_list--;
+		else if (width_right > 0)
+			width_right--;
+		else if (width_after > 0)
+			width_after--;
+		else
+			width_left--;
+	}
+
+	/* If there is no list left, pass off to the no list function. */
+	if (width_list == 0) {
+		screen_write_start(&ctx, NULL, left);
+		screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
+		screen_write_stop(&ctx);
+
+		format_draw_none(octx, available, ocx, ocy, left, centre,
+		    right, frs);
+		return;
+	}
+
+	/* Write left at 0. */
+	format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
+
+	/* Write right at available - width_right. */
+	format_draw_put(octx, ocx, ocy, right, frs,
+	    available - width_right,
+	    right->cx - width_right,
+	    width_right);
+
+	/* Write after at width_left + width_list. */
+	format_draw_put(octx, ocx, ocy, after, frs,
+	    width_left + width_list,
+	    0,
+	    width_after);
+
+	/*
+	 * Write centre halfway between
+	 *     width_left + width_list + width_after
+	 * and
+	 *     available - width_right.
+	 */
+	format_draw_put(octx, ocx, ocy, centre, frs,
+	    (width_left + width_list + width_after)
+	    + ((available - width_right)
+		- (width_left + width_list + width_after)) / 2
+	    - width_centre / 2,
+	    centre->cx / 2 - width_centre / 2,
+	    width_centre);
+
+	/*
+	 * The list now goes from
+	 *     width_left
+	 * to
+	 *     width_left + width_list.
+	 * If there is no focus given, keep the left in focus.
+	 */
+	if (focus_start == -1 || focus_end == -1)
+		focus_start = focus_end = 0;
+	format_draw_put_list(octx, ocx, ocy, width_left, width_list, list,
+	    list_left, list_right, focus_start, focus_end, frs);
+}
+
+/* Draw format with list in the centre. */
+static void
+format_draw_centre(struct screen_write_ctx *octx, u_int available, u_int ocx,
+    u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
+    struct screen *list, struct screen *list_left, struct screen *list_right,
+    struct screen *after, int focus_start, int focus_end,
+    struct format_ranges *frs)
+{
+	u_int			width_left, width_centre, width_right;
+	u_int			width_list, width_after, middle;
+	struct screen_write_ctx	ctx;
+
+	width_left = left->cx;
+	width_centre = centre->cx;
+	width_right = right->cx;
+	width_list = list->cx;
+	width_after = after->cx;
+
+	/*
+	 * Trim first the list, then after the list, then the centre, then the
+	 * right, then the left.
+	 */
+	while (width_left +
+	    width_centre +
+	    width_right +
+	    width_list +
+	    width_after > available) {
+		if (width_list > 0)
+			width_list--;
+		else if (width_after > 0)
+			width_after--;
+		else if (width_centre > 0)
+			width_centre--;
+		else if (width_right > 0)
+			width_right--;
+		else
+			width_left--;
+	}
+
+	/* If there is no list left, pass off to the no list function. */
+	if (width_list == 0) {
+		screen_write_start(&ctx, NULL, centre);
+		screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
+		screen_write_stop(&ctx);
+
+		format_draw_none(octx, available, ocx, ocy, left, centre,
+		    right, frs);
+		return;
+	}
+
+	/* Write left at 0. */
+	format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
+
+	/* Write after at available - width_after. */
+	format_draw_put(octx, ocx, ocy, after, frs,
+	    available - width_after,
+	    after->cx - width_after,
+	    width_after);
+
+	/* Write right at available - width_right. */
+	format_draw_put(octx, ocx, ocy, right, frs,
+	    available - width_right,
+	    right->cx - width_right,
+	    width_right);
+
+	/*
+	 * All three centre sections are offset from the middle of the
+	 * available space.
+	 */
+	middle = (width_left + ((available - width_right) - width_left) / 2);
+
+	/*
+	 * Write centre at
+	 *     middle - width_list / 2 - width_centre.
+	 */
+	format_draw_put(octx, ocx, ocy, centre, frs,
+	    middle - width_list / 2 - width_centre,
+	    0,
+	    width_centre);
+
+	/*
+	 * Write after at
+	 *     middle + width_list / 2 - width_centre.
+	 */
+	format_draw_put(octx, ocx, ocy, after, frs,
+	    middle + width_list / 2,
+	    0,
+	    width_after);
+
+	/*
+	 * The list now goes from
+	 *     middle - width_list / 2
+	 * to
+	 *     middle + width_list / 2
+	 * If there is no focus given, keep the centre in focus.
+	 */
+	if (focus_start == -1 || focus_end == -1)
+		focus_start = focus_end = list->cx / 2;
+	format_draw_put_list(octx, ocx, ocy, middle - width_list / 2,
+	    width_list, list, list_left, list_right, focus_start, focus_end,
+	    frs);
+}
+
+/* Draw format with list on the right. */
+static void
+format_draw_right(struct screen_write_ctx *octx, u_int available, u_int ocx,
+    u_int ocy, struct screen *left, struct screen *centre, struct screen *right,
+    struct screen *list, struct screen *list_left, struct screen *list_right,
+    struct screen *after, int focus_start, int focus_end,
+    struct format_ranges *frs)
+{
+	u_int			width_left, width_centre, width_right;
+	u_int			width_list, width_after;
+	struct screen_write_ctx	ctx;
+
+	width_left = left->cx;
+	width_centre = centre->cx;
+	width_right = right->cx;
+	width_list = list->cx;
+	width_after = after->cx;
+
+	/*
+	 * Trim first the centre, then the list, then the right, then
+	 * after the list, then the left.
+	 */
+	while (width_left +
+	    width_centre +
+	    width_right +
+	    width_list +
+	    width_after > available) {
+		if (width_centre > 0)
+			width_centre--;
+		else if (width_list > 0)
+			width_list--;
+		else if (width_right > 0)
+			width_right--;
+		else if (width_after > 0)
+			width_after--;
+		else
+			width_left--;
+	}
+
+	/* If there is no list left, pass off to the no list function. */
+	if (width_list == 0) {
+		screen_write_start(&ctx, NULL, right);
+		screen_write_fast_copy(&ctx, after, 0, 0, width_after, 1);
+		screen_write_stop(&ctx);
+
+		format_draw_none(octx, available, ocx, ocy, left, centre,
+		    right, frs);
+		return;
+	}
+
+	/* Write left at 0. */
+	format_draw_put(octx, ocx, ocy, left, frs, 0, 0, width_left);
+
+	/* Write after at available - width_after. */
+	format_draw_put(octx, ocx, ocy, after, frs,
+	    available - width_after,
+	    after->cx - width_after,
+	    width_after);
+
+	/*
+	 * Write right at
+	 *     available - width_right - width_list - width_after.
+	 */
+	format_draw_put(octx, ocx, ocy, right, frs,
+	    available - width_right - width_list - width_after,
+	    0,
+	    width_right);
+
+	/*
+	 * Write centre halfway between
+	 *     width_left
+	 * and
+	 *     available - width_right - width_list - width_after.
+	 */
+	format_draw_put(octx, ocx, ocy, centre, frs,
+	    width_left
+	    + ((available - width_right - width_list - width_after)
+		- width_left) / 2
+	    - width_centre / 2,
+	    centre->cx / 2 - width_centre / 2,
+	    width_centre);
+
+	/*
+	 * The list now goes from
+	 *     available - width_list - width_after
+	 * to
+	 *     available - width_after
+	 * If there is no focus given, keep the right in focus.
+	 */
+	if (focus_start == -1 || focus_end == -1)
+		focus_start = focus_end = 0;
+	format_draw_put_list(octx, ocx, ocy, available - width_list -
+	    width_after, width_list, list, list_left, list_right, focus_start,
+	    focus_end, frs);
+}
+
+/* Draw a format to a screen. */
+void
+format_draw(struct screen_write_ctx *octx, const struct grid_cell *base,
+    u_int available, const char *expanded, struct style_ranges *srs)
+{
+	enum { LEFT,
+	       CENTRE,
+	       RIGHT,
+	       LIST,
+	       LIST_LEFT,
+	       LIST_RIGHT,
+	       AFTER,
+	       TOTAL } current = LEFT, last = LEFT;
+	const char	        *names[] = { "LEFT",
+					     "CENTRE",
+					     "RIGHT",
+					     "LIST",
+					     "LIST_LEFT",
+					     "LIST_RIGHT",
+					     "AFTER" };
+	size_t			 size = strlen(expanded);
+	struct screen		*os = octx->s, s[TOTAL];
+	struct screen_write_ctx	 ctx[TOTAL];
+	u_int			 ocx = os->cx, ocy = os->cy, i, width[TOTAL];
+	u_int			 map[] = { LEFT, LEFT, CENTRE, RIGHT };
+	int			 focus_start = -1, focus_end = -1;
+	int			 list_state = -1;
+	enum style_align	 list_align = STYLE_ALIGN_DEFAULT;
+	struct style		 sy;
+	struct utf8_data	*ud = &sy.gc.data;
+	const char		*cp, *end;
+	enum utf8_state		 more;
+	char			*tmp;
+	struct format_range	*fr = NULL, *fr1;
+	struct format_ranges	 frs;
+	struct style_range	*sr;
+
+	style_set(&sy, base);
+	TAILQ_INIT(&frs);
+	log_debug("%s: %s", __func__, expanded);
+
+	/*
+	 * We build three screens for left, right, centre alignment, one for
+	 * the list, one for anything after the list and two for the list left
+	 * and right markers.
+	 */
+	for (i = 0; i < TOTAL; i++) {
+		screen_init(&s[i], size, 1, 0);
+		screen_write_start(&ctx[i], NULL, &s[i]);
+		screen_write_clearendofline(&ctx[i], base->bg);
+		width[i] = 0;
+	}
+
+	/*
+	 * Walk the string and add to the corresponding screens,
+	 * parsing styles as we go.
+	 */
+	cp = expanded;
+	while (*cp != '\0') {
+		if (cp[0] != '#' || cp[1] != '[') {
+			/* See if this is a UTF-8 character. */
+			if ((more = utf8_open(ud, *cp)) == UTF8_MORE) {
+				while (*++cp != '\0' && more == UTF8_MORE)
+					more = utf8_append(ud, *cp);
+				if (more != UTF8_DONE)
+					cp -= ud->have;
+			}
+
+			/* Not a UTF-8 character - ASCII or not valid. */
+			if (more != UTF8_DONE) {
+				if (*cp < 0x20 || *cp > 0x7e) {
+					/* Ignore nonprintable characters. */
+					cp++;
+					continue;
+				}
+				utf8_set(ud, *cp);
+				cp++;
+			}
+
+			/* Draw the cell to th current screen. */
+			screen_write_cell(&ctx[current], &sy.gc);
+			width[current] += ud->width;
+			continue;
+		}
+
+		/* This is a style. Work out where the end is and parse it. */
+		end = format_skip(cp + 2, "]");
+		if (end == NULL) {
+			log_debug("%s: no terminating ] at '%s'", __func__,
+			    cp + 2);
+			TAILQ_FOREACH_SAFE(fr, &frs, entry, fr1)
+			    format_free_range(&frs, fr);
+			goto out;
+		}
+		tmp = xstrndup(cp + 2, end - (cp + 2));
+		if (style_parse(&sy, base, tmp) != 0) {
+			log_debug("%s: invalid style '%s'", __func__, tmp);
+			free(tmp);
+			cp = end + 1;
+			continue;
+		}
+		log_debug("%s: style '%s' -> '%s'", __func__, tmp,
+		    style_tostring(&sy));
+		free(tmp);
+
+		/* Check the list state. */
+		switch (sy.list) {
+		case STYLE_LIST_ON:
+			/*
+			 * Entering the list, exiting a marker, or exiting the
+			 * focus.
+			 */
+			if (list_state != 0) {
+				if (fr != NULL) { /* abort any region */
+					free(fr);
+					fr = NULL;
+				}
+				list_state = 0;
+				list_align = sy.align;
+			}
+
+			/* End the focus if started. */
+			if (focus_start != -1 && focus_end == -1)
+				focus_end = s[LIST].cx;
+
+			current = LIST;
+			break;
+		case STYLE_LIST_FOCUS:
+			/* Entering the focus. */
+			if (list_state != 0) /* not inside the list */
+				break;
+			if (focus_start == -1) /* focus already started */
+				focus_start = s[LIST].cx;
+			break;
+		case STYLE_LIST_OFF:
+			/* Exiting or outside the list. */
+			if (list_state == 0) {
+				if (fr != NULL) { /* abort any region */
+					free(fr);
+					fr = NULL;
+				}
+				if (focus_start != -1 && focus_end == -1)
+					focus_end = s[LIST].cx;
+
+				map[list_align] = AFTER;
+				if (list_align == STYLE_ALIGN_LEFT)
+					map[STYLE_ALIGN_DEFAULT] = AFTER;
+				list_state = 1;
+			}
+			current = map[sy.align];
+			break;
+		case STYLE_LIST_LEFT_MARKER:
+			/* Entering left marker. */
+			if (list_state != 0) /* not inside the list */
+				break;
+			if (s[LIST_LEFT].cx != 0) /* already have marker */
+				break;
+			if (fr != NULL) { /* abort any region */
+				free(fr);
+				fr = NULL;
+			}
+			if (focus_start != -1 && focus_end == -1)
+				focus_start = focus_end = -1;
+			current = LIST_LEFT;
+			break;
+		case STYLE_LIST_RIGHT_MARKER:
+			/* Entering right marker. */
+			if (list_state != 0) /* not inside the list */
+				break;
+			if (s[LIST_RIGHT].cx != 0) /* already have marker */
+				break;
+			if (fr != NULL) { /* abort any region */
+				free(fr);
+				fr = NULL;
+			}
+			if (focus_start != -1 && focus_end == -1)
+				focus_start = focus_end = -1;
+			current = LIST_RIGHT;
+			break;
+		}
+		if (current != last) {
+			log_debug("%s: change %s -> %s", __func__,
+			    names[last], names[current]);
+			last = current;
+		}
+
+		/*
+		 * Check if the range style has changed and if so end the
+		 * current range and start a new one if needed.
+		 */
+		if (srs != NULL) {
+			if (fr != NULL && !format_is_type(fr, &sy)) {
+				if (s[current].cx != fr->start) {
+					fr->end = s[current].cx + 1;
+					TAILQ_INSERT_TAIL(&frs, fr, entry);
+				} else
+					free(fr);
+				fr = NULL;
+			}
+			if (fr == NULL && sy.range_type != STYLE_RANGE_NONE) {
+				fr = xcalloc(1, sizeof *fr);
+				fr->index = current;
+
+				fr->s = &s[current];
+				fr->start = s[current].cx;
+
+				fr->type = sy.range_type;
+				fr->argument = sy.range_argument;
+			}
+		}
+
+		cp = end + 1;
+	}
+	free(fr);
+
+	for (i = 0; i < TOTAL; i++) {
+		screen_write_stop(&ctx[i]);
+		log_debug("%s: width %s is %u", __func__, names[i], width[i]);
+	}
+	if (focus_start != -1 && focus_end != -1)
+		log_debug("%s: focus %d-%d", __func__, focus_start, focus_end);
+	TAILQ_FOREACH(fr, &frs, entry) {
+		log_debug("%s: range %d|%u is %s %u-%u", __func__, fr->type,
+		    fr->argument, names[fr->index], fr->start, fr->end);
+	}
+
+	/*
+	 * Draw the screens. How they are arranged depends on where the list
+	 * appearsq.
+	 */
+	switch (list_align) {
+	case STYLE_ALIGN_DEFAULT:
+		/* No list. */
+		format_draw_none(octx, available, ocx, ocy, &s[LEFT],
+		    &s[CENTRE], &s[RIGHT], &frs);
+		break;
+	case STYLE_ALIGN_LEFT:
+		/* List is part of the left. */
+		format_draw_left(octx, available, ocx, ocy, &s[LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[LIST], &s[LIST_LEFT],
+		    &s[LIST_RIGHT], &s[AFTER], focus_start, focus_end, &frs);
+		break;
+	case STYLE_ALIGN_CENTRE:
+		/* List is part of the centre. */
+		format_draw_centre(octx, available, ocx, ocy, &s[LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[LIST], &s[LIST_LEFT],
+		    &s[LIST_RIGHT], &s[AFTER], focus_start, focus_end, &frs);
+		break;
+	case STYLE_ALIGN_RIGHT:
+		/* List is part of the right. */
+		format_draw_right(octx, available, ocx, ocy, &s[LEFT],
+		    &s[CENTRE], &s[RIGHT], &s[LIST], &s[LIST_LEFT],
+		    &s[LIST_RIGHT], &s[AFTER], focus_start, focus_end, &frs);
+		break;
+	}
+
+	/* Create ranges to return. */
+	TAILQ_FOREACH_SAFE(fr, &frs, entry, fr1) {
+		sr = xcalloc(1, sizeof *sr);
+		sr->type = fr->type;
+		sr->argument = fr->argument;
+		sr->start = fr->start;
+		sr->end = fr->end;
+		TAILQ_INSERT_TAIL(srs, sr, entry);
+
+		log_debug("%s: range %d|%u at %u-%u", __func__, sr->type,
+		    sr->argument, sr->start, sr->end);
+
+		format_free_range(&frs, fr);
+	}
+
+out:
+	/* Free the screens. */
+	for (i = 0; i < TOTAL; i++)
+		screen_free(&s[i]);
+
+	/* Restore the original cursor position. */
+	screen_write_cursormove(octx, ocx, ocy, 0);
+}
+
+/* Get width, taking #[] into account. */
+u_int
+format_width(const char *expanded)
+{
+	const char		*cp, *end;
+	u_int			 width = 0;
+	struct utf8_data	 ud;
+	enum utf8_state		 more;
+
+	cp = expanded;
+	while (*cp != '\0') {
+		if (cp[0] == '#' && cp[1] == '[') {
+			end = format_skip(cp + 2, "]");
+			if (end == NULL)
+				return 0;
+			cp = end + 1;
+		} else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
+			while (*++cp != '\0' && more == UTF8_MORE)
+				more = utf8_append(&ud, *cp);
+			if (more == UTF8_DONE)
+				width += ud.width;
+			else
+				cp -= ud.have;
+		} else if (*cp > 0x1f && *cp < 0x7f) {
+			width++;
+			cp++;
+		}
+	}
+	return (width);
+}
+
+/* Trim on the left, taking #[] into account. */
+char *
+format_trim_left(const char *expanded, u_int limit)
+{
+	char			*copy, *out;
+	const char		*cp = expanded, *end;
+	u_int			 width = 0;
+	struct utf8_data	 ud;
+	enum utf8_state		 more;
+
+	out = copy = xmalloc(strlen(expanded) + 1);
+	while (*cp != '\0') {
+		if (cp[0] == '#' && cp[1] == '[') {
+			end = format_skip(cp + 2, "]");
+			if (end == NULL)
+				break;
+			memcpy(out, cp, end + 1 - cp);
+			out += (end + 1 - cp);
+			cp = end + 1;
+		} else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
+			while (*++cp != '\0' && more == UTF8_MORE)
+				more = utf8_append(&ud, *cp);
+			if (more == UTF8_DONE) {
+				if (width + ud.width <= limit) {
+					memcpy(out, ud.data, ud.size);
+					out += ud.size;
+				}
+				width += ud.width;
+			} else
+				cp -= ud.have;
+		} else if (*cp > 0x1f && *cp < 0x7f) {
+			if (width + 1 <= limit)
+				*out++ = *cp;
+			width++;
+			cp++;
+		} else
+			cp++;
+	}
+	*out = '\0';
+	return (copy);
+}
+
+/* Trim on the right, taking #[] into account. */
+char *
+format_trim_right(const char *expanded, u_int limit)
+{
+	char			*copy, *out;
+	const char		*cp = expanded, *end;
+	u_int			 width = 0, total_width, skip;
+	struct utf8_data	 ud;
+	enum utf8_state		 more;
+
+	total_width = format_width(expanded);
+	if (total_width <= limit)
+		return (xstrdup(expanded));
+	skip = total_width - limit;
+
+	out = copy = xmalloc(strlen(expanded) + 1);
+	while (*cp != '\0') {
+		if (cp[0] == '#' && cp[1] == '[') {
+			end = format_skip(cp + 2, "]");
+			if (end == NULL)
+				break;
+			memcpy(out, cp, end + 1 - cp);
+			out += (end + 1 - cp);
+			cp = end + 1;
+		} else if ((more = utf8_open(&ud, *cp)) == UTF8_MORE) {
+			while (*++cp != '\0' && more == UTF8_MORE)
+				more = utf8_append(&ud, *cp);
+			if (more == UTF8_DONE) {
+				if (width >= skip) {
+					memcpy(out, ud.data, ud.size);
+					out += ud.size;
+				}
+				width += ud.width;
+			} else
+				cp -= ud.have;
+		} else if (*cp > 0x1f && *cp < 0x7f) {
+			if (width >= skip)
+				*out++ = *cp;
+			width++;
+			cp++;
+		} else
+			cp++;
+	}
+	*out = '\0';
+	return (copy);
+}

grid-view.c

@@ -64,7 +64,7 @@ grid_view_clear_history(struct grid *gd, u_int bg)
 	/* Find the last used line. */
 	last = 0;
 	for (yy = 0; yy < gd->sy; yy++) {
-		gl = &gd->linedata[grid_view_y(gd, yy)];
+		gl = grid_get_line(gd, grid_view_y(gd, yy));
 		if (gl->cellused != 0)
 			last = yy + 1;
 	}

grid.c

@@ -39,32 +39,23 @@
 const struct grid_cell grid_default_cell = {
 	0, 0, 8, 8, { { ' ' }, 0, 1, 1 }
 };
-static const struct grid_cell_entry grid_default_entry = {
-	0, { .data = { 0, 8, 8, ' ' } }
+
+/* Cleared grid cell data. */
+const struct grid_cell grid_cleared_cell = {
+	GRID_FLAG_CLEARED, 0, 8, 8, { { ' ' }, 0, 1, 1 }
+};
+static const struct grid_cell_entry grid_cleared_entry = {
+	GRID_FLAG_CLEARED, { .data = { 0, 8, 8, ' ' } }
 };
 
-static void	grid_expand_line(struct grid *, u_int, u_int, u_int);
 static void	grid_empty_line(struct grid *, u_int, u_int);
 
-static void	grid_reflow_copy(struct grid_line *, u_int, struct grid_line *,
-		    u_int, u_int);
-static void	grid_reflow_join(struct grid *, u_int *, struct grid_line *,
-		    u_int);
-static void	grid_reflow_split(struct grid *, u_int *, struct grid_line *,
-		    u_int, u_int);
-static void	grid_reflow_move(struct grid *, u_int *, struct grid_line *);
-
-static size_t	grid_string_cells_fg(const struct grid_cell *, int *);
-static size_t	grid_string_cells_bg(const struct grid_cell *, int *);
-static void	grid_string_cells_code(const struct grid_cell *,
-		    const struct grid_cell *, char *, size_t, int);
-
 /* Store cell in entry. */
 static void
 grid_store_cell(struct grid_cell_entry *gce, const struct grid_cell *gc,
     u_char c)
 {
-	gce->flags = gc->flags;
+	gce->flags = (gc->flags & ~GRID_FLAG_CLEARED);
 
 	gce->data.fg = gc->fg & 0xff;
 	if (gc->fg & COLOUR_FLAG_256)
@@ -78,7 +69,7 @@ grid_store_cell(struct grid_cell_entry *gce, const struct grid_cell *gc,
 	gce->data.data = c;
 }
 
-/* Check if a cell should be extended. */
+/* Check if a cell should be an extended cell. */
 static int
 grid_need_extended_cell(const struct grid_cell_entry *gce,
     const struct grid_cell *gc)
@@ -94,6 +85,40 @@ grid_need_extended_cell(const struct grid_cell_entry *gce,
 	return (0);
 }
 
+/* Get an extended cell. */
+static void
+grid_get_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
+    int flags)
+{
+	u_int at = gl->extdsize + 1;
+
+	gl->extddata = xreallocarray(gl->extddata, at, sizeof *gl->extddata);
+	gl->extdsize = at;
+
+	gce->offset = at - 1;
+	gce->flags = (flags | GRID_FLAG_EXTENDED);
+}
+
+/* Set cell as extended. */
+static struct grid_cell *
+grid_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
+    const struct grid_cell *gc)
+{
+	struct grid_cell	*gcp;
+	int			 flags = (gc->flags & ~GRID_FLAG_CLEARED);
+
+	if (~gce->flags & GRID_FLAG_EXTENDED)
+		grid_get_extended_cell(gl, gce, flags);
+	else if (gce->offset >= gl->extdsize)
+		fatalx("offset too big");
+	gl->flags |= GRID_LINE_EXTENDED;
+
+	gcp = &gl->extddata[gce->offset];
+	memcpy(gcp, gc, sizeof *gcp);
+	gcp->flags = flags;
+	return (gcp);
+}
+
 /* Free up unused extended cells. */
 static void
 grid_compact_line(struct grid_line *gl)
@@ -136,27 +161,18 @@ grid_compact_line(struct grid_line *gl)
 	gl->extdsize = new_extdsize;
 }
 
-/* Set cell as extended. */
-static struct grid_cell *
-grid_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
-    const struct grid_cell *gc)
+/* Get line data. */
+struct grid_line *
+grid_get_line(struct grid *gd, u_int line)
 {
-	struct grid_cell	*gcp;
+	return (&gd->linedata[line]);
+}
 
-	gl->flags |= GRID_LINE_EXTENDED;
-
-	if (~gce->flags & GRID_FLAG_EXTENDED) {
-		gl->extddata = xreallocarray(gl->extddata, gl->extdsize + 1,
-		    sizeof *gl->extddata);
-		gce->offset = gl->extdsize++;
-		gce->flags = gc->flags | GRID_FLAG_EXTENDED;
-	}
-	if (gce->offset >= gl->extdsize)
-		fatalx("offset too big");
-
-	gcp = &gl->extddata[gce->offset];
-	memcpy(gcp, gc, sizeof *gcp);
-	return (gcp);
+/* Adjust number of lines. */
+void
+grid_adjust_lines(struct grid *gd, u_int lines)
+{
+	gd->linedata = xreallocarray(gd->linedata, lines, sizeof *gd->linedata);
 }
 
 /* Copy default into a cell. */
@@ -167,9 +183,13 @@ grid_clear_cell(struct grid *gd, u_int px, u_int py, u_int bg)
 	struct grid_cell_entry	*gce = &gl->celldata[px];
 	struct grid_cell	*gc;
 
-	memcpy(gce, &grid_default_entry, sizeof *gce);
+	memcpy(gce, &grid_cleared_entry, sizeof *gce);
 	if (bg & COLOUR_FLAG_RGB) {
-		gc = grid_extended_cell(gl, gce, &grid_default_cell);
+		grid_get_extended_cell(gl, gce, gce->flags);
+		gl->flags |= GRID_LINE_EXTENDED;
+
+		gc = &gl->extddata[gce->offset];
+		memcpy(gc, &grid_cleared_cell, sizeof *gc);
 		gc->bg = bg;
 	} else {
 		if (bg & COLOUR_FLAG_256)
@@ -180,10 +200,10 @@ grid_clear_cell(struct grid *gd, u_int px, u_int py, u_int bg)
 
 /* Check grid y position. */
 static int
-grid_check_y(struct grid *gd, u_int py)
+grid_check_y(struct grid *gd, const char* from, u_int py)
 {
-	if ((py) >= (gd)->hsize + (gd)->sy) {
-		log_debug("y out of range: %u", py);
+	if (py >= gd->hsize + gd->sy) {
+		log_debug("%s: y out of range: %u", from, py);
 		return (-1);
 	}
 	return (0);
@@ -240,7 +260,10 @@ grid_create(u_int sx, u_int sy, u_int hlimit)
 	gd->hsize = 0;
 	gd->hlimit = hlimit;
 
-	gd->linedata = xcalloc(gd->sy, sizeof *gd->linedata);
+	if (gd->sy != 0)
+		gd->linedata = xcalloc(gd->sy, sizeof *gd->linedata);
+	else
+		gd->linedata = NULL;
 
 	return (gd);
 }
@@ -283,6 +306,15 @@ grid_compare(struct grid *ga, struct grid *gb)
 	return (0);
 }
 
+/* Trim lines from the history. */
+static void
+grid_trim_history(struct grid *gd, u_int ny)
+{
+	grid_free_lines(gd, 0, ny);
+	memmove(&gd->linedata[0], &gd->linedata[ny],
+	    (gd->hsize + gd->sy - ny) * (sizeof *gd->linedata));
+}
+
 /*
  * Collect lines from the history if at the limit. Free the top (oldest) 10%
  * and shift up.
@@ -305,9 +337,7 @@ grid_collect_history(struct grid *gd)
 	 * Free the lines from 0 to ny then move the remaining lines over
 	 * them.
 	 */
-	grid_free_lines(gd, 0, ny);
-	memmove(&gd->linedata[0], &gd->linedata[ny],
-	    (gd->hsize + gd->sy - ny) * (sizeof *gd->linedata));
+	grid_trim_history(gd, ny);
 
 	gd->hsize -= ny;
 	if (gd->hscrolled > gd->hsize)
@@ -337,9 +367,7 @@ grid_scroll_history(struct grid *gd, u_int bg)
 void
 grid_clear_history(struct grid *gd)
 {
-	grid_free_lines(gd, 0, gd->hsize);
-	memmove(&gd->linedata[0], &gd->linedata[gd->hsize],
-	    gd->sy * (sizeof *gd->linedata));
+	grid_trim_history(gd, gd->hsize);
 
 	gd->hscrolled = 0;
 	gd->hsize = 0;
@@ -410,7 +438,7 @@ static void
 grid_empty_line(struct grid *gd, u_int py, u_int bg)
 {
 	memset(&gd->linedata[py], 0, sizeof gd->linedata[py]);
-	if (bg != 8)
+	if (!COLOUR_DEFAULT(bg))
 		grid_expand_line(gd, py, gd->sx, bg);
 }
 
@@ -418,25 +446,16 @@ grid_empty_line(struct grid *gd, u_int py, u_int bg)
 const struct grid_line *
 grid_peek_line(struct grid *gd, u_int py)
 {
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return (NULL);
 	return (&gd->linedata[py]);
 }
 
-/* Get cell for reading. */
-void
-grid_get_cell(struct grid *gd, u_int px, u_int py, struct grid_cell *gc)
+/* Get cell from line. */
+static void
+grid_get_cell1(struct grid_line *gl, u_int px, struct grid_cell *gc)
 {
-	struct grid_line	*gl;
-	struct grid_cell_entry	*gce;
-
-	if (grid_check_y(gd, py) != 0 || px >= gd->linedata[py].cellsize) {
-		memcpy(gc, &grid_default_cell, sizeof *gc);
-		return;
-	}
-
-	gl = &gd->linedata[py];
-	gce = &gl->celldata[px];
+	struct grid_cell_entry	*gce = &gl->celldata[px];
 
 	if (gce->flags & GRID_FLAG_EXTENDED) {
 		if (gce->offset >= gl->extdsize)
@@ -457,6 +476,17 @@ grid_get_cell(struct grid *gd, u_int px, u_int py, struct grid_cell *gc)
 	utf8_set(&gc->data, gce->data.data);
 }
 
+/* Get cell for reading. */
+void
+grid_get_cell(struct grid *gd, u_int px, u_int py, struct grid_cell *gc)
+{
+	if (grid_check_y(gd, __func__, py) != 0 ||
+	    px >= gd->linedata[py].cellsize)
+		memcpy(gc, &grid_default_cell, sizeof *gc);
+	else
+		grid_get_cell1(&gd->linedata[py], px, gc);
+}
+
 /* Set cell at relative position. */
 void
 grid_set_cell(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc)
@@ -464,7 +494,7 @@ grid_set_cell(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc)
 	struct grid_line	*gl;
 	struct grid_cell_entry	*gce;
 
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return;
 
 	grid_expand_line(gd, py, px + 1, 8);
@@ -490,7 +520,7 @@ grid_set_cells(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc,
 	struct grid_cell	*gcp;
 	u_int			 i;
 
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return;
 
 	grid_expand_line(gd, py, px + slen, 8);
@@ -513,7 +543,8 @@ grid_set_cells(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc,
 void
 grid_clear(struct grid *gd, u_int px, u_int py, u_int nx, u_int ny, u_int bg)
 {
-	u_int	xx, yy;
+	struct grid_line	*gl;
+	u_int			 xx, yy;
 
 	if (nx == 0 || ny == 0)
 		return;
@@ -523,18 +554,19 @@ grid_clear(struct grid *gd, u_int px, u_int py, u_int nx, u_int ny, u_int bg)
 		return;
 	}
 
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return;
-	if (grid_check_y(gd, py + ny - 1) != 0)
+	if (grid_check_y(gd, __func__, py + ny - 1) != 0)
 		return;
 
 	for (yy = py; yy < py + ny; yy++) {
-		if (px + nx >= gd->sx && px < gd->linedata[yy].cellused)
-			gd->linedata[yy].cellused = px;
-		if (px > gd->linedata[yy].cellsize && bg == 8)
+		gl = &gd->linedata[yy];
+		if (px + nx >= gd->sx && px < gl->cellused)
+			gl->cellused = px;
+		if (px > gl->cellsize && COLOUR_DEFAULT(bg))
 			continue;
-		if (px + nx >= gd->linedata[yy].cellsize && bg == 8) {
-			gd->linedata[yy].cellsize = px;
+		if (px + nx >= gl->cellsize && COLOUR_DEFAULT(bg)) {
+			gl->cellsize = px;
 			continue;
 		}
 		grid_expand_line(gd, yy, px + nx, 8); /* default bg first */
@@ -552,9 +584,9 @@ grid_clear_lines(struct grid *gd, u_int py, u_int ny, u_int bg)
 	if (ny == 0)
 		return;
 
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return;
-	if (grid_check_y(gd, py + ny - 1) != 0)
+	if (grid_check_y(gd, __func__, py + ny - 1) != 0)
 		return;
 
 	for (yy = py; yy < py + ny; yy++) {
@@ -572,13 +604,13 @@ grid_move_lines(struct grid *gd, u_int dy, u_int py, u_int ny, u_int bg)
 	if (ny == 0 || py == dy)
 		return;
 
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return;
-	if (grid_check_y(gd, py + ny - 1) != 0)
+	if (grid_check_y(gd, __func__, py + ny - 1) != 0)
 		return;
-	if (grid_check_y(gd, dy) != 0)
+	if (grid_check_y(gd, __func__, dy) != 0)
 		return;
-	if (grid_check_y(gd, dy + ny - 1) != 0)
+	if (grid_check_y(gd, __func__, dy + ny - 1) != 0)
 		return;
 
 	/* Free any lines which are being replaced. */
@@ -612,7 +644,7 @@ grid_move_cells(struct grid *gd, u_int dx, u_int px, u_int py, u_int nx,
 	if (nx == 0 || px == dx)
 		return;
 
-	if (grid_check_y(gd, py) != 0)
+	if (grid_check_y(gd, __func__, py) != 0)
 		return;
 	gl = &gd->linedata[py];
 
@@ -753,7 +785,11 @@ grid_string_cells_code(const struct grid_cell *lastgc,
 		{ GRID_ATTR_BLINK, 5 },
 		{ GRID_ATTR_REVERSE, 7 },
 		{ GRID_ATTR_HIDDEN, 8 },
-		{ GRID_ATTR_STRIKETHROUGH, 9 }
+		{ GRID_ATTR_STRIKETHROUGH, 9 },
+		{ GRID_ATTR_UNDERSCORE_2, 42 },
+		{ GRID_ATTR_UNDERSCORE_3, 43 },
+		{ GRID_ATTR_UNDERSCORE_4, 44 },
+		{ GRID_ATTR_UNDERSCORE_5, 45 },
 	};
 	n = 0;
 
@@ -779,11 +815,15 @@ grid_string_cells_code(const struct grid_cell *lastgc,
 		else
 			strlcat(buf, "\033[", len);
 		for (i = 0; i < n; i++) {
-			if (i + 1 < n)
-				xsnprintf(tmp, sizeof tmp, "%d;", s[i]);
-			else
+			if (s[i] < 10)
 				xsnprintf(tmp, sizeof tmp, "%d", s[i]);
+			else {
+				xsnprintf(tmp, sizeof tmp, "%d:%d", s[i] / 10,
+				    s[i] % 10);
+			}
 			strlcat(buf, tmp, len);
+			if (i + 1 < n)
+				strlcat(buf, ";", len);
 		}
 		strlcat(buf, "m", len);
 	}
@@ -953,164 +993,359 @@ grid_duplicate_lines(struct grid *dst, u_int dy, struct grid *src, u_int sy,
 	}
 }
 
-/* Copy a section of a line. */
+/* Mark line as dead. */
 static void
-grid_reflow_copy(struct grid_line *dst_gl, u_int to, struct grid_line *src_gl,
-    u_int from, u_int to_copy)
+grid_reflow_dead(struct grid_line *gl)
 {
-	struct grid_cell_entry	*gce;
-	u_int			 i, was;
+	memset(gl, 0, sizeof *gl);
+	gl->flags = GRID_LINE_DEAD;
+}
 
-	memcpy(&dst_gl->celldata[to], &src_gl->celldata[from],
-	    to_copy * sizeof *dst_gl->celldata);
+/* Add lines, return the first new one. */
+static struct grid_line *
+grid_reflow_add(struct grid *gd, u_int n)
+{
+	struct grid_line	*gl;
+	u_int			 sy = gd->sy + n;
 
-	for (i = to; i < to + to_copy; i++) {
-		gce = &dst_gl->celldata[i];
-		if (~gce->flags & GRID_FLAG_EXTENDED)
+	gd->linedata = xreallocarray(gd->linedata, sy, sizeof *gd->linedata);
+	gl = &gd->linedata[gd->sy];
+	memset(gl, 0, n * (sizeof *gl));
+	gd->sy = sy;
+	return (gl);
+}
+
+/* Move a line across. */
+static struct grid_line *
+grid_reflow_move(struct grid *gd, struct grid_line *from)
+{
+	struct grid_line	*to;
+
+	to = grid_reflow_add(gd, 1);
+	memcpy(to, from, sizeof *to);
+	grid_reflow_dead(from);
+	return (to);
+}
+
+/* Join line below onto this one. */
+static void
+grid_reflow_join(struct grid *target, struct grid *gd, u_int sx, u_int yy,
+    u_int width, int already)
+{
+	struct grid_line	*gl, *from = NULL;
+	struct grid_cell	 gc;
+	u_int			 lines, left, i, to, line, want = 0;
+	u_int			 at;
+	int			 wrapped = 1;
+
+	/*
+	 * Add a new target line.
+	 */
+	if (!already) {
+		to = target->sy;
+		gl = grid_reflow_move(target, &gd->linedata[yy]);
+	} else {
+		to = target->sy - 1;
+		gl = &target->linedata[to];
+	}
+	at = gl->cellused;
+
+	/*
+	 * Loop until no more to consume or the target line is full.
+	 */
+	lines = 0;
+	for (;;) {
+		/*
+		 * If this is now the last line, there is nothing more to be
+		 * done.
+		 */
+		if (yy + 1 + lines == gd->hsize + gd->sy)
+			break;
+		line = yy + 1 + lines;
+
+		/* If the next line is empty, skip it. */
+		if (~gd->linedata[line].flags & GRID_LINE_WRAPPED)
+			wrapped = 0;
+		if (gd->linedata[line].cellused == 0) {
+			if (!wrapped)
+				break;
+			lines++;
 			continue;
-		was = gce->offset;
-
-		dst_gl->extddata = xreallocarray(dst_gl->extddata,
-		    dst_gl->extdsize + 1, sizeof *dst_gl->extddata);
-		gce->offset = dst_gl->extdsize++;
-		memcpy(&dst_gl->extddata[gce->offset], &src_gl->extddata[was],
-		    sizeof *dst_gl->extddata);
-	}
-}
-
-/* Join line data. */
-static void
-grid_reflow_join(struct grid *dst, u_int *py, struct grid_line *src_gl,
-    u_int new_x)
-{
-	struct grid_line	*dst_gl = &dst->linedata[(*py) - 1];
-	u_int			 left, to_copy, ox, nx;
-
-	/* How much is left on the old line? */
-	left = new_x - dst_gl->cellused;
-
-	/* Work out how much to append. */
-	to_copy = src_gl->cellused;
-	if (to_copy > left)
-		to_copy = left;
-	ox = dst_gl->cellused;
-	nx = ox + to_copy;
-
-	/* Resize the destination line. */
-	dst_gl->celldata = xreallocarray(dst_gl->celldata, nx,
-	    sizeof *dst_gl->celldata);
-	dst_gl->cellsize = dst_gl->cellused = nx;
-
-	/* Append as much as possible. */
-	grid_reflow_copy(dst_gl, ox, src_gl, 0, to_copy);
-
-	/* If there is any left in the source, split it. */
-	if (src_gl->cellused > to_copy) {
-		dst_gl->flags |= GRID_LINE_WRAPPED;
-
-		src_gl->cellused -= to_copy;
-		grid_reflow_split(dst, py, src_gl, new_x, to_copy);
-	}
-}
-
-/* Split line data. */
-static void
-grid_reflow_split(struct grid *dst, u_int *py, struct grid_line *src_gl,
-    u_int new_x, u_int offset)
-{
-	struct grid_line	*dst_gl = NULL;
-	u_int			 to_copy;
-
-	/* Loop and copy sections of the source line. */
-	while (src_gl->cellused > 0) {
-		/* Create new line. */
-		if (*py >= dst->hsize + dst->sy)
-			grid_scroll_history(dst, 8);
-		dst_gl = &dst->linedata[*py];
-		(*py)++;
-
-		/* How much should we copy? */
-		to_copy = new_x;
-		if (to_copy > src_gl->cellused)
-			to_copy = src_gl->cellused;
-
-		/* Expand destination line. */
-		dst_gl->celldata = xreallocarray(NULL, to_copy,
-		    sizeof *dst_gl->celldata);
-		dst_gl->cellsize = dst_gl->cellused = to_copy;
-		dst_gl->flags |= GRID_LINE_WRAPPED;
-
-		/* Copy the data. */
-		grid_reflow_copy(dst_gl, 0, src_gl, offset, to_copy);
-
-		/* Move offset and reduce old line size. */
-		offset += to_copy;
-		src_gl->cellused -= to_copy;
-	}
-
-	/* Last line is not wrapped. */
-	if (dst_gl != NULL)
-		dst_gl->flags &= ~GRID_LINE_WRAPPED;
-}
-
-/* Move line data. */
-static void
-grid_reflow_move(struct grid *dst, u_int *py, struct grid_line *src_gl)
-{
-	struct grid_line	*dst_gl;
-
-	/* Create new line. */
-	if (*py >= dst->hsize + dst->sy)
-		grid_scroll_history(dst, 8);
-	dst_gl = &dst->linedata[*py];
-	(*py)++;
-
-	/* Copy the old line. */
-	memcpy(dst_gl, src_gl, sizeof *dst_gl);
-	dst_gl->flags &= ~GRID_LINE_WRAPPED;
-
-	/* Clear old line. */
-	src_gl->celldata = NULL;
-	src_gl->extddata = NULL;
-}
-
-/*
- * Reflow lines from src grid into dst grid of width new_x. Returns number of
- * lines fewer in the visible area. The source grid is destroyed.
- */
-u_int
-grid_reflow(struct grid *dst, struct grid *src, u_int new_x)
-{
-	u_int			 py, sy, line;
-	int			 previous_wrapped;
-	struct grid_line	*src_gl;
-
-	py = 0;
-	sy = src->sy;
-
-	previous_wrapped = 0;
-	for (line = 0; line < sy + src->hsize; line++) {
-		src_gl = src->linedata + line;
-		if (!previous_wrapped) {
-			/* Wasn't wrapped. If smaller, move to destination. */
-			if (src_gl->cellused <= new_x)
-				grid_reflow_move(dst, &py, src_gl);
-			else
-				grid_reflow_split(dst, &py, src_gl, new_x, 0);
-		} else {
-			/* Previous was wrapped. Try to join. */
-			grid_reflow_join(dst, &py, src_gl, new_x);
 		}
-		previous_wrapped = (src_gl->flags & GRID_LINE_WRAPPED);
 
-		/* This is where we started scrolling. */
-		if (line == sy + src->hsize - src->hscrolled - 1)
-			dst->hscrolled = 0;
+		/*
+		 * Is the destination line now full? Copy the first character
+		 * separately because we need to leave "from" set to the last
+		 * line if this line is full.
+		 */
+		grid_get_cell1(&gd->linedata[line], 0, &gc);
+		if (width + gc.data.width > sx)
+			break;
+		width += gc.data.width;
+		grid_set_cell(target, at, to, &gc);
+		at++;
+
+		/* Join as much more as possible onto the current line. */
+		from = &gd->linedata[line];
+		for (want = 1; want < from->cellused; want++) {
+			grid_get_cell1(from, want, &gc);
+			if (width + gc.data.width > sx)
+				break;
+			width += gc.data.width;
+
+			grid_set_cell(target, at, to, &gc);
+			at++;
+		}
+		lines++;
+
+		/*
+		 * If this line wasn't wrapped or we didn't consume the entire
+		 * line, don't try to join any further lines.
+		 */
+		if (!wrapped || want != from->cellused || width == sx)
+			break;
+	}
+	if (lines == 0)
+		return;
+
+	/*
+	 * If we didn't consume the entire final line, then remove what we did
+	 * consume. If we consumed the entire line and it wasn't wrapped,
+	 * remove the wrap flag from this line.
+	 */
+	left = from->cellused - want;
+	if (left != 0) {
+		grid_move_cells(gd, 0, want, yy + lines, left, 8);
+		from->cellsize = from->cellused = left;
+		lines--;
+	} else if (!wrapped)
+		gl->flags &= ~GRID_LINE_WRAPPED;
+
+	/* Remove the lines that were completely consumed. */
+	for (i = yy + 1; i < yy + 1 + lines; i++) {
+		free(gd->linedata[i].celldata);
+		free(gd->linedata[i].extddata);
+		grid_reflow_dead(&gd->linedata[i]);
 	}
 
-	grid_destroy(src);
-
-	if (py > sy)
-		return (0);
-	return (sy - py);
+	/* Adjust scroll position. */
+	if (gd->hscrolled > to + lines)
+		gd->hscrolled -= lines;
+	else if (gd->hscrolled > to)
+		gd->hscrolled = to;
+}
+
+/* Split this line into several new ones */
+static void
+grid_reflow_split(struct grid *target, struct grid *gd, u_int sx, u_int yy,
+    u_int at)
+{
+	struct grid_line	*gl = &gd->linedata[yy], *first;
+	struct grid_cell	 gc;
+	u_int			 line, lines, width, i, xx;
+	u_int			 used = gl->cellused;
+	int			 flags = gl->flags;
+
+	/* How many lines do we need to insert? We know we need at least two. */
+	if (~gl->flags & GRID_LINE_EXTENDED)
+		lines = 1 + (gl->cellused - 1) / sx;
+	else {
+		lines = 2;
+		width = 0;
+		for (i = at; i < used; i++) {
+			grid_get_cell1(gl, i, &gc);
+			if (width + gc.data.width > sx) {
+				lines++;
+				width = 0;
+			}
+			width += gc.data.width;
+		}
+	}
+
+	/* Insert new lines. */
+	line = target->sy + 1;
+	first = grid_reflow_add(target, lines);
+
+	/* Copy sections from the original line. */
+	width = 0;
+	xx = 0;
+	for (i = at; i < used; i++) {
+		grid_get_cell1(gl, i, &gc);
+		if (width + gc.data.width > sx) {
+			target->linedata[line].flags |= GRID_LINE_WRAPPED;
+
+			line++;
+			width = 0;
+			xx = 0;
+		}
+		width += gc.data.width;
+		grid_set_cell(target, xx, line, &gc);
+		xx++;
+	}
+	if (flags & GRID_LINE_WRAPPED)
+		target->linedata[line].flags |= GRID_LINE_WRAPPED;
+
+	/* Move the remainder of the original line. */
+	gl->cellsize = gl->cellused = at;
+	gl->flags |= GRID_LINE_WRAPPED;
+	memcpy(first, gl, sizeof *first);
+	grid_reflow_dead(gl);
+
+	/* Adjust the scroll position. */
+	if (yy <= gd->hscrolled)
+		gd->hscrolled += lines - 1;
+
+	/*
+	 * If the original line had the wrapped flag and there is still space
+	 * in the last new line, try to join with the next lines.
+	 */
+	if (width < sx && (flags & GRID_LINE_WRAPPED))
+		grid_reflow_join(target, gd, sx, yy, width, 1);
+}
+
+/* Reflow lines on grid to new width. */
+void
+grid_reflow(struct grid *gd, u_int sx)
+{
+	struct grid		*target;
+	struct grid_line	*gl;
+	struct grid_cell	 gc;
+	u_int			 yy, width, i, at, first;
+
+	/*
+	 * Create a destination grid. This is just used as a container for the
+	 * line data and may not be fully valid.
+	 */
+	target = grid_create(gd->sx, 0, 0);
+
+	/*
+	 * Loop over each source line.
+	 */
+	for (yy = 0; yy < gd->hsize + gd->sy; yy++) {
+		gl = &gd->linedata[yy];
+		if (gl->flags & GRID_LINE_DEAD)
+			continue;
+
+		/*
+		 * Work out the width of this line. first is the width of the
+		 * first character, at is the point at which the available
+		 * width is hit, and width is the full line width.
+		 */
+		first = at = width = 0;
+		if (~gl->flags & GRID_LINE_EXTENDED) {
+			first = 1;
+			width = gl->cellused;
+			if (width > sx)
+				at = sx;
+			else
+				at = width;
+		} else {
+			for (i = 0; i < gl->cellused; i++) {
+				grid_get_cell1(gl, i, &gc);
+				if (i == 0)
+					first = gc.data.width;
+				if (at == 0 && width + gc.data.width > sx)
+					at = i;
+				width += gc.data.width;
+			}
+		}
+
+		/*
+		 * If the line is exactly right or the first character is wider
+		 * than the targe width, just move it across unchanged.
+		 */
+		if (width == sx || first > sx) {
+			grid_reflow_move(target, gl);
+			continue;
+		}
+
+		/*
+		 * If the line is too big, it needs to be split, whether or not
+		 * it was previously wrapped.
+		 */
+		if (width > sx) {
+			grid_reflow_split(target, gd, sx, yy, at);
+			continue;
+		}
+
+		/*
+		 * If the line was previously wrapped, join as much as possible
+		 * of the next line.
+		 */
+		if (gl->flags & GRID_LINE_WRAPPED)
+			grid_reflow_join(target, gd, sx, yy, width, 0);
+		else
+			grid_reflow_move(target, gl);
+	}
+
+	/*
+	 * Replace the old grid with the new.
+	 */
+	if (target->sy < gd->sy)
+		grid_reflow_add(target, gd->sy - target->sy);
+	gd->hsize = target->sy - gd->sy;
+	if (gd->hscrolled > gd->hsize)
+		gd->hscrolled = gd->hsize;
+	free(gd->linedata);
+	gd->linedata = target->linedata;
+	free(target);
+}
+
+/* Convert to position based on wrapped lines. */
+void
+grid_wrap_position(struct grid *gd, u_int px, u_int py, u_int *wx, u_int *wy)
+{
+	u_int	ax = 0, ay = 0, yy;
+
+	for (yy = 0; yy < py; yy++) {
+		if (gd->linedata[yy].flags & GRID_LINE_WRAPPED)
+			ax += gd->linedata[yy].cellused;
+		else {
+			ax = 0;
+			ay++;
+		}
+	}
+	if (px >= gd->linedata[yy].cellused)
+		ax = UINT_MAX;
+	else
+		ax += px;
+	*wx = ax;
+	*wy = ay;
+}
+
+/* Convert position based on wrapped lines back. */
+void
+grid_unwrap_position(struct grid *gd, u_int *px, u_int *py, u_int wx, u_int wy)
+{
+	u_int	yy, ax = 0, ay = 0;
+
+	for (yy = 0; yy < gd->hsize + gd->sy - 1; yy++) {
+		if (ay == wy)
+			break;
+		if (gd->linedata[yy].flags & GRID_LINE_WRAPPED)
+			ax += gd->linedata[yy].cellused;
+		else {
+			ax = 0;
+			ay++;
+		}
+	}
+
+	/*
+	 * yy is now 0 on the unwrapped line which contains wx. Walk forwards
+	 * until we find the end or the line now containing wx.
+	 */
+	if (wx == UINT_MAX) {
+		while (gd->linedata[yy].flags & GRID_LINE_WRAPPED)
+			yy++;
+		wx = gd->linedata[yy].cellused;
+	} else {
+		while (gd->linedata[yy].flags & GRID_LINE_WRAPPED) {
+			if (wx < gd->linedata[yy].cellused)
+				break;
+			wx -= gd->linedata[yy].cellused;
+			yy++;
+		}
+	}
+	*px = wx;
+	*py = yy;
 }

hooks.c

@@ -139,33 +139,6 @@ hooks_find(struct hooks *hooks, const char *name)
 	return (hook);
 }
 
-void
-hooks_run(struct hooks *hooks, struct client *c, struct cmd_find_state *fs,
-    const char *fmt, ...)
-{
-	struct hook		*hook;
-	va_list			 ap;
-	char			*name;
-	struct cmdq_item	*new_item;
-
-	va_start(ap, fmt);
-	xvasprintf(&name, fmt, ap);
-	va_end(ap);
-
-	hook = hooks_find(hooks, name);
-	if (hook == NULL) {
-		free(name);
-		return;
-	}
-	log_debug("running hook %s", name);
-
-	new_item = cmdq_get_command(hook->cmdlist, fs, NULL, CMDQ_NOHOOKS);
-	cmdq_format(new_item, "hook", "%s", name);
-	cmdq_append(c, new_item);
-
-	free(name);
-}
-
 void
 hooks_insert(struct hooks *hooks, struct cmdq_item *item,
     struct cmd_find_state *fs, const char *fmt, ...)

input-keys.c

@@ -247,10 +247,10 @@ input_key_mouse(struct window_pane *wp, struct mouse_event *m)
 
 	if ((mode & ALL_MOUSE_MODES) == 0)
 		return;
-	if (!window_pane_visible(wp))
-		return;
 	if (cmd_mouse_at(wp, m, &x, &y, 0) != 0)
 		return;
+	if (!window_pane_visible(wp))
+		return;
 
 	/* If this pane is not in button or all mode, discard motion events. */
 	if (MOUSE_DRAG(m->b) &&

job.c

@@ -36,14 +36,39 @@ static void	job_read_callback(struct bufferevent *, void *);
 static void	job_write_callback(struct bufferevent *, void *);
 static void	job_error_callback(struct bufferevent *, short, void *);
 
+/* A single job. */
+struct job {
+	enum {
+		JOB_RUNNING,
+		JOB_DEAD,
+		JOB_CLOSED
+	} state;
+
+	int			 flags;
+
+	char			*cmd;
+	pid_t			 pid;
+	int			 status;
+
+	int			 fd;
+	struct bufferevent	*event;
+
+	job_update_cb		 updatecb;
+	job_complete_cb		 completecb;
+	job_free_cb		 freecb;
+	void			*data;
+
+	LIST_ENTRY(job)		 entry;
+};
+
 /* All jobs list. */
-struct joblist	all_jobs = LIST_HEAD_INITIALIZER(all_jobs);
+static LIST_HEAD(joblist, job) all_jobs = LIST_HEAD_INITIALIZER(all_jobs);
 
 /* Start a job running, if it isn't already. */
 struct job *
 job_run(const char *cmd, struct session *s, const char *cwd,
     job_update_cb updatecb, job_complete_cb completecb, job_free_cb freecb,
-    void *data)
+    void *data, int flags)
 {
 	struct job	*job;
 	struct environ	*env;
@@ -54,6 +79,7 @@ job_run(const char *cmd, struct session *s, const char *cwd,
 
 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, out) != 0)
 		return (NULL);
+	log_debug("%s: cmd=%s, cwd=%s", __func__, cmd, cwd == NULL ? "" : cwd);
 
 	/*
 	 * Do not set TERM during .tmux.conf, it is nice to be able to use
@@ -110,6 +136,7 @@ job_run(const char *cmd, struct session *s, const char *cwd,
 
 	job = xmalloc(sizeof *job);
 	job->state = JOB_RUNNING;
+	job->flags = flags;
 
 	job->cmd = xstrdup(cmd);
 	job->pid = pid;
@@ -127,6 +154,8 @@ job_run(const char *cmd, struct session *s, const char *cwd,
 
 	job->event = bufferevent_new(job->fd, job_read_callback,
 	    job_write_callback, job_error_callback, job);
+	if (job->event == NULL)
+		fatalx("out of memory");
 	bufferevent_enable(job->event, EV_READ|EV_WRITE);
 
 	log_debug("run job %p: %s, pid %ld", job, job->cmd, (long) job->pid);
@@ -206,8 +235,16 @@ job_error_callback(__unused struct bufferevent *bufev, __unused short events,
 
 /* Job died (waitpid() returned its pid). */
 void
-job_died(struct job *job, int status)
+job_check_died(pid_t pid, int status)
 {
+	struct job	*job;
+
+	LIST_FOREACH(job, &all_jobs, entry) {
+		if (pid == job->pid)
+			break;
+	}
+	if (job == NULL)
+		return;
 	log_debug("job died %p: %s, pid %ld", job, job->cmd, (long) job->pid);
 
 	job->status = status;
@@ -221,3 +258,67 @@ job_died(struct job *job, int status)
 		job->state = JOB_DEAD;
 	}
 }
+
+/* Get job status. */
+int
+job_get_status(struct job *job)
+{
+	return (job->status);
+}
+
+/* Get job data. */
+void *
+job_get_data(struct job *job)
+{
+	return (job->data);
+}
+
+/* Get job event. */
+struct bufferevent *
+job_get_event(struct job *job)
+{
+	return (job->event);
+}
+
+/* Kill all jobs. */
+void
+job_kill_all(void)
+{
+	struct job	*job;
+
+	LIST_FOREACH(job, &all_jobs, entry) {
+		if (job->pid != -1)
+			kill(job->pid, SIGTERM);
+	}
+}
+
+/* Are any jobs still running? */
+int
+job_still_running(void)
+{
+	struct job	*job;
+
+	LIST_FOREACH(job, &all_jobs, entry) {
+		if ((~job->flags & JOB_NOWAIT) && job->state == JOB_RUNNING)
+			return (1);
+	}
+	return (0);
+}
+
+/* Print job summary. */
+void
+job_print_summary(struct cmdq_item *item, int blank)
+{
+	struct job	*job;
+	u_int		 n = 0;
+
+	LIST_FOREACH(job, &all_jobs, entry) {
+		if (blank) {
+			cmdq_print(item, "%s", "");
+			blank = 0;
+		}
+		cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]",
+		    n, job->cmd, job->fd, (long)job->pid, job->status);
+		n++;
+	}
+}

key-bindings.c

@@ -24,17 +24,19 @@
 
 #include "tmux.h"
 
-RB_GENERATE(key_bindings, key_binding, entry, key_bindings_cmp);
-RB_GENERATE(key_tables, key_table, entry, key_table_cmp);
-struct key_tables key_tables = RB_INITIALIZER(&key_tables);
+static int key_bindings_cmp(struct key_binding *, struct key_binding *);
+RB_GENERATE_STATIC(key_bindings, key_binding, entry, key_bindings_cmp);
+static int key_table_cmp(struct key_table *, struct key_table *);
+RB_GENERATE_STATIC(key_tables, key_table, entry, key_table_cmp);
+static struct key_tables key_tables = RB_INITIALIZER(&key_tables);
 
-int
-key_table_cmp(struct key_table *e1, struct key_table *e2)
+static int
+key_table_cmp(struct key_table *table1, struct key_table *table2)
 {
-	return (strcmp(e1->name, e2->name));
+	return (strcmp(table1->name, table2->name));
 }
 
-int
+static int
 key_bindings_cmp(struct key_binding *bd1, struct key_binding *bd2)
 {
 	if (bd1->key < bd2->key)
@@ -64,6 +66,18 @@ key_bindings_get_table(const char *name, int create)
 	return (table);
 }
 
+struct key_table *
+key_bindings_first_table(void)
+{
+	return (RB_MIN(key_tables, &key_tables));
+}
+
+struct key_table *
+key_bindings_next_table(struct key_table *table)
+{
+	return (RB_NEXT(key_tables, &key_tables, table));
+}
+
 void
 key_bindings_unref_table(struct key_table *table)
 {
@@ -83,6 +97,27 @@ key_bindings_unref_table(struct key_table *table)
 	free(table);
 }
 
+struct key_binding *
+key_bindings_get(struct key_table *table, key_code key)
+{
+	struct key_binding	bd;
+
+	bd.key = key;
+	return (RB_FIND(key_bindings, &table->key_bindings, &bd));
+}
+
+struct key_binding *
+key_bindings_first(struct key_table *table)
+{
+	return (RB_MIN(key_bindings, &table->key_bindings));
+}
+
+struct key_binding *
+key_bindings_next(__unused struct key_table *table, struct key_binding *bd)
+{
+	return (RB_NEXT(key_bindings, &table->key_bindings, bd));
+}
+
 void
 key_bindings_add(const char *name, key_code key, int repeat,
     struct cmd_list *cmdlist)
@@ -162,13 +197,13 @@ key_bindings_init(void)
 		"bind ! break-pane",
 		"bind '\"' split-window",
 		"bind '#' list-buffers",
-		"bind '$' command-prompt -I'#S' \"rename-session '%%'\"",
+		"bind '$' command-prompt -I'#S' \"rename-session -- '%%'\"",
 		"bind % split-window -h",
 		"bind & confirm-before -p\"kill-window #W? (y/n)\" kill-window",
 		"bind \"'\" command-prompt -pindex \"select-window -t ':%%'\"",
 		"bind ( switch-client -p",
 		"bind ) switch-client -n",
-		"bind , command-prompt -I'#W' \"rename-window '%%'\"",
+		"bind , command-prompt -I'#W' \"rename-window -- '%%'\"",
 		"bind - delete-buffer",
 		"bind . command-prompt \"move-window -t '%%'\"",
 		"bind 0 select-window -t:=0",
@@ -183,16 +218,17 @@ key_bindings_init(void)
 		"bind 9 select-window -t:=9",
 		"bind : command-prompt",
 		"bind \\; last-pane",
-		"bind = choose-buffer",
+		"bind = choose-buffer -Z",
 		"bind ? list-keys",
-		"bind D choose-client",
+		"bind D choose-client -Z",
+		"bind E select-layout -E",
 		"bind L switch-client -l",
 		"bind M select-pane -M",
 		"bind [ copy-mode",
 		"bind ] paste-buffer",
 		"bind c new-window",
 		"bind d detach-client",
-		"bind f command-prompt \"find-window '%%'\"",
+		"bind f command-prompt \"find-window -Z -- '%%'\"",
 		"bind i display-message",
 		"bind l last-window",
 		"bind m select-pane -m",
@@ -201,9 +237,9 @@ key_bindings_init(void)
 		"bind p previous-window",
 		"bind q display-panes",
 		"bind r refresh-client",
-		"bind s choose-tree -s",
+		"bind s choose-tree -Zs",
 		"bind t clock-mode",
-		"bind w choose-tree -w",
+		"bind w choose-tree -Zw",
 		"bind x confirm-before -p\"kill-pane #P? (y/n)\" kill-pane",
 		"bind z resize-pane -Z",
 		"bind { swap-pane -U",
@@ -222,6 +258,11 @@ key_bindings_init(void)
 		"bind M-n next-window -a",
 		"bind M-o rotate-window -D",
 		"bind M-p previous-window -a",
+		"bind -r S-Up refresh-client -U 10",
+		"bind -r S-Down refresh-client -D 10",
+		"bind -r S-Left refresh-client -L 10",
+		"bind -r S-Right refresh-client -R 10",
+		"bind -r DC refresh-client -c",
 		"bind -r M-Up resize-pane -U 5",
 		"bind -r M-Down resize-pane -D 5",
 		"bind -r M-Left resize-pane -L 5",

key-string.c

@@ -43,7 +43,9 @@ static const struct {
 	{ "F11",	KEYC_F11 },
 	{ "F12",	KEYC_F12 },
 	{ "IC",		KEYC_IC },
+	{ "Insert",     KEYC_IC },
 	{ "DC",		KEYC_DC },
+	{ "Delete",     KEYC_DC },
 	{ "Home",	KEYC_HOME },
 	{ "End",	KEYC_END },
 	{ "NPage",	KEYC_NPAGE },
@@ -166,9 +168,11 @@ key_string_lookup_string(const char *string)
 	enum utf8_state		 more;
 	wchar_t			 wc;
 
-	/* Is this no key? */
+	/* Is this no key or any key? */
 	if (strcasecmp(string, "None") == 0)
 		return (KEYC_NONE);
+	if (strcasecmp(string, "Any") == 0)
+		return (KEYC_ANY);
 
 	/* Is this a hexadecimal value? */
 	if (string[0] == '0' && string[1] == 'x') {
@@ -251,6 +255,8 @@ key_string_lookup_key(key_code key)
 	/* Handle special keys. */
 	if (key == KEYC_UNKNOWN)
 		return ("Unknown");
+	if (key == KEYC_ANY)
+		return ("Any");
 	if (key == KEYC_FOCUS_IN)
 		return ("FocusIn");
 	if (key == KEYC_FOCUS_OUT)
@@ -267,6 +273,10 @@ key_string_lookup_key(key_code key)
 		return ("MouseMovePane");
 	if (key == KEYC_MOUSEMOVE_STATUS)
 		return ("MouseMoveStatus");
+	if (key == KEYC_MOUSEMOVE_STATUS_LEFT)
+		return ("MouseMoveStatusLeft");
+	if (key == KEYC_MOUSEMOVE_STATUS_RIGHT)
+		return ("MouseMoveStatusRight");
 	if (key == KEYC_MOUSEMOVE_BORDER)
 		return ("MouseMoveBorder");
 	if (key >= KEYC_USER && key < KEYC_USER + KEYC_NUSER) {

layout-custom.c

@@ -167,7 +167,7 @@ layout_parse(struct window *w, const char *layout)
 
 	/* Update pane offsets and sizes. */
 	layout_fix_offsets(lc);
-	layout_fix_panes(w, lc->sx, lc->sy);
+	layout_fix_panes(w);
 
 	/* Then resize the layout back to the original window size. */
 	layout_resize(w, sx, sy);

layout-set.c

@@ -115,11 +115,11 @@ layout_set_previous(struct window *w)
 }
 
 static void
-layout_set_even_h(struct window *w)
+layout_set_even(struct window *w, enum layout_type type)
 {
 	struct window_pane	*wp;
 	struct layout_cell	*lc, *lcnew;
-	u_int			 i, n, width, xoff;
+	u_int			 n, sx, sy;
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
@@ -128,109 +128,64 @@ layout_set_even_h(struct window *w)
 	if (n <= 1)
 		return;
 
-	/* How many can we fit? */
-	width = (w->sx - (n - 1)) / n;
-	if (width < PANE_MINIMUM)
-		width = PANE_MINIMUM;
-
 	/* Free the old root and construct a new. */
 	layout_free(w);
 	lc = w->layout_root = layout_create_cell(NULL);
-	layout_set_size(lc, w->sx, w->sy, 0, 0);
-	layout_make_node(lc, LAYOUT_LEFTRIGHT);
+	if (type == LAYOUT_LEFTRIGHT) {
+		sx = (n * (PANE_MINIMUM + 1)) - 1;
+		if (sx < w->sx)
+			sx = w->sx;
+		sy = w->sy;
+	} else {
+		sy = (n * (PANE_MINIMUM + 1)) - 1;
+		if (sy < w->sy)
+			sy = w->sy;
+		sx = w->sx;
+	}
+	layout_set_size(lc, sx, sy, 0, 0);
+	layout_make_node(lc, type);
 
 	/* Build new leaf cells. */
-	i = xoff = 0;
 	TAILQ_FOREACH(wp, &w->panes, entry) {
-		/* Create child cell. */
 		lcnew = layout_create_cell(lc);
-		layout_set_size(lcnew, width, w->sy, xoff, 0);
 		layout_make_leaf(lcnew, wp);
+		lcnew->sx = w->sx;
+		lcnew->sy = w->sy;
 		TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
-
-		i++;
-		xoff += width + 1;
 	}
 
-	/* Allocate any remaining space. */
-	if (w->sx > xoff - 1) {
-		lc = TAILQ_LAST(&lc->cells, layout_cells);
-		layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT,
-		    w->sx - (xoff - 1));
-	}
+	/* Spread out cells. */
+	layout_spread_cell(w, lc);
 
 	/* Fix cell offsets. */
 	layout_fix_offsets(lc);
-	layout_fix_panes(w, w->sx, w->sy);
+	layout_fix_panes(w);
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
+	window_resize(w, lc->sx, lc->sy);
 	notify_window("window-layout-changed", w);
 	server_redraw_window(w);
 }
 
+static void
+layout_set_even_h(struct window *w)
+{
+	layout_set_even(w, LAYOUT_LEFTRIGHT);
+}
+
 static void
 layout_set_even_v(struct window *w)
 {
-	struct window_pane	*wp;
-	struct layout_cell	*lc, *lcnew;
-	u_int			 i, n, height, yoff;
-
-	layout_print_cell(w->layout_root, __func__, 1);
-
-	/* Get number of panes. */
-	n = window_count_panes(w);
-	if (n <= 1)
-		return;
-
-	/* How many can we fit? */
-	height = (w->sy - (n - 1)) / n;
-	if (height < PANE_MINIMUM)
-		height = PANE_MINIMUM;
-
-	/* Free the old root and construct a new. */
-	layout_free(w);
-	lc = w->layout_root = layout_create_cell(NULL);
-	layout_set_size(lc, w->sx, w->sy, 0, 0);
-	layout_make_node(lc, LAYOUT_TOPBOTTOM);
-
-	/* Build new leaf cells. */
-	i = yoff = 0;
-	TAILQ_FOREACH(wp, &w->panes, entry) {
-		/* Create child cell. */
-		lcnew = layout_create_cell(lc);
-		layout_set_size(lcnew, w->sx, height, 0, yoff);
-		layout_make_leaf(lcnew, wp);
-		TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
-
-		i++;
-		yoff += height + 1;
-	}
-
-	/* Allocate any remaining space. */
-	if (w->sy > yoff - 1) {
-		lc = TAILQ_LAST(&lc->cells, layout_cells);
-		layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM,
-		    w->sy - (yoff - 1));
-	}
-
-	/* Fix cell offsets. */
-	layout_fix_offsets(lc);
-	layout_fix_panes(w, w->sx, w->sy);
-
-	layout_print_cell(w->layout_root, __func__, 1);
-
-	notify_window("window-layout-changed", w);
-	server_redraw_window(w);
+	layout_set_even(w, LAYOUT_TOPBOTTOM);
 }
 
 static void
 layout_set_main_h(struct window *w)
 {
 	struct window_pane	*wp;
-	struct layout_cell	*lc, *lcmain, *lcrow, *lcchild;
-	u_int			 n, mainheight, otherheight, width, height;
-	u_int			 used, i, j, columns, rows, totalrows;
+	struct layout_cell	*lc, *lcmain, *lcother, *lcchild;
+	u_int			 n, mainh, otherh, sx;
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
@@ -240,110 +195,65 @@ layout_set_main_h(struct window *w)
 		return;
 	n--;	/* take off main pane */
 
-	/* How many rows and columns will be needed, not counting main? */
-	columns = (w->sx + 1) / (PANE_MINIMUM + 1);	/* maximum columns */
-	if (columns == 0)
-		columns = 1;
-	rows = 1 + (n - 1) / columns;
-	columns = 1 + (n - 1) / rows;
-	width = (w->sx - (n - 1)) / columns;
-
-	/* Get the main pane height and add one for separator line. */
-	mainheight = options_get_number(w->options, "main-pane-height") + 1;
-
-	/* Get the optional other pane height and add one for separator line. */
-	otherheight = options_get_number(w->options, "other-pane-height") + 1;
-
-	/*
-	 * If an other pane height was specified, honour it so long as it
-	 * doesn't shrink the main height to less than the main-pane-height
-	 */
-	if (otherheight > 1 && w->sy - otherheight > mainheight)
-		mainheight = w->sy - otherheight;
-	if (mainheight < PANE_MINIMUM + 1)
-		mainheight = PANE_MINIMUM + 1;
-
-	/* Try and make everything fit. */
-	totalrows = rows * (PANE_MINIMUM + 1) - 1;
-	if (mainheight + totalrows > w->sy) {
-		if (totalrows + PANE_MINIMUM + 1 > w->sy)
-			mainheight = PANE_MINIMUM + 2;
+	/* Get the main pane height and work out the other pane height. */
+	mainh = options_get_number(w->options, "main-pane-height");
+	if (mainh + PANE_MINIMUM + 1 >= w->sy) {
+		if (w->sy <= PANE_MINIMUM + 1 + PANE_MINIMUM)
+			mainh = PANE_MINIMUM;
 		else
-			mainheight = w->sy - totalrows;
-		height = PANE_MINIMUM;
-	} else
-		height = (w->sy - mainheight - (rows - 1)) / rows;
+			mainh = w->sy - (PANE_MINIMUM + 1);
+		otherh = PANE_MINIMUM;
+	} else {
+		otherh = options_get_number(w->options, "other-pane-height");
+		if (otherh == 0)
+			otherh = w->sy - mainh;
+		else if (otherh > w->sy || w->sy - otherh < mainh)
+			otherh = w->sy - mainh;
+		else
+			mainh = w->sy - otherh;
+	}
+
+	/* Work out what height is needed. */
+	sx = (n * (PANE_MINIMUM + 1)) - 1;
+	if (sx < w->sx)
+		sx = w->sx;
 
 	/* Free old tree and create a new root. */
 	layout_free(w);
 	lc = w->layout_root = layout_create_cell(NULL);
-	layout_set_size(lc, w->sx, mainheight + rows * (height + 1) - 1, 0, 0);
+	layout_set_size(lc, sx, mainh + otherh + 1, 0, 0);
 	layout_make_node(lc, LAYOUT_TOPBOTTOM);
 
 	/* Create the main pane. */
 	lcmain = layout_create_cell(lc);
-	layout_set_size(lcmain, w->sx, mainheight - 1, 0, 0);
+	layout_set_size(lcmain, sx, mainh, 0, 0);
 	layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
 	TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
 
-	/* Create a grid of the remaining cells. */
-	wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
-	for (j = 0; j < rows; j++) {
-		/* If this is the last cell, all done. */
-		if (wp == NULL)
-			break;
+	/* Create the other pane. */
+	lcother = layout_create_cell(lc);
+	layout_set_size(lcother, sx, otherh, 0, 0);
+	layout_make_node(lcother, LAYOUT_LEFTRIGHT);
+	TAILQ_INSERT_TAIL(&lc->cells, lcother, entry);
 
-		/* Create the new row. */
-		lcrow = layout_create_cell(lc);
-		layout_set_size(lcrow, w->sx, height, 0, 0);
-		TAILQ_INSERT_TAIL(&lc->cells, lcrow, entry);
-
-		/* If only one column, just use the row directly. */
-		if (columns == 1) {
-			layout_make_leaf(lcrow, wp);
-			wp = TAILQ_NEXT(wp, entry);
+	/* Add the remaining panes as children. */
+	TAILQ_FOREACH(wp, &w->panes, entry) {
+		if (wp == TAILQ_FIRST(&w->panes))
 			continue;
-		}
-
-		/* Add in the columns. */
-		layout_make_node(lcrow, LAYOUT_LEFTRIGHT);
-		for (i = 0; i < columns; i++) {
-			/* Create and add a pane cell. */
-			lcchild = layout_create_cell(lcrow);
-			layout_set_size(lcchild, width, height, 0, 0);
-			layout_make_leaf(lcchild, wp);
-			TAILQ_INSERT_TAIL(&lcrow->cells, lcchild, entry);
-
-			/* Move to the next cell. */
-			if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
-				break;
-		}
-
-		/* Adjust the row to fit the full width if necessary. */
-		if (i == columns)
-			i--;
-		used = ((i + 1) * (width + 1)) - 1;
-		if (w->sx <= used)
-			continue;
-		lcchild = TAILQ_LAST(&lcrow->cells, layout_cells);
-		layout_resize_adjust(w, lcchild, LAYOUT_LEFTRIGHT,
-		    w->sx - used);
-	}
-
-	/* Adjust the last row height to fit if necessary. */
-	used = mainheight + (rows * height) + rows - 1;
-	if (w->sy > used) {
-		lcrow = TAILQ_LAST(&lc->cells, layout_cells);
-		layout_resize_adjust(w, lcrow, LAYOUT_TOPBOTTOM,
-		    w->sy - used);
+		lcchild = layout_create_cell(lc);
+		layout_set_size(lcchild, PANE_MINIMUM, otherh, 0, 0);
+		layout_make_leaf(lcchild, wp);
+		TAILQ_INSERT_TAIL(&lcother->cells, lcchild, entry);
 	}
+	layout_spread_cell(w, lcother);
 
 	/* Fix cell offsets. */
 	layout_fix_offsets(lc);
-	layout_fix_panes(w, w->sx, w->sy);
+	layout_fix_panes(w);
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
+	window_resize(w, lc->sx, lc->sy);
 	notify_window("window-layout-changed", w);
 	server_redraw_window(w);
 }
@@ -352,9 +262,8 @@ static void
 layout_set_main_v(struct window *w)
 {
 	struct window_pane	*wp;
-	struct layout_cell	*lc, *lcmain, *lccolumn, *lcchild;
-	u_int			 n, mainwidth, otherwidth, width, height;
-	u_int			 used, i, j, columns, rows, totalcolumns;
+	struct layout_cell	*lc, *lcmain, *lcother, *lcchild;
+	u_int			 n, mainw, otherw, sy;
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
@@ -364,110 +273,65 @@ layout_set_main_v(struct window *w)
 		return;
 	n--;	/* take off main pane */
 
-	/* How many rows and columns will be needed, not counting main? */
-	rows = (w->sy + 1) / (PANE_MINIMUM + 1);	/* maximum rows */
-	if (rows == 0)
-		rows = 1;
-	columns = 1 + (n - 1) / rows;
-	rows = 1 + (n - 1) / columns;
-	height = (w->sy - (n - 1)) / rows;
-
-	/* Get the main pane width and add one for separator line. */
-	mainwidth = options_get_number(w->options, "main-pane-width") + 1;
-
-	/* Get the optional other pane width and add one for separator line. */
-	otherwidth = options_get_number(w->options, "other-pane-width") + 1;
-
-	/*
-	 * If an other pane width was specified, honour it so long as it
-	 * doesn't shrink the main width to less than the main-pane-width
-	 */
-	if (otherwidth > 1 && w->sx - otherwidth > mainwidth)
-		mainwidth = w->sx - otherwidth;
-	if (mainwidth < PANE_MINIMUM + 1)
-		mainwidth = PANE_MINIMUM + 1;
-
-	/* Try and make everything fit. */
-	totalcolumns = columns * (PANE_MINIMUM + 1) - 1;
-	if (mainwidth + totalcolumns > w->sx) {
-		if (totalcolumns + PANE_MINIMUM + 1 > w->sx)
-			mainwidth = PANE_MINIMUM + 2;
+	/* Get the main pane width and work out the other pane width. */
+	mainw = options_get_number(w->options, "main-pane-width");
+	if (mainw + PANE_MINIMUM + 1 >= w->sx) {
+		if (w->sx <= PANE_MINIMUM + 1 + PANE_MINIMUM)
+			mainw = PANE_MINIMUM;
 		else
-			mainwidth = w->sx - totalcolumns;
-		width = PANE_MINIMUM;
-	} else
-		width = (w->sx - mainwidth - (columns - 1)) / columns;
+			mainw = w->sx - (PANE_MINIMUM + 1);
+		otherw = PANE_MINIMUM;
+	} else {
+		otherw = options_get_number(w->options, "other-pane-width");
+		if (otherw == 0)
+			otherw = w->sx - mainw;
+		else if (otherw > w->sx || w->sx - otherw < mainw)
+			otherw = w->sx - mainw;
+		else
+			mainw = w->sx - otherw;
+	}
+
+	/* Work out what height is needed. */
+	sy = (n * (PANE_MINIMUM + 1)) - 1;
+	if (sy < w->sy)
+		sy = w->sy;
 
 	/* Free old tree and create a new root. */
 	layout_free(w);
 	lc = w->layout_root = layout_create_cell(NULL);
-	layout_set_size(lc, mainwidth + columns * (width + 1) - 1, w->sy, 0, 0);
+	layout_set_size(lc, mainw + otherw + 1, sy, 0, 0);
 	layout_make_node(lc, LAYOUT_LEFTRIGHT);
 
 	/* Create the main pane. */
 	lcmain = layout_create_cell(lc);
-	layout_set_size(lcmain, mainwidth - 1, w->sy, 0, 0);
+	layout_set_size(lcmain, mainw, sy, 0, 0);
 	layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
 	TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
 
-	/* Create a grid of the remaining cells. */
-	wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
-	for (j = 0; j < columns; j++) {
-		/* If this is the last cell, all done. */
-		if (wp == NULL)
-			break;
+	/* Create the other pane. */
+	lcother = layout_create_cell(lc);
+	layout_set_size(lcother, otherw, sy, 0, 0);
+	layout_make_node(lcother, LAYOUT_TOPBOTTOM);
+	TAILQ_INSERT_TAIL(&lc->cells, lcother, entry);
 
-		/* Create the new column. */
-		lccolumn = layout_create_cell(lc);
-		layout_set_size(lccolumn, width, w->sy, 0, 0);
-		TAILQ_INSERT_TAIL(&lc->cells, lccolumn, entry);
-
-		/* If only one row, just use the row directly. */
-		if (rows == 1) {
-			layout_make_leaf(lccolumn, wp);
-			wp = TAILQ_NEXT(wp, entry);
+	/* Add the remaining panes as children. */
+	TAILQ_FOREACH(wp, &w->panes, entry) {
+		if (wp == TAILQ_FIRST(&w->panes))
 			continue;
-		}
-
-		/* Add in the rows. */
-		layout_make_node(lccolumn, LAYOUT_TOPBOTTOM);
-		for (i = 0; i < rows; i++) {
-			/* Create and add a pane cell. */
-			lcchild = layout_create_cell(lccolumn);
-			layout_set_size(lcchild, width, height, 0, 0);
-			layout_make_leaf(lcchild, wp);
-			TAILQ_INSERT_TAIL(&lccolumn->cells, lcchild, entry);
-
-			/* Move to the next cell. */
-			if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
-				break;
-		}
-
-		/* Adjust the column to fit the full height if necessary. */
-		if (i == rows)
-			i--;
-		used = ((i + 1) * (height + 1)) - 1;
-		if (w->sy <= used)
-			continue;
-		lcchild = TAILQ_LAST(&lccolumn->cells, layout_cells);
-		layout_resize_adjust(w, lcchild, LAYOUT_TOPBOTTOM,
-		    w->sy - used);
-	}
-
-	/* Adjust the last column width to fit if necessary. */
-	used = mainwidth + (columns * width) + columns - 1;
-	if (w->sx > used) {
-		lccolumn = TAILQ_LAST(&lc->cells, layout_cells);
-		layout_resize_adjust(w, lccolumn, LAYOUT_LEFTRIGHT,
-		    w->sx - used);
+		lcchild = layout_create_cell(lc);
+		layout_set_size(lcchild, otherw, PANE_MINIMUM, 0, 0);
+		layout_make_leaf(lcchild, wp);
+		TAILQ_INSERT_TAIL(&lcother->cells, lcchild, entry);
 	}
+	layout_spread_cell(w, lcother);
 
 	/* Fix cell offsets. */
 	layout_fix_offsets(lc);
-	layout_fix_panes(w, w->sx, w->sy);
+	layout_fix_panes(w);
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
+	window_resize(w, lc->sx, lc->sy);
 	notify_window("window-layout-changed", w);
 	server_redraw_window(w);
 }
@@ -477,7 +341,7 @@ layout_set_tiled(struct window *w)
 {
 	struct window_pane	*wp;
 	struct layout_cell	*lc, *lcrow, *lcchild;
-	u_int			 n, width, height, used;
+	u_int			 n, width, height, used, sx, sy;
 	u_int			 i, j, columns, rows;
 
 	layout_print_cell(w->layout_root, __func__, 1);
@@ -506,8 +370,13 @@ layout_set_tiled(struct window *w)
 	/* Free old tree and create a new root. */
 	layout_free(w);
 	lc = w->layout_root = layout_create_cell(NULL);
-	layout_set_size(lc, (width + 1) * columns - 1,
-	    (height + 1) * rows - 1, 0, 0);
+	sx = ((width + 1) * columns) - 1;
+	if (sx < w->sx)
+		sx = w->sx;
+	sy = ((height + 1) * rows) - 1;
+	if (sy < w->sy)
+		sy = w->sy;
+	layout_set_size(lc, sx, sy, 0, 0);
 	layout_make_node(lc, LAYOUT_TOPBOTTOM);
 
 	/* Create a grid of the cells. */
@@ -567,10 +436,11 @@ layout_set_tiled(struct window *w)
 
 	/* Fix cell offsets. */
 	layout_fix_offsets(lc);
-	layout_fix_panes(w, w->sx, w->sy);
+	layout_fix_panes(w);
 
 	layout_print_cell(w->layout_root, __func__, 1);
 
+	window_resize(w, lc->sx, lc->sy);
 	notify_window("window-layout-changed", w);
 	server_redraw_window(w);
 }

layout.c

@@ -97,9 +97,24 @@ void
 layout_print_cell(struct layout_cell *lc, const char *hdr, u_int n)
 {
 	struct layout_cell	*lcchild;
+	const char		*type;
 
-	log_debug("%s:%*s%p type %u [parent %p] wp=%p [%u,%u %ux%u]", hdr, n,
-	    " ", lc, lc->type, lc->parent, lc->wp, lc->xoff, lc->yoff, lc->sx,
+	switch (lc->type) {
+	case LAYOUT_LEFTRIGHT:
+		type = "LEFTRIGHT";
+		break;
+	case LAYOUT_TOPBOTTOM:
+		type = "TOPBOTTOM";
+		break;
+	case LAYOUT_WINDOWPANE:
+		type = "WINDOWPANE";
+		break;
+	default:
+		type = "UNKNOWN";
+		break;
+	}
+	log_debug("%s:%*s%p type %s [parent %p] wp=%p [%u,%u %ux%u]", hdr, n,
+	    " ", lc, type, lc->parent, lc->wp, lc->xoff, lc->yoff, lc->sx,
 	    lc->sy);
 	switch (lc->type) {
 	case LAYOUT_LEFTRIGHT:
@@ -112,6 +127,42 @@ layout_print_cell(struct layout_cell *lc, const char *hdr, u_int n)
 	}
 }
 
+struct layout_cell *
+layout_search_by_border(struct layout_cell *lc, u_int x, u_int y)
+{
+	struct layout_cell	*lcchild, *last = NULL;
+
+	TAILQ_FOREACH(lcchild, &lc->cells, entry) {
+		if (x >= lcchild->xoff && x < lcchild->xoff + lcchild->sx &&
+		    y >= lcchild->yoff && y < lcchild->yoff + lcchild->sy) {
+			/* Inside the cell - recurse. */
+			return (layout_search_by_border(lcchild, x, y));
+		}
+
+		if (last == NULL) {
+			last = lcchild;
+			continue;
+		}
+
+		switch (lc->type) {
+		case LAYOUT_LEFTRIGHT:
+			if (x < lcchild->xoff && x >= last->xoff + last->sx)
+				return (last);
+			break;
+		case LAYOUT_TOPBOTTOM:
+			if (y < lcchild->yoff && y >= last->yoff + last->sy)
+				return (last);
+			break;
+		case LAYOUT_WINDOWPANE:
+			break;
+		}
+
+		last = lcchild;
+	}
+
+	return (NULL);
+}
+
 void
 layout_set_size(struct layout_cell *lc, u_int sx, u_int sy, u_int xoff,
     u_int yoff)
@@ -185,7 +236,7 @@ layout_need_status(struct layout_cell *lc, int at_top)
 {
 	struct layout_cell	*first_lc;
 
-	if (lc->parent) {
+	if (lc->parent != NULL) {
 		if (lc->parent->type == LAYOUT_LEFTRIGHT)
 			return (layout_need_status(lc->parent, at_top));
 
@@ -202,71 +253,29 @@ layout_need_status(struct layout_cell *lc, int at_top)
 
 /* Update pane offsets and sizes based on their cells. */
 void
-layout_fix_panes(struct window *w, u_int wsx, u_int wsy)
+layout_fix_panes(struct window *w)
 {
 	struct window_pane	*wp;
 	struct layout_cell	*lc;
-	u_int			 sx, sy;
-	int			 shift, status, at_top;
+	int			 shift, status;
 
 	status = options_get_number(w->options, "pane-border-status");
-	at_top = (status == 1);
 	TAILQ_FOREACH(wp, &w->panes, entry) {
 		if ((lc = wp->layout_cell) == NULL)
 			continue;
 
 		if (status != 0)
-			shift = layout_need_status(lc, at_top);
+			shift = layout_need_status(lc, status == 1);
 		else
 			shift = 0;
 
 		wp->xoff = lc->xoff;
 		wp->yoff = lc->yoff;
 
-		if (shift && at_top)
+		if (shift && status == 1)
 			wp->yoff += 1;
 
-		/*
-		 * Layout cells are limited by the smallest size of other cells
-		 * within the same row or column; if this isn't the case
-		 * resizing becomes difficult.
-		 *
-		 * However, panes do not have to take up their entire cell, so
-		 * they can be cropped to the window edge if the layout
-		 * overflows and they are partly visible.
-		 *
-		 * This stops cells being hidden unnecessarily.
-		 */
-
-		/*
-		 * Work out the horizontal size. If the pane is actually
-		 * outside the window or the entire pane is already visible,
-		 * don't crop.
-		 */
-		if (lc->xoff >= wsx || lc->xoff + lc->sx < wsx)
-			sx = lc->sx;
-		else {
-			sx = wsx - lc->xoff;
-			if (sx < 1)
-				sx = lc->sx;
-		}
-
-		/*
-		 * Similarly for the vertical size; the minimum vertical size
-		 * is two because scroll regions cannot be one line.
-		 */
-		if (lc->yoff >= wsy || lc->yoff + lc->sy < wsy)
-			sy = lc->sy;
-		else {
-			sy = wsy - lc->yoff;
-			if (sy < 2)
-				sy = lc->sy;
-		}
-
-		if (shift)
-			sy -= 1;
-
-		window_pane_resize(wp, sx, sy);
+		window_pane_resize(wp, lc->sx, lc->sy - shift);
 	}
 }
 
@@ -298,7 +307,9 @@ layout_resize_check(struct window *w, struct layout_cell *lc,
 {
 	struct layout_cell	*lcchild;
 	u_int			 available, minimum;
+	int			 status;
 
+	status = options_get_number(w->options, "pane-border-status");
 	if (lc->type == LAYOUT_WINDOWPANE) {
 		/* Space available in this cell only. */
 		minimum = PANE_MINIMUM;
@@ -306,9 +317,8 @@ layout_resize_check(struct window *w, struct layout_cell *lc,
 			available = lc->sx;
 		else {
 			available = lc->sy;
-			minimum += layout_need_status(lc,
-			    options_get_number(w->options,
-			    "pane-border-status") == 1);
+			if (status != 0)
+				minimum += layout_need_status(lc, status == 1);
 		}
 		if (available > minimum)
 			available -= minimum;
@@ -440,8 +450,7 @@ layout_init(struct window *w, struct window_pane *wp)
 	lc = w->layout_root = layout_create_cell(NULL);
 	layout_set_size(lc, w->sx, w->sy, 0, 0);
 	layout_make_leaf(lc, wp);
-
-	layout_fix_panes(w, w->sx, w->sy);
+	layout_fix_panes(w);
 }
 
 void
@@ -470,7 +479,7 @@ layout_resize(struct window *w, u_int sx, u_int sy)
 	 * out proportionately - this should leave the layout fitting the new
 	 * window size.
 	 */
-	xchange = sx - w->sx;
+	xchange = sx - lc->sx;
 	xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT);
 	if (xchange < 0 && xchange < -xlimit)
 		xchange = -xlimit;
@@ -484,7 +493,7 @@ layout_resize(struct window *w, u_int sx, u_int sy)
 		layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, xchange);
 
 	/* Adjust vertically in a similar fashion. */
-	ychange = sy - w->sy;
+	ychange = sy - lc->sy;
 	ylimit = layout_resize_check(w, lc, LAYOUT_TOPBOTTOM);
 	if (ychange < 0 && ychange < -ylimit)
 		ychange = -ylimit;
@@ -499,7 +508,7 @@ layout_resize(struct window *w, u_int sx, u_int sy)
 
 	/* Fix cell offsets. */
 	layout_fix_offsets(lc);
-	layout_fix_panes(w, sx, sy);
+	layout_fix_panes(w);
 }
 
 /* Resize a pane to an absolute size. */
@@ -535,29 +544,11 @@ layout_resize_pane_to(struct window_pane *wp, enum layout_type type,
 	layout_resize_pane(wp, type, change, 1);
 }
 
-/* Resize a single pane within the layout. */
 void
-layout_resize_pane(struct window_pane *wp, enum layout_type type, int change,
-    int opposite)
+layout_resize_layout(struct window *w, struct layout_cell *lc,
+    enum layout_type type, int change, int opposite)
 {
-	struct window		*w = wp->window;
-	struct layout_cell	*lc, *lcparent;
-	int			 needed, size;
-
-	lc = wp->layout_cell;
-
-	/* Find next parent of the same type. */
-	lcparent = lc->parent;
-	while (lcparent != NULL && lcparent->type != type) {
-		lc = lcparent;
-		lcparent = lc->parent;
-	}
-	if (lcparent == NULL)
-		return;
-
-	/* If this is the last cell, move back one. */
-	if (lc == TAILQ_LAST(&lcparent->cells, layout_cells))
-		lc = TAILQ_PREV(lc, layout_cells, entry);
+	int	needed, size;
 
 	/* Grow or shrink the cell. */
 	needed = change;
@@ -576,9 +567,34 @@ layout_resize_pane(struct window_pane *wp, enum layout_type type, int change,
 	}
 
 	/* Fix cell offsets. */
-	layout_fix_offsets(wp->window->layout_root);
-	layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
-	notify_window("window-layout-changed", wp->window);
+	layout_fix_offsets(w->layout_root);
+	layout_fix_panes(w);
+	notify_window("window-layout-changed", w);
+}
+
+/* Resize a single pane within the layout. */
+void
+layout_resize_pane(struct window_pane *wp, enum layout_type type, int change,
+    int opposite)
+{
+	struct layout_cell	*lc, *lcparent;
+
+	lc = wp->layout_cell;
+
+	/* Find next parent of the same type. */
+	lcparent = lc->parent;
+	while (lcparent != NULL && lcparent->type != type) {
+		lc = lcparent;
+		lcparent = lc->parent;
+	}
+	if (lcparent == NULL)
+		return;
+
+	/* If this is the last cell, move back one. */
+	if (lc == TAILQ_LAST(&lcparent->cells, layout_cells))
+		lc = TAILQ_PREV(lc, layout_cells, entry);
+
+	layout_resize_layout(wp->window, lc, type, change, opposite);
 }
 
 /* Helper function to grow pane. */
@@ -659,7 +675,7 @@ void
 layout_assign_pane(struct layout_cell *lc, struct window_pane *wp)
 {
 	layout_make_leaf(lc, wp);
-	layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
+	layout_fix_panes(wp->window);
 }
 
 /* Calculate the new pane size for resized parent. */
@@ -706,7 +722,7 @@ layout_set_size_check(struct window *w, struct layout_cell *lc,
     enum layout_type type, int size)
 {
 	struct layout_cell	*lcchild;
-	u_int			new_size, available, previous, count, idx;
+	u_int			 new_size, available, previous, count, idx;
 
 	/* Cells with no children must just be bigger than minimum. */
 	if (lc->type == LAYOUT_WINDOWPANE)
@@ -720,6 +736,9 @@ layout_set_size_check(struct window *w, struct layout_cell *lc,
 
 	/* Check new size will work for each child. */
 	if (lc->type == type) {
+		if (available < (count * 2) - 1)
+			return (0);
+
 		if (type == LAYOUT_LEFTRIGHT)
 			previous = lc->sx;
 		else
@@ -729,13 +748,17 @@ layout_set_size_check(struct window *w, struct layout_cell *lc,
 		TAILQ_FOREACH(lcchild, &lc->cells, entry) {
 			new_size = layout_new_pane_size(w, previous, lcchild,
 			    type, size, count - idx, available);
-			if (new_size > available)
-				return (0);
-
-			available -= (new_size + 1);
+			if (idx == count - 1) {
+				if (new_size > available)
+					return (0);
+				available -= new_size;
+			} else {
+				if (new_size + 1 > available)
+					return (0);
+				available -= new_size + 1;
+			}
 			if (!layout_set_size_check(w, lcchild, type, new_size))
 				return (0);
-
 			idx++;
 		}
 	} else {
@@ -811,8 +834,9 @@ layout_split_pane(struct window_pane *wp, enum layout_type type, int size,
     int insert_before, int full_size)
 {
 	struct layout_cell     *lc, *lcparent, *lcnew, *lc1, *lc2;
-	u_int			sx, sy, xoff, yoff, size1, size2;
+	u_int			sx, sy, xoff, yoff, size1, size2, minimum;
 	u_int			new_size, saved_size, resize_first = 0;
+	int			status;
 
 	/*
 	 * If full_size is specified, add a new cell at the top of the window
@@ -822,6 +846,7 @@ layout_split_pane(struct window_pane *wp, enum layout_type type, int size,
 		lc = wp->window->layout_root;
 	else
 		lc = wp->layout_cell;
+	status = options_get_number(wp->window->options, "pane-border-status");
 
 	/* Copy the old cell size. */
 	sx = lc->sx;
@@ -836,7 +861,10 @@ layout_split_pane(struct window_pane *wp, enum layout_type type, int size,
 			return (NULL);
 		break;
 	case LAYOUT_TOPBOTTOM:
-		if (sy < PANE_MINIMUM * 2 + 1)
+		minimum = PANE_MINIMUM * 2 + 1;
+		if (status != 0)
+			minimum += layout_need_status(lc, status == 1);
+		if (sy < minimum)
 			return (NULL);
 		break;
 	default:
@@ -979,7 +1007,75 @@ layout_close_pane(struct window_pane *wp)
 	/* Fix pane offsets and sizes. */
 	if (w->layout_root != NULL) {
 		layout_fix_offsets(w->layout_root);
-		layout_fix_panes(w, w->sx, w->sy);
+		layout_fix_panes(w);
 	}
 	notify_window("window-layout-changed", w);
 }
+
+int
+layout_spread_cell(struct window *w, struct layout_cell *parent)
+{
+	struct layout_cell	*lc;
+	u_int			 number, each, size, this;
+	int			 change, changed, status;
+
+	number = 0;
+	TAILQ_FOREACH (lc, &parent->cells, entry)
+	    number++;
+	if (number <= 1)
+		return (0);
+	status = options_get_number(w->options, "pane-border-status");
+
+	if (parent->type == LAYOUT_LEFTRIGHT)
+		size = parent->sx;
+	else if (parent->type == LAYOUT_TOPBOTTOM) {
+		size = parent->sy;
+		if (status != 0)
+			size -= layout_need_status(parent, status == 1);
+	} else
+		return (0);
+	if (size < number - 1)
+		return (0);
+	each = (size - (number - 1)) / number;
+	if (each == 0)
+		return (0);
+
+	changed = 0;
+	TAILQ_FOREACH (lc, &parent->cells, entry) {
+		if (TAILQ_NEXT(lc, entry) == NULL)
+			each = size - ((each + 1) * (number - 1));
+		change = 0;
+		if (parent->type == LAYOUT_LEFTRIGHT) {
+			change = each - (int)lc->sx;
+			layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, change);
+		} else if (parent->type == LAYOUT_TOPBOTTOM) {
+			this = each;
+			if (status != 0)
+				this += layout_need_status(lc, status == 1);
+			change = this - (int)lc->sy;
+			layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, change);
+		}
+		if (change != 0)
+			changed = 1;
+	}
+	return (changed);
+}
+
+void
+layout_spread_out(struct window_pane *wp)
+{
+	struct layout_cell	*parent;
+	struct window		*w = wp->window;
+
+	parent = wp->layout_cell->parent;
+	if (parent == NULL)
+		return;
+
+	do {
+		if (layout_spread_cell(w, parent)) {
+			layout_fix_offsets(parent);
+			layout_fix_panes(w);
+			break;
+		}
+	} while ((parent = parent->parent) != NULL);
+}

mode-tree.c

@@ -31,6 +31,7 @@ TAILQ_HEAD(mode_tree_list, mode_tree_item);
 struct mode_tree_data {
 	int			  dead;
 	u_int			  references;
+	int			  zoomed;
 
 	struct window_pane	 *wp;
 	void			 *modedata;
@@ -39,10 +40,9 @@ struct mode_tree_data {
 	u_int			  sort_size;
 	u_int			  sort_type;
 
-	void			 (*buildcb)(void *, u_int, uint64_t *,
-				     const char *);
-	struct screen		*(*drawcb)(void *, void *, u_int, u_int);
-	int			 (*searchcb)(void*, void *, const char *);
+	mode_tree_build_cb        buildcb;
+	mode_tree_draw_cb         drawcb;
+	mode_tree_search_cb       searchcb;
 
 	struct mode_tree_list	  children;
 	struct mode_tree_list	  saved;
@@ -63,6 +63,7 @@ struct mode_tree_data {
 	int			  preview;
 	char			 *search;
 	char			 *filter;
+	int			  no_matches;
 };
 
 struct mode_tree_item {
@@ -192,27 +193,6 @@ mode_tree_clear_tagged(struct mode_tree_list *mtl)
 }
 
 static void
-mode_tree_set_current(struct mode_tree_data *mtd, uint64_t tag)
-{
-	u_int	i;
-
-	for (i = 0; i < mtd->line_size; i++) {
-		if (mtd->line_list[i].item->tag == tag)
-			break;
-	}
-	if (i != mtd->line_size) {
-		mtd->current = i;
-		if (mtd->current > mtd->height - 1)
-			mtd->offset = mtd->current - mtd->height + 1;
-		else
-			mtd->offset = 0;
-	} else {
-		mtd->current = 0;
-		mtd->offset = 0;
-	}
-}
-
-void
 mode_tree_up(struct mode_tree_data *mtd, int wrap)
 {
 	if (mtd->current == 0) {
@@ -249,6 +229,36 @@ mode_tree_get_current(struct mode_tree_data *mtd)
 	return (mtd->line_list[mtd->current].item->itemdata);
 }
 
+void
+mode_tree_expand_current(struct mode_tree_data *mtd)
+{
+	if (!mtd->line_list[mtd->current].item->expanded) {
+		mtd->line_list[mtd->current].item->expanded = 1;
+		mode_tree_build(mtd);
+	}
+}
+
+void
+mode_tree_set_current(struct mode_tree_data *mtd, uint64_t tag)
+{
+	u_int	i;
+
+	for (i = 0; i < mtd->line_size; i++) {
+		if (mtd->line_list[i].item->tag == tag)
+			break;
+	}
+	if (i != mtd->line_size) {
+		mtd->current = i;
+		if (mtd->current > mtd->height - 1)
+			mtd->offset = mtd->current - mtd->height + 1;
+		else
+			mtd->offset = 0;
+	} else {
+		mtd->current = 0;
+		mtd->offset = 0;
+	}
+}
+
 u_int
 mode_tree_count_tagged(struct mode_tree_data *mtd)
 {
@@ -265,8 +275,8 @@ mode_tree_count_tagged(struct mode_tree_data *mtd)
 }
 
 void
-mode_tree_each_tagged(struct mode_tree_data *mtd, void (*cb)(void *, void *,
-    key_code), key_code key, int current)
+mode_tree_each_tagged(struct mode_tree_data *mtd, mode_tree_each_cb cb,
+    struct client *c, key_code key, int current)
 {
 	struct mode_tree_item	*mti;
 	u_int			 i;
@@ -277,21 +287,20 @@ mode_tree_each_tagged(struct mode_tree_data *mtd, void (*cb)(void *, void *,
 		mti = mtd->line_list[i].item;
 		if (mti->tagged) {
 			fired = 1;
-			cb(mtd->modedata, mti->itemdata, key);
+			cb(mtd->modedata, mti->itemdata, c, key);
 		}
 	}
 	if (!fired && current) {
 		mti = mtd->line_list[mtd->current].item;
-		cb(mtd->modedata, mti->itemdata, key);
+		cb(mtd->modedata, mti->itemdata, c, key);
 	}
 }
 
 struct mode_tree_data *
 mode_tree_start(struct window_pane *wp, struct args *args,
-    void (*buildcb)(void *, u_int, uint64_t *, const char *),
-    struct screen *(*drawcb)(void *, void *, u_int, u_int),
-    int (*searchcb)(void *, void *, const char *), void *modedata,
-    const char **sort_list, u_int sort_size, struct screen **s)
+    mode_tree_build_cb buildcb, mode_tree_draw_cb drawcb,
+    mode_tree_search_cb searchcb, void *modedata, const char **sort_list,
+    u_int sort_size, struct screen **s)
 {
 	struct mode_tree_data	*mtd;
 	const char		*sort;
@@ -335,6 +344,19 @@ mode_tree_start(struct window_pane *wp, struct args *args,
 	return (mtd);
 }
 
+void
+mode_tree_zoom(struct mode_tree_data *mtd, struct args *args)
+{
+	struct window_pane	*wp = mtd->wp;
+
+	if (args_has(args, 'Z')) {
+		mtd->zoomed = (wp->window->flags & WINDOW_ZOOMED);
+		if (!mtd->zoomed && window_zoom(wp) == 0)
+			server_redraw_window(wp->window);
+	} else
+		mtd->zoomed = -1;
+}
+
 void
 mode_tree_build(struct mode_tree_data *mtd)
 {
@@ -350,7 +372,8 @@ mode_tree_build(struct mode_tree_data *mtd)
 	TAILQ_INIT(&mtd->children);
 
 	mtd->buildcb(mtd->modedata, mtd->sort_type, &tag, mtd->filter);
-	if (TAILQ_EMPTY(&mtd->children))
+	mtd->no_matches = TAILQ_EMPTY(&mtd->children);
+	if (mtd->no_matches)
 		mtd->buildcb(mtd->modedata, mtd->sort_type, &tag, NULL);
 
 	mode_tree_free_items(&mtd->saved);
@@ -385,6 +408,11 @@ mode_tree_remove_ref(struct mode_tree_data *mtd)
 void
 mode_tree_free(struct mode_tree_data *mtd)
 {
+	struct window_pane	*wp = mtd->wp;
+
+	if (mtd->zoomed == 0)
+		server_unzoom_window(wp->window);
+
 	mode_tree_free_items(&mtd->children);
 	mode_tree_clear_lines(mtd);
 	screen_free(&mtd->screen);
@@ -463,16 +491,16 @@ void
 mode_tree_draw(struct mode_tree_data *mtd)
 {
 	struct window_pane	*wp = mtd->wp;
-	struct screen		*s = &mtd->screen, *box = NULL;
+	struct screen		*s = &mtd->screen;
 	struct mode_tree_line	*line;
 	struct mode_tree_item	*mti;
 	struct options		*oo = wp->window->options;
 	struct screen_write_ctx	 ctx;
 	struct grid_cell	 gc0, gc;
-	u_int			 w, h, i, j, sy, box_x, box_y;
+	u_int			 w, h, i, j, sy, box_x, box_y, width;
 	char			*text, *start, key[7];
 	const char		*tag, *symbol;
-	size_t			 size;
+	size_t			 size, n;
 	int			 keylen;
 
 	if (mtd->line_size == 0)
@@ -502,7 +530,7 @@ mode_tree_draw(struct mode_tree_data *mtd)
 		line = &mtd->line_list[i];
 		mti = line->item;
 
-		screen_write_cursormove(&ctx, 0, i - mtd->offset);
+		screen_write_cursormove(&ctx, 0, i - mtd->offset, 0);
 
 		if (i < 10)
 			snprintf(key, sizeof key, "(%c)  ", '0' + i);
@@ -544,8 +572,9 @@ mode_tree_draw(struct mode_tree_data *mtd)
 			tag = "*";
 		else
 			tag = "";
-		xasprintf(&text, "%-*s%s%s%s: %s", keylen, key, start,
-		    mti->name, tag, mti->text);
+		xasprintf(&text, "%-*s%s%s%s: ", keylen, key, start, mti->name,
+		    tag);
+		width = utf8_cstrwidth(text);
 		free(start);
 
 		if (mti->tagged) {
@@ -554,10 +583,14 @@ mode_tree_draw(struct mode_tree_data *mtd)
 		}
 
 		if (i != mtd->current) {
-			screen_write_puts(&ctx, &gc0, "%.*s", w, text);
 			screen_write_clearendofline(&ctx, 8);
-		} else
-			screen_write_puts(&ctx, &gc, "%-*.*s", w, w, text);
+			screen_write_puts(&ctx, &gc0, "%s", text);
+			format_draw(&ctx, &gc0, w - width, mti->text, NULL);
+		} else {
+			screen_write_clearendofline(&ctx, gc.bg);
+			screen_write_puts(&ctx, &gc, "%s", text);
+			format_draw(&ctx, &gc, w - width, mti->text, NULL);
+		}
 		free(text);
 
 		if (mti->tagged) {
@@ -575,27 +608,36 @@ mode_tree_draw(struct mode_tree_data *mtd)
 	line = &mtd->line_list[mtd->current];
 	mti = line->item;
 
-	screen_write_cursormove(&ctx, 0, h);
+	screen_write_cursormove(&ctx, 0, h, 0);
 	screen_write_box(&ctx, w, sy - h);
 
-	xasprintf(&text, " %s (sort: %s) ", mti->name,
+	xasprintf(&text, " %s (sort: %s)", mti->name,
 	    mtd->sort_list[mtd->sort_type]);
 	if (w - 2 >= strlen(text)) {
-		screen_write_cursormove(&ctx, 1, h);
+		screen_write_cursormove(&ctx, 1, h, 0);
 		screen_write_puts(&ctx, &gc0, "%s", text);
+
+		if (mtd->no_matches)
+			n = (sizeof "no matches") - 1;
+		else
+			n = (sizeof "active") - 1;
+		if (mtd->filter != NULL && w - 2 >= strlen(text) + 10 + n + 2) {
+			screen_write_puts(&ctx, &gc0, " (filter: ");
+			if (mtd->no_matches)
+				screen_write_puts(&ctx, &gc, "no matches");
+			else
+				screen_write_puts(&ctx, &gc0, "active");
+			screen_write_puts(&ctx, &gc0, ") ");
+		}
 	}
 	free(text);
 
 	box_x = w - 4;
 	box_y = sy - h - 2;
 
-	if (box_x != 0 && box_y != 0)
-		box = mtd->drawcb(mtd->modedata, mti->itemdata, box_x, box_y);
-	if (box != NULL) {
-		screen_write_cursormove(&ctx, 2, h + 1);
-		screen_write_copy(&ctx, box, 0, 0, box_x, box_y, NULL, NULL);
-
-		screen_free(box);
+	if (box_x != 0 && box_y != 0) {
+		screen_write_cursormove(&ctx, 2, h + 1, 0);
+		mtd->drawcb(mtd->modedata, mti->itemdata, &ctx, box_x, box_y);
 	}
 
 	screen_write_stop(&ctx);
@@ -722,7 +764,7 @@ mode_tree_filter_free(void *data)
 
 int
 mode_tree_key(struct mode_tree_data *mtd, struct client *c, key_code *key,
-    struct mouse_event *m)
+    struct mouse_event *m, u_int *xp, u_int *yp)
 {
 	struct mode_tree_line	*line;
 	struct mode_tree_item	*current, *parent;
@@ -730,20 +772,31 @@ mode_tree_key(struct mode_tree_data *mtd, struct client *c, key_code *key,
 	int			 choice;
 	key_code		 tmp;
 
-	if (*key == KEYC_MOUSEDOWN1_PANE) {
+	if (KEYC_IS_MOUSE(*key)) {
 		if (cmd_mouse_at(mtd->wp, m, &x, &y, 0) != 0) {
 			*key = KEYC_NONE;
 			return (0);
 		}
+		if (xp != NULL)
+			*xp = x;
+		if (yp != NULL)
+			*yp = y;
 		if (x > mtd->width || y > mtd->height) {
-			*key = KEYC_NONE;
+			if (!mtd->preview)
+				*key = KEYC_NONE;
 			return (0);
 		}
 		if (mtd->offset + y < mtd->line_size) {
-			mtd->current = mtd->offset + y;
-			*key = '\r';
-			return (0);
-		}
+			if (*key == KEYC_MOUSEDOWN1_PANE ||
+			    *key == KEYC_DOUBLECLICK1_PANE)
+				mtd->current = mtd->offset + y;
+			if (*key == KEYC_DOUBLECLICK1_PANE)
+				*key = '\r';
+			else
+				*key = KEYC_NONE;
+		} else
+			*key = KEYC_NONE;
+		return (0);
 	}
 
 	line = &mtd->line_list[mtd->current];
@@ -770,15 +823,18 @@ mode_tree_key(struct mode_tree_data *mtd, struct client *c, key_code *key,
 	switch (*key) {
 	case 'q':
 	case '\033': /* Escape */
+	case '\007': /* C-g */
 		return (1);
 	case KEYC_UP:
 	case 'k':
 	case KEYC_WHEELUP_PANE:
+	case '\020': /* C-p */
 		mode_tree_up(mtd, 1);
 		break;
 	case KEYC_DOWN:
 	case 'j':
 	case KEYC_WHEELDOWN_PANE:
+	case '\016': /* C-n */
 		mode_tree_down(mtd, 1);
 		break;
 	case KEYC_PPAGE:
@@ -844,6 +900,7 @@ mode_tree_key(struct mode_tree_data *mtd, struct client *c, key_code *key,
 		mode_tree_build(mtd);
 		break;
 	case KEYC_LEFT:
+	case 'h':
 	case '-':
 		if (line->flat || !current->expanded)
 			current = current->parent;
@@ -856,6 +913,7 @@ mode_tree_key(struct mode_tree_data *mtd, struct client *c, key_code *key,
 		}
 		break;
 	case KEYC_RIGHT:
+	case 'l':
 	case '+':
 		if (line->flat || current->expanded)
 			mode_tree_down(mtd, 0);

notify.c

@@ -35,7 +35,7 @@ struct notify_entry {
 };
 
 static void
-notify_hook(struct cmdq_item *item, struct notify_entry *ne)
+notify_hook1(struct cmdq_item *item, struct notify_entry *ne)
 {
 	struct cmd_find_state	 fs;
 	struct hook		*hook;
@@ -101,7 +101,7 @@ notify_callback(struct cmdq_item *item, void *data)
 	if (strcmp(ne->name, "session-window-changed") == 0)
 		control_notify_session_window_changed(ne->session);
 
-	notify_hook(item, ne);
+	notify_hook1(item, ne);
 
 	if (ne->client != NULL)
 		server_client_unref(ne->client);
@@ -153,6 +153,24 @@ notify_add(const char *name, struct cmd_find_state *fs, struct client *c,
 	cmdq_append(NULL, new_item);
 }
 
+void
+notify_hook(struct cmdq_item *item, const char *name)
+{
+	struct notify_entry	ne;
+
+	memset(&ne, 0, sizeof ne);
+
+	ne.name = name;
+	cmd_find_copy_state(&ne.fs, &item->target);
+
+	ne.client = item->client;
+	ne.session = item->target.s;
+	ne.window = item->target.w;
+	ne.pane = item->target.wp->id;
+
+	notify_hook1(item, &ne);
+}
+
 void
 notify_input(struct window_pane *wp, struct evbuffer *input)
 {

options-table.c

@@ -38,6 +38,9 @@ static const char *options_table_mode_keys_list[] = {
 static const char *options_table_clock_mode_style_list[] = {
 	"12", "24", NULL
 };
+static const char *options_table_status_list[] = {
+	"off", "on", "2", "3", "4", "5", NULL
+};
 static const char *options_table_status_keys_list[] = {
 	"emacs", "vi", NULL
 };
@@ -59,6 +62,72 @@ static const char *options_table_pane_status_list[] = {
 static const char *options_table_set_clipboard_list[] = {
 	"off", "external", "on", NULL
 };
+static const char *options_table_window_size_list[] = {
+	"largest", "smallest", "manual", NULL
+};
+
+/* Status line format. */
+#define OPTIONS_TABLE_STATUS_FORMAT1 \
+	"#[align=left range=left #{status-left-style}]" \
+	"#{T;=/#{status-left-length}:status-left}#[norange default]" \
+	"#[list=on align=#{status-justify}]" \
+	"#[list=left-marker]<#[list=right-marker]>#[list=on]" \
+	"#{W:" \
+		"#[range=window|#{window_index} " \
+			"#{window-status-style}" \
+			"#{?#{&&:#{window_last_flag}," \
+				"#{!=:#{window-status-last-style},default}}, " \
+				"#{window-status-last-style}," \
+			"}" \
+			"#{?#{&&:#{window_bell_flag}," \
+				"#{!=:#{window-status-bell-style},default}}, " \
+				"#{window-status-bell-style}," \
+				"#{?#{&&:#{||:#{window_activity_flag}," \
+					     "#{window_silence_flag}}," \
+					"#{!=:" \
+					"#{window-status-activity-style}," \
+					"default}}, " \
+					"#{window-status-activity-style}," \
+				"}" \
+			"}" \
+		"]" \
+		"#{T:window-status-format}" \
+		"#[norange default]" \
+		"#{?window_end_flag,,#{window-status-separator}}" \
+	"," \
+		"#[range=window|#{window_index} list=focus " \
+			"#{?#{!=:#{window-status-current-style},default}," \
+	                        "#{window-status-current-style}," \
+	                        "#{window-status-style}" \
+	                "}" \
+			"#{?#{&&:#{window_last_flag}," \
+				"#{!=:#{window-status-last-style},default}}, " \
+				"#{window-status-last-style}," \
+			"}" \
+			"#{?#{&&:#{window_bell_flag}," \
+				"#{!=:#{window-status-bell-style},default}}, " \
+				"#{window-status-bell-style}," \
+				"#{?#{&&:#{||:#{window_activity_flag}," \
+					     "#{window_silence_flag}}," \
+					"#{!=:" \
+					"#{window-status-activity-style}," \
+					"default}}, " \
+					"#{window-status-activity-style}," \
+				"}" \
+			"}" \
+		"]" \
+		"#{T:window-status-current-format}" \
+		"#[norange list=on default]" \
+		"#{?window_end_flag,,#{window-status-separator}}" \
+	"}" \
+	"#[nolist align=right range=right #{status-right-style}]" \
+	"#{T;=/#{status-right-length}:status-right}#[norange default]"
+#define OPTIONS_TABLE_STATUS_FORMAT2 \
+	"#[align=centre]#{P:#{?pane_active,#[reverse],}" \
+	"#{pane_index}[#{pane_width}x#{pane_height}]#[default] }"
+static const char *options_table_status_format_default[] = {
+	OPTIONS_TABLE_STATUS_FORMAT1, OPTIONS_TABLE_STATUS_FORMAT2, NULL
+};
 
 /* Top-level options. */
 const struct options_table_entry options_table[] = {
@@ -96,6 +165,12 @@ const struct options_table_entry options_table[] = {
 	  .default_num = 500
 	},
 
+	{ .name = "exit-empty",
+	  .type = OPTIONS_TABLE_FLAG,
+	  .scope = OPTIONS_TABLE_SERVER,
+	  .default_num = 1
+	},
+
 	{ .name = "exit-unattached",
 	  .type = OPTIONS_TABLE_FLAG,
 	  .scope = OPTIONS_TABLE_SERVER,
@@ -187,6 +262,13 @@ const struct options_table_entry options_table[] = {
 	  .default_str = _PATH_BSHELL
 	},
 
+	{ .name = "default-size",
+	  .type = OPTIONS_TABLE_STRING,
+	  .scope = OPTIONS_TABLE_SESSION,
+	  .pattern = "[0-9]*x[0-9]*",
+	  .default_str = "80x24"
+	},
+
 	{ .name = "destroy-unattached",
 	  .type = OPTIONS_TABLE_FLAG,
 	  .scope = OPTIONS_TABLE_SESSION,
@@ -255,54 +337,12 @@ const struct options_table_entry options_table[] = {
 	  .default_str = "lock -np"
 	},
 
-	{ .name = "message-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "message-style"
-	},
-
-	{ .name = "message-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 3,
-	  .style = "message-style"
-	},
-
-	{ .name = "message-command-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "message-command-style"
-	},
-
-	{ .name = "message-command-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "message-command-style"
-	},
-
-	{ .name = "message-command-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 3,
-	  .style = "message-command-style"
-	},
-
 	{ .name = "message-command-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_SESSION,
 	  .default_str = "bg=black,fg=yellow"
 	},
 
-	{ .name = "message-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "message-style"
-	},
-
 	{ .name = "message-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_SESSION,
@@ -361,30 +401,28 @@ const struct options_table_entry options_table[] = {
 	},
 
 	{ .name = "status",
-	  .type = OPTIONS_TABLE_FLAG,
+	  .type = OPTIONS_TABLE_CHOICE,
 	  .scope = OPTIONS_TABLE_SESSION,
+	  .choices = options_table_status_list,
 	  .default_num = 1
 	},
 
-	{ .name = "status-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "status-style"
-	},
-
 	{ .name = "status-bg",
 	  .type = OPTIONS_TABLE_COLOUR,
 	  .scope = OPTIONS_TABLE_SESSION,
 	  .default_num = 2,
-	  .style = "status-style"
 	},
 
 	{ .name = "status-fg",
 	  .type = OPTIONS_TABLE_COLOUR,
 	  .scope = OPTIONS_TABLE_SESSION,
 	  .default_num = 0,
-	  .style = "status-style"
+	},
+
+	{ .name = "status-format",
+	  .type = OPTIONS_TABLE_ARRAY,
+	  .scope = OPTIONS_TABLE_SESSION,
+	  .default_arr = options_table_status_format_default,
 	},
 
 	{ .name = "status-interval",
@@ -415,27 +453,6 @@ const struct options_table_entry options_table[] = {
 	  .default_str = "[#S] "
 	},
 
-	{ .name = "status-left-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "status-left-style"
-	},
-
-	{ .name = "status-left-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 8,
-	  .style = "status-left-style"
-	},
-
-	{ .name = "status-left-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 8,
-	  .style = "status-left-style"
-	},
-
 	{ .name = "status-left-length",
 	  .type = OPTIONS_TABLE_NUMBER,
 	  .scope = OPTIONS_TABLE_SESSION,
@@ -460,28 +477,9 @@ const struct options_table_entry options_table[] = {
 	{ .name = "status-right",
 	  .type = OPTIONS_TABLE_STRING,
 	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_str = " \"#{=21:pane_title}\" %H:%M %d-%b-%y"
-	},
-
-	{ .name = "status-right-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 0,
-	  .style = "status-right-style"
-	},
-
-	{ .name = "status-right-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 8,
-	  .style = "status-right-style"
-	},
-
-	{ .name = "status-right-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_num = 8,
-	  .style = "status-right-style"
+	  .default_str = "#{?window_bigger,"
+	                 "[#{window_offset_x}#,#{window_offset_y}] ,}"
+	                 "\"#{=21:pane_title}\" %H:%M %d-%b-%y"
 	},
 
 	{ .name = "status-right-length",
@@ -507,8 +505,8 @@ const struct options_table_entry options_table[] = {
 	{ .name = "update-environment",
 	  .type = OPTIONS_TABLE_ARRAY,
 	  .scope = OPTIONS_TABLE_SESSION,
-	  .default_str = "DISPLAY SSH_ASKPASS SSH_AUTH_SOCK SSH_AGENT_PID "
-			 "SSH_CONNECTION WINDOWID XAUTHORITY"
+	  .default_str = "DISPLAY KRB5CCNAME SSH_ASKPASS SSH_AUTH_SOCK "
+	  		 "SSH_AGENT_PID SSH_CONNECTION WINDOWID XAUTHORITY"
 	},
 
 	{ .name = "visual-activity",
@@ -547,7 +545,7 @@ const struct options_table_entry options_table[] = {
 	{ .name = "allow-rename",
 	  .type = OPTIONS_TABLE_FLAG,
 	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 1
+	  .default_num = 0
 	},
 
 	{ .name = "alternate-screen",
@@ -582,22 +580,6 @@ const struct options_table_entry options_table[] = {
 	  .default_num = 1
 	},
 
-	{ .name = "force-height",
-	  .type = OPTIONS_TABLE_NUMBER,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .minimum = 0,
-	  .maximum = INT_MAX,
-	  .default_num = 0
-	},
-
-	{ .name = "force-width",
-	  .type = OPTIONS_TABLE_NUMBER,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .minimum = 0,
-	  .maximum = INT_MAX,
-	  .default_num = 0
-	},
-
 	{ .name = "main-pane-height",
 	  .type = OPTIONS_TABLE_NUMBER,
 	  .scope = OPTIONS_TABLE_WINDOW,
@@ -614,27 +596,6 @@ const struct options_table_entry options_table[] = {
 	  .default_num = 80
 	},
 
-	{ .name = "mode-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 0,
-	  .style = "mode-style"
-	},
-
-	{ .name = "mode-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 3,
-	  .style = "mode-style"
-	},
-
-	{ .name = "mode-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 0,
-	  .style = "mode-style"
-	},
-
 	{ .name = "mode-keys",
 	  .type = OPTIONS_TABLE_CHOICE,
 	  .scope = OPTIONS_TABLE_WINDOW,
@@ -684,20 +645,6 @@ const struct options_table_entry options_table[] = {
 	  .default_num = 0
 	},
 
-	{ .name = "pane-active-border-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "pane-active-border-style"
-	},
-
-	{ .name = "pane-active-border-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 2,
-	  .style = "pane-active-border-style"
-	},
-
 	{ .name = "pane-active-border-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_WINDOW,
@@ -712,20 +659,6 @@ const struct options_table_entry options_table[] = {
 	  .default_num = 0
 	},
 
-	{ .name = "pane-border-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "pane-border-style"
-	},
-
-	{ .name = "pane-border-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "pane-border-style"
-	},
-
 	{ .name = "pane-border-format",
 	  .type = OPTIONS_TABLE_STRING,
 	  .scope = OPTIONS_TABLE_WINDOW,
@@ -764,101 +697,31 @@ const struct options_table_entry options_table[] = {
 	  .default_str = "default"
 	},
 
+	{ .name = "window-size",
+	  .type = OPTIONS_TABLE_CHOICE,
+	  .scope = OPTIONS_TABLE_WINDOW,
+	  .choices = options_table_window_size_list,
+	  .default_num = WINDOW_SIZE_SMALLEST
+	},
+
 	{ .name = "window-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_WINDOW,
 	  .default_str = "default"
 	},
 
-	{ .name = "window-status-activity-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = GRID_ATTR_REVERSE,
-	  .style = "window-status-activity-style"
-	},
-
-	{ .name = "window-status-activity-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-activity-style"
-	},
-
-	{ .name = "window-status-activity-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-activity-style"
-	},
-
 	{ .name = "window-status-activity-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_WINDOW,
 	  .default_str = "reverse"
 	},
 
-	{ .name = "window-status-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 0,
-	  .style = "window-status-style"
-	},
-
-	{ .name = "window-status-bell-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = GRID_ATTR_REVERSE,
-	  .style = "window-status-bell-style"
-	},
-
-	{ .name = "window-status-bell-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-bell-style"
-	},
-
-	{ .name = "window-status-bell-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-bell-style"
-	},
-
 	{ .name = "window-status-bell-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_WINDOW,
 	  .default_str = "reverse"
 	},
 
-	{ .name = "window-status-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-style"
-	},
-
-	{ .name = "window-status-current-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 0,
-	  .style = "window-status-current-style"
-	},
-
-	{ .name = "window-status-current-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-current-style"
-	},
-
-	{ .name = "window-status-current-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-current-style"
-	},
-
 	{ .name = "window-status-current-format",
 	  .type = OPTIONS_TABLE_STRING,
 	  .scope = OPTIONS_TABLE_WINDOW,
@@ -871,40 +734,12 @@ const struct options_table_entry options_table[] = {
 	  .default_str = "default"
 	},
 
-	{ .name = "window-status-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-style"
-	},
-
 	{ .name = "window-status-format",
 	  .type = OPTIONS_TABLE_STRING,
 	  .scope = OPTIONS_TABLE_WINDOW,
 	  .default_str = "#I:#W#{?window_flags,#{window_flags}, }"
 	},
 
-	{ .name = "window-status-last-attr",
-	  .type = OPTIONS_TABLE_ATTRIBUTES,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 0,
-	  .style = "window-status-last-style"
-	},
-
-	{ .name = "window-status-last-bg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-last-style"
-	},
-
-	{ .name = "window-status-last-fg",
-	  .type = OPTIONS_TABLE_COLOUR,
-	  .scope = OPTIONS_TABLE_WINDOW,
-	  .default_num = 8,
-	  .style = "window-status-last-style"
-	},
-
 	{ .name = "window-status-last-style",
 	  .type = OPTIONS_TABLE_STYLE,
 	  .scope = OPTIONS_TABLE_WINDOW,

options.c

@@ -30,6 +30,23 @@
  * a red-black tree.
  */
 
+struct options_array_item {
+	u_int				 index;
+	char				*value;
+	RB_ENTRY(options_array_item)	 entry;
+};
+RB_HEAD(options_array, options_array_item);
+static int
+options_array_cmp(struct options_array_item *a1, struct options_array_item *a2)
+{
+	if (a1->index < a2->index)
+		return (-1);
+	if (a1->index > a2->index)
+		return (1);
+	return (0);
+}
+RB_GENERATE_STATIC(options_array, options_array_item, entry, options_array_cmp);
+
 struct options_entry {
 	struct options				 *owner;
 
@@ -39,11 +56,8 @@ struct options_entry {
 	union {
 		char				 *string;
 		long long			  number;
-		struct grid_cell		  style;
-		struct {
-			const char		**array;
-			u_int			  arraysize;
-		};
+		struct style			  style;
+		struct options_array		  array;
 	};
 
 	RB_ENTRY(options_entry)			  entry;
@@ -56,8 +70,6 @@ struct options {
 
 static struct options_entry	*options_add(struct options *, const char *);
 
-#define OPTIONS_ARRAY_LIMIT 1000
-
 #define OPTIONS_IS_STRING(o)						\
 	((o)->tableentry == NULL ||					\
 	    (o)->tableentry->type == OPTIONS_TABLE_STRING)
@@ -66,7 +78,6 @@ static struct options_entry	*options_add(struct options *, const char *);
 	    ((o)->tableentry->type == OPTIONS_TABLE_NUMBER ||		\
 	    (o)->tableentry->type == OPTIONS_TABLE_KEY ||		\
 	    (o)->tableentry->type == OPTIONS_TABLE_COLOUR ||		\
-	    (o)->tableentry->type == OPTIONS_TABLE_ATTRIBUTES ||	\
 	    (o)->tableentry->type == OPTIONS_TABLE_FLAG ||		\
 	    (o)->tableentry->type == OPTIONS_TABLE_CHOICE))
 #define OPTIONS_IS_STYLE(o) \
@@ -163,22 +174,30 @@ options_empty(struct options *oo, const struct options_table_entry *oe)
 	o = options_add(oo, oe->name);
 	o->tableentry = oe;
 
+	if (oe->type == OPTIONS_TABLE_ARRAY)
+		RB_INIT(&o->array);
+
 	return (o);
 }
 
 struct options_entry *
 options_default(struct options *oo, const struct options_table_entry *oe)
 {
-	struct options_entry	*o;
+	struct options_entry	 *o;
+	u_int			  i;
 
 	o = options_empty(oo, oe);
-	if (oe->type == OPTIONS_TABLE_ARRAY)
-		options_array_assign(o, oe->default_str);
-	else if (oe->type == OPTIONS_TABLE_STRING)
+	if (oe->type == OPTIONS_TABLE_ARRAY) {
+		if (oe->default_arr != NULL) {
+			for (i = 0; oe->default_arr[i] != NULL; i++)
+				options_array_set(o, i, oe->default_arr[i], 0);
+		} else
+			options_array_assign(o, oe->default_str);
+	} else if (oe->type == OPTIONS_TABLE_STRING)
 		o->string = xstrdup(oe->default_str);
 	else if (oe->type == OPTIONS_TABLE_STYLE) {
-		memcpy(&o->style, &grid_default_cell, sizeof o->style);
-		style_parse(&grid_default_cell, &o->style, oe->default_str);
+		style_set(&o->style, &grid_default_cell);
+		style_parse(&o->style, &grid_default_cell, oe->default_str);
 	} else
 		o->number = oe->default_num;
 	return (o);
@@ -205,15 +224,11 @@ void
 options_remove(struct options_entry *o)
 {
 	struct options	*oo = o->owner;
-	u_int		 i;
 
 	if (OPTIONS_IS_STRING(o))
-		free((void *)o->string);
-	else if (OPTIONS_IS_ARRAY(o)) {
-		for (i = 0; i < o->arraysize; i++)
-			free((void *)o->array[i]);
-		free(o->array);
-	}
+		free(o->string);
+	else if (OPTIONS_IS_ARRAY(o))
+		options_array_clear(o);
 
 	RB_REMOVE(options_tree, &oo->tree, o);
 	free(o);
@@ -231,62 +246,79 @@ options_table_entry(struct options_entry *o)
 	return (o->tableentry);
 }
 
+static struct options_array_item *
+options_array_item(struct options_entry *o, u_int idx)
+{
+	struct options_array_item	a;
+
+	a.index = idx;
+	return (RB_FIND(options_array, &o->array, &a));
+}
+
+static void
+options_array_free(struct options_entry *o, struct options_array_item *a)
+{
+	free(a->value);
+	RB_REMOVE(options_array, &o->array, a);
+	free(a);
+}
+
 void
 options_array_clear(struct options_entry *o)
 {
-	if (OPTIONS_IS_ARRAY(o))
-		o->arraysize = 0;
+	struct options_array_item	*a, *a1;
+
+	if (!OPTIONS_IS_ARRAY(o))
+		return;
+
+	RB_FOREACH_SAFE(a, options_array, &o->array, a1)
+	    options_array_free(o, a);
 }
 
 const char *
 options_array_get(struct options_entry *o, u_int idx)
 {
+	struct options_array_item	*a;
+
 	if (!OPTIONS_IS_ARRAY(o))
 		return (NULL);
-	if (idx >= o->arraysize)
+	a = options_array_item(o, idx);
+	if (a == NULL)
 		return (NULL);
-	return (o->array[idx]);
+	return (a->value);
 }
 
 int
 options_array_set(struct options_entry *o, u_int idx, const char *value,
     int append)
 {
-	char	*new;
-	u_int	 i;
+	struct options_array_item	*a;
+	char				*new;
 
 	if (!OPTIONS_IS_ARRAY(o))
 		return (-1);
 
-	if (idx >= OPTIONS_ARRAY_LIMIT)
-		return (-1);
-	if (idx >= o->arraysize) {
-		o->array = xreallocarray(o->array, idx + 1, sizeof *o->array);
-		for (i = o->arraysize; i < idx + 1; i++)
-			o->array[i] = NULL;
-		o->arraysize = idx + 1;
+	a = options_array_item(o, idx);
+	if (value == NULL) {
+		if (a != NULL)
+			options_array_free(o, a);
+		return (0);
 	}
 
-	new = NULL;
-	if (value != NULL) {
-		if (o->array[idx] != NULL && append)
-			xasprintf(&new, "%s%s", o->array[idx], value);
+	if (a == NULL) {
+		a = xcalloc(1, sizeof *a);
+		a->index = idx;
+		a->value = xstrdup(value);
+		RB_INSERT(options_array, &o->array, a);
+	} else {
+		free(a->value);
+		if (a != NULL && append)
+			xasprintf(&new, "%s%s", a->value, value);
 		else
 			new = xstrdup(value);
+		a->value = new;
 	}
 
-	free((void *)o->array[idx]);
-	o->array[idx] = new;
-	return (0);
-}
-
-int
-options_array_size(struct options_entry *o, u_int *size)
-{
-	if (!OPTIONS_IS_ARRAY(o))
-		return (-1);
-	if (size != NULL)
-		*size = o->arraysize;
 	return (0);
 }
 
@@ -305,37 +337,69 @@ options_array_assign(struct options_entry *o, const char *s)
 	while ((next = strsep(&string, separator)) != NULL) {
 		if (*next == '\0')
 			continue;
-		for (i = 0; i < OPTIONS_ARRAY_LIMIT; i++) {
-			if (i >= o->arraysize || o->array[i] == NULL)
+		for (i = 0; i < UINT_MAX; i++) {
+			if (options_array_item(o, i) == NULL)
 				break;
 		}
-		if (i == OPTIONS_ARRAY_LIMIT)
+		if (i == UINT_MAX)
 			break;
 		options_array_set(o, i, next, 0);
 	}
 	free(copy);
 }
 
+struct options_array_item *
+options_array_first(struct options_entry *o)
+{
+	if (!OPTIONS_IS_ARRAY(o))
+		return (NULL);
+	return (RB_MIN(options_array, &o->array));
+}
+
+struct options_array_item *
+options_array_next(struct options_array_item *a)
+{
+	return (RB_NEXT(options_array, &o->array, a));
+}
+
+u_int
+options_array_item_index(struct options_array_item *a)
+{
+	return (a->index);
+}
+
+const char *
+options_array_item_value(struct options_array_item *a)
+{
+	return (a->value);
+}
+
+int
+options_isarray(struct options_entry *o)
+{
+	return (OPTIONS_IS_ARRAY(o));
+}
+
 int
 options_isstring(struct options_entry *o)
 {
-	if (o->tableentry == NULL)
-		return (1);
 	return (OPTIONS_IS_STRING(o) || OPTIONS_IS_ARRAY(o));
 }
 
 const char *
 options_tostring(struct options_entry *o, int idx, int numeric)
 {
-	static char	 s[1024];
-	const char	*tmp;
+	static char			 s[1024];
+	const char			*tmp;
+	struct options_array_item	*a;
 
 	if (OPTIONS_IS_ARRAY(o)) {
 		if (idx == -1)
 			return (NULL);
-		if ((u_int)idx >= o->arraysize || o->array[idx] == NULL)
+		a = options_array_item(o, idx);
+		if (a == NULL)
 			return ("");
-		return (o->array[idx]);
+		return (a->value);
 	}
 	if (OPTIONS_IS_STYLE(o))
 		return (style_tostring(&o->style));
@@ -351,9 +415,6 @@ options_tostring(struct options_entry *o, int idx, int numeric)
 		case OPTIONS_TABLE_COLOUR:
 			tmp = colour_tostring(o->number);
 			break;
-		case OPTIONS_TABLE_ATTRIBUTES:
-			tmp = attributes_tostring(o->number);
-			break;
 		case OPTIONS_TABLE_FLAG:
 			if (numeric)
 				xsnprintf(s, sizeof s, "%lld", o->number);
@@ -504,7 +565,7 @@ options_get_number(struct options *oo, const char *name)
 	return (o->number);
 }
 
-const struct grid_cell *
+struct style *
 options_get_style(struct options *oo, const char *name)
 {
 	struct options_entry	*o;
@@ -576,17 +637,17 @@ options_set_style(struct options *oo, const char *name, int append,
     const char *value)
 {
 	struct options_entry	*o;
-	struct grid_cell	 gc;
+	struct style		 sy;
 
 	if (*name == '@')
 		fatalx("user option %s must be a string", name);
 
 	o = options_get_only(oo, name);
 	if (o != NULL && append && OPTIONS_IS_STYLE(o))
-		memcpy(&gc, &o->style, sizeof gc);
+		style_copy(&sy, &o->style);
 	else
-		memcpy(&gc, &grid_default_cell, sizeof gc);
-	if (style_parse(&grid_default_cell, &gc, value) == -1)
+		style_set(&sy, &grid_default_cell);
+	if (style_parse(&sy, &grid_default_cell, value) == -1)
 		return (NULL);
 	if (o == NULL) {
 		o = options_default(oo, options_parent_table_entry(oo, name));
@@ -596,7 +657,7 @@ options_set_style(struct options *oo, const char *name, int append,
 
 	if (!OPTIONS_IS_STYLE(o))
 		fatalx("option %s is not a style", name);
-	memcpy(&o->style, &gc, sizeof o->style);
+	style_copy(&o->style, &sy);
 	return (o);
 }
 
@@ -643,44 +704,3 @@ options_scope_from_flags(struct args *args, int window,
 		return (OPTIONS_TABLE_SESSION);
 	}
 }
-
-void
-options_style_update_new(struct options *oo, struct options_entry *o)
-{
-	const char		*newname = o->tableentry->style;
-	struct options_entry	*new;
-
-	if (newname == NULL)
-		return;
-	new = options_get_only(oo, newname);
-	if (new == NULL)
-		new = options_set_style(oo, newname, 0, "default");
-
-	if (strstr(o->name, "-bg") != NULL)
-		new->style.bg = o->number;
-	else if (strstr(o->name, "-fg") != NULL)
-		new->style.fg = o->number;
-	else if (strstr(o->name, "-attr") != NULL)
-		new->style.attr = o->number;
-}
-
-void
-options_style_update_old(struct options *oo, struct options_entry *o)
-{
-	char	newname[128];
-	int	size;
-
-	size = strrchr(o->name, '-') - o->name;
-
-	xsnprintf(newname, sizeof newname, "%.*s-bg", size, o->name);
-	if (options_get(oo, newname) != NULL)
-		options_set_number(oo, newname, o->style.bg);
-
-	xsnprintf(newname, sizeof newname, "%.*s-fg", size, o->name);
-	if (options_get(oo, newname) != NULL)
-		options_set_number(oo, newname, o->style.fg);
-
-	xsnprintf(newname, sizeof newname, "%.*s-attr", size, o->name);
-	if (options_get(oo, newname) != NULL)
-		options_set_number(oo, newname, o->style.attr);
-}

osdep-darwin.c

@@ -88,11 +88,17 @@ osdep_get_cwd(int fd)
 struct event_base *
 osdep_event_init(void)
 {
+	struct event_base	*base;
+
 	/*
 	 * On OS X, kqueue and poll are both completely broken and don't
 	 * work on anything except socket file descriptors (yes, really).
 	 */
 	setenv("EVENT_NOKQUEUE", "1", 1);
 	setenv("EVENT_NOPOLL", "1", 1);
-	return (event_init());
+
+	base = event_init();
+	unsetenv("EVENT_NOKQUEUE");
+	unsetenv("EVENT_NOPOLL");
+	return (base);
 }

osdep-freebsd.c

@@ -31,6 +31,8 @@
 #include <unistd.h>
 #include <libutil.h>
 
+#include "compat.h"
+
 struct kinfo_proc	*cmp_procs(struct kinfo_proc *, struct kinfo_proc *);
 char			*osdep_get_name(int, char *);
 char			*osdep_get_cwd(int);
@@ -193,10 +195,15 @@ osdep_get_cwd(int fd)
 struct event_base *
 osdep_event_init(void)
 {
+	struct event_base	*base;
+
 	/*
 	 * On some versions of FreeBSD, kqueue doesn't work properly on tty
 	 * file descriptors. This is fixed in recent FreeBSD versions.
 	 */
 	setenv("EVENT_NOKQUEUE", "1", 1);
-	return (event_init());
+
+	base = event_init();
+	unsetenv("EVENT_NOKQUEUE");
+	return (base);
 }

osdep-linux.c

@@ -92,7 +92,12 @@ osdep_get_cwd(int fd)
 struct event_base *
 osdep_event_init(void)
 {
+	struct event_base	*base;
+
 	/* On Linux, epoll doesn't work on /dev/null (yes, really). */
 	setenv("EVENT_NOEPOLL", "1", 1);
-	return (event_init());
+
+	base = event_init();
+	unsetenv("EVENT_NOEPOLL");
+	return (base);
 }

osdep-netbsd.c

@@ -23,14 +23,17 @@
 
 #include <errno.h>
 #include <event.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
+#include "tmux.h"
+
 #define is_runnable(p) \
-        ((p)->p_stat == LSRUN || (p)->p_stat == SIDL)
+	((p)->p_stat == LSRUN || (p)->p_stat == SIDL)
 #define is_stopped(p) \
-        ((p)->p_stat == SSTOP || (p)->p_stat == SZOMB)
+	((p)->p_stat == SSTOP || (p)->p_stat == SZOMB)
 
 struct kinfo_proc2	*cmp_procs(struct kinfo_proc2 *, struct kinfo_proc2 *);
 char			*osdep_get_name(int, char *);
@@ -129,6 +132,22 @@ error:
 char *
 osdep_get_cwd(int fd)
 {
+	static char	target[PATH_MAX + 1];
+	char		*path;
+	pid_t		pgrp;
+	ssize_t		n;
+
+	if ((pgrp = tcgetpgrp(fd)) == -1)
+		return (NULL);
+
+	xasprintf(&path, "/proc/%lld/cwd", (long long) pgrp);
+	n = readlink(path, target, sizeof(target) - 1);
+	free(path);
+	if (n > 0) {
+		target[n] = '\0';
+		return (target);
+	}
+
 	return (NULL);
 }
 

regress/Makefile

@@ -7,3 +7,4 @@ all: $(TESTS)
 
 $(TESTS):
 	sh $*.sh
+	sleep 1

regress/control-client-size.sh

@@ -18,32 +18,32 @@ trap "rm -f $TMP $OUT" 0 1 15
 $TMUX -f/dev/null new -d || exit 1
 sleep 1
 cat <<EOF|$TMUX -C a >$TMP
-ls -F':#{session_width} #{session_height}'
+ls -F':#{window_width} #{window_height}'
 refresh -C 100,50
-ls -F':#{session_width} #{session_height}'
+ls -F':#{window_width} #{window_height}'
 EOF
 grep ^: $TMP >$OUT
-printf ":80 24\n:100 50\n"|cmp -s $OUT || exit 1
+printf ":80 24\n:100 49\n"|cmp -s $OUT - || exit 1
 $TMUX kill-server 2>/dev/null
 
 $TMUX -f/dev/null new -d || exit 1
 sleep 1
-cat <<EOF|$TMUX -C a >$TMP
-ls -F':#{session_width} #{session_height}'
+cat <<EOF|$TMUX -f/dev/null -C a >$TMP
+ls -F':#{window_width} #{window_height}'
 refresh -C 80,24
-ls -F':#{session_width} #{session_height}'
+ls -F':#{window_width} #{window_height}'
 EOF
 grep ^: $TMP >$OUT
-printf ":80 24\n:80 24\n"|cmp -s $OUT || exit 1
+printf ":80 24\n:80 23\n"|cmp -s $OUT - || exit 1
 $TMUX kill-server 2>/dev/null
 
-cat <<EOF|$TMUX -C new -x 100 -y 50 >$TMP
-ls -F':#{session_width} #{session_height}'
+cat <<EOF|$TMUX -f/dev/null -C new -x 100 -y 50 >$TMP
+ls -F':#{window_width} #{window_height}'
 refresh -C 80,24
-ls -F':#{session_width} #{session_height}'
+ls -F':#{window_width} #{window_height}'
 EOF
 grep ^: $TMP >$OUT
-printf ":100 50\n:80 24\n"|cmp -s $OUT || exit 1
+printf ":100 50\n:80 23\n"|cmp -s $OUT - || exit 1
 $TMUX kill-server 2>/dev/null
 
 exit 0

regress/cursor-test.txt

@@ -0,0 +1,6 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
+incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
+commodo consequat. Duis aute
+irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
+nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia
+deserunt mollit anim id est laborum.

regress/cursor-test1.result

@@ -0,0 +1,33 @@
+14 8 t
+0 ud exercitation ullamco laboris nisi ut
+1 aliquip ex ea
+2 commodo consequat. Duis aute
+3 irure dolor in reprehenderit in voluptat
+4 e velit esse cillum dolore eu fugiat
+5 nulla pariatur. Excepteur sint occaecat
+6 cupidatat non proident, sunt in culpa qu
+7 i officia
+8 deserunt mollit anim id est laborum.
+9 
+4 6 t
+0 cupidatat
+1 non proide
+2 nt, sunt i
+3 n culpa qu
+4 i officia
+5 deserunt m
+6 ollit anim
+7  id est la
+8 borum.
+9 
+14 8 t
+0 incididunt ut labore et dolore magna aliqua. Ut en
+1 im ad minim veniam, quis nostrud exercitation ulla
+2 mco laboris nisi ut aliquip ex ea
+3 commodo consequat. Duis aute
+4 irure dolor in reprehenderit in voluptate velit es
+5 se cillum dolore eu fugiat
+6 nulla pariatur. Excepteur sint occaecat cupidatat
+7 non proident, sunt in culpa qui officia
+8 deserunt mollit anim id est laborum.
+9 

regress/cursor-test1.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -f/dev/null -Ltest"
+$TMUX kill-server 2>/dev/null
+
+TMP=$(mktemp)
+trap "rm -f $TMP" 0 1 15
+
+$TMUX -f/dev/null new -d -x40 -y10 \
+      "cat cursor-test.txt; printf '\e[9;15H'; cat" || exit 1
+$TMUX set -g window-size manual || exit 1
+
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x10 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x50 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+
+cmp -s $TMP cursor-test1.result || exit 1
+
+$TMUX kill-server 2>/dev/null
+exit 0

regress/cursor-test2.result

@@ -0,0 +1,33 @@
+9 7 a
+0 cupidatat
+1 non proide
+2 nt, sunt i
+3 n culpa qu
+4 i officia
+5 deserunt m
+6 ollit anim
+7  id est la
+8 borum.
+9 
+4 6 a
+0 icia
+1 deser
+2 unt m
+3 ollit
+4  anim
+5  id e
+6 st la
+7 borum
+8 .
+9 
+29 8 a
+0 incididunt ut labore et dolore magna aliqua. Ut en
+1 im ad minim veniam, quis nostrud exercitation ulla
+2 mco laboris nisi ut aliquip ex ea
+3 commodo consequat. Duis aute
+4 irure dolor in reprehenderit in voluptate velit es
+5 se cillum dolore eu fugiat
+6 nulla pariatur. Excepteur sint occaecat cupidatat
+7 non proident, sunt in culpa qui officia
+8 deserunt mollit anim id est laborum.
+9 

regress/cursor-test2.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -Ltest"
+$TMUX kill-server 2>/dev/null
+
+TMP=$(mktemp)
+trap "rm -f $TMP" 0 1 15
+
+$TMUX -f/dev/null new -d -x10 -y10 \
+      "cat cursor-test.txt; printf '\e[8;10H'; cat" || exit 1
+$TMUX set -g window-size manual || exit 1
+
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x5 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x50 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+
+cmp -s $TMP cursor-test2.result || exit 1
+
+$TMUX kill-server 2>/dev/null
+exit 0

regress/cursor-test3.result

@@ -0,0 +1,9 @@
+6 1 b
+0 abcdefa
+1 bcdefab
+3 1 b
+0 fabcd
+1 efab
+6 1 b
+0 abcdefa
+1 bcdefab

regress/cursor-test3.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -Ltest"
+$TMUX kill-server 2>/dev/null
+
+TMP=$(mktemp)
+trap "rm -f $TMP" 0 1 15
+
+$TMUX -f/dev/null new -d -x7 -y2 \
+      "printf 'abcdefabcdefab'; printf '\e[2;7H'; cat" || exit 1
+$TMUX set -g window-size manual || exit 1
+
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x5 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x7 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+
+cmp -s $TMP cursor-test3.result || exit 1
+
+$TMUX kill-server 2>/dev/null
+exit 0

regress/cursor-test4.result

@@ -0,0 +1,16 @@
+0 1  
+0 abcdef
+1 
+2 
+0 1  
+0 abcdef
+1 
+2 
+0 1  
+0 def
+1 
+2 
+0 1  
+0 abcdef
+1 
+2 

regress/cursor-test4.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -Ltest"
+$TMUX kill-server 2>/dev/null
+
+TMP=$(mktemp)
+trap "rm -f $TMP" 0 1 15
+
+$TMUX -f/dev/null new -d -x10 -y3 "printf 'abcdef\n'; cat" || exit 1
+$TMUX set -g window-size manual || exit 1
+
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x20 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x3 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+$TMUX resizew -x10 || exit 1
+$TMUX display -pF '#{cursor_x} #{cursor_y} #{cursor_character}' >>$TMP
+$TMUX capturep -p|awk '{print NR-1,$0}' >>$TMP
+
+cmp -s $TMP cursor-test4.result || exit 1
+
+$TMUX kill-server 2>/dev/null
+exit 0

regress/format-strings.sh

@@ -0,0 +1,183 @@
+#!/bin/sh
+
+# Tests of formats as described in tmux(1) FORMATS
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -Ltest"
+
+# test_format $format $expected_result
+test_format()
+{
+	fmt="$1"
+	exp="$2"
+
+	out=$($TMUX display-message -p "$fmt")
+
+	if [ "$out" != "$exp" ]; then
+		echo "Format test failed for '$fmt'."
+		echo "Expected: '$exp'"
+		echo "But got   '$out'"
+		exit 1
+	fi
+}
+
+# test_conditional_with_pane_in_mode $format $exp1 $exp2
+#
+# Tests the format string $format to yield $exp1 if #{pane_in_mode} is true and
+# $exp2 when #{pane_in_mode} is false.
+test_conditional_with_pane_in_mode()
+{
+	fmt="$1"
+	exp_true="$2"
+	exp_false="$3"
+
+	$TMUX copy-mode # enter copy mode
+	test_format "$fmt" "$exp_true"
+	$TMUX send-keys -X cancel # leave copy mode
+	test_format "$fmt" "$exp_false"
+}
+
+# test_conditional_with_session_name #format $exp_summer $exp_winter
+#
+# Tests the format string $format to yield $exp_summer if the session name is
+# 'Summer' and $exp_winter if the session name is 'Winter'.
+test_conditional_with_session_name()
+{
+	fmt="$1"
+	exp_summer="$2"
+	exp_winter="$3"
+
+	$TMUX rename-session "Summer"
+	test_format "$fmt" "$exp_summer"
+	$TMUX rename-session "Winter"
+	test_format "$fmt" "$exp_winter"
+	$TMUX rename-session "Summer" # restore default
+}
+
+
+$TMUX kill-server 2>/dev/null
+$TMUX -f/dev/null new-session -d || exit 1
+$TMUX rename-session "Summer" || exit 1 # used later in conditionals
+
+# Plain string without substitutions et al
+test_format "abc xyz" "abc xyz"
+
+# Test basic escapes for "#", "{", "#{" "}", "#}", ","
+test_format "##" "#"
+test_format "#," ","
+test_format "{" "{"
+test_format "##{" "#{"
+test_format "#}" "}"
+test_format "###}" "#}" # not a "basic" one but interesting nevertheless
+
+# Simple expansion
+test_format "#{pane_in_mode}" "0"
+
+# Simple conditionals
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,xyz}" "abc" "xyz"
+
+# Expansion in conditionals
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#{session_name},xyz}" "Summer" "xyz"
+
+# Basic escapes in conditionals
+# First argument
+test_conditional_with_pane_in_mode "#{?pane_in_mode,##,xyz}" "#" "xyz"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#,,xyz}" "," "xyz"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,{,xyz}" "{" "xyz"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,##{,xyz}" "#{" "xyz"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#},xyz}" "}" "xyz"
+# not a "basic" one but interesting nevertheless
+test_conditional_with_pane_in_mode "#{?pane_in_mode,###},xyz}" "#}" "xyz"
+# Second argument
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,##}" "abc" "#"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,#,}" "abc" ","
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,{}" "abc" "{"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,##{}" "abc" "#{"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,#}}" "abc" "}"
+# not a "basic" one but interesting nevertheless
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,###}}" "abc" "#}"
+# mixed
+test_conditional_with_pane_in_mode "#{?pane_in_mode,{,#}}" "{" "}"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#},{}" "}" "{"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,##{,###}}" "#{" "#}"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,###},##{}" "#}" "#{"
+
+# Conditionals split on the second comma (this is not documented)
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,xyz,bonus}" "abc" "xyz,bonus"
+
+# Curly brackets {...} do not capture a comma inside of conditionals as the
+# conditional ends on the first '}'
+test_conditional_with_pane_in_mode "#{?pane_in_mode,{abc,xyz},bonus}" "{abc,bonus}" "xyz,bonus}"
+
+# Substitutions '#{...}' capture the comma
+# invalid format: #{abc,xyz} is not a known variable name.
+#test_conditional_with_pane_in_mode "#{?pane_in_mode,#{abc,xyz},bonus}" "" "bonus"
+
+# Parenthesis (...) do not captura a comma
+test_conditional_with_pane_in_mode "#{?pane_in_mode,(abc,xyz),bonus}" "(abc" "xyz),bonus"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,(abc#,xyz),bonus}" "(abc,xyz)" "bonus"
+
+# Brackets [...] do not captura a comma
+test_conditional_with_pane_in_mode "#{?pane_in_mode,[abc,xyz],bonus}" "[abc" "xyz],bonus"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,[abc#,xyz],bonus}" "[abc,xyz]" "bonus"
+
+
+# Escape comma inside of #(...)
+# Note: #() commands are run asynchronous and are substituted with result of the
+# *previous* run or a placeholder (like "<'echo ,' not ready") if the command
+# has not been run before. The format is updated as soon as the command
+# finishes. As we are printing the message only once it never gets updated
+# and the displayed message is "<'echo ,' not ready>"
+test_format "#{?pane_in_mode,#(echo #,),xyz}" "xyz"
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#(echo #,),xyz}" "<'echo ,' not ready>" "xyz"
+# This caching does not work :-(
+#$TMUX display-message -p "#(echo #,)" > /dev/null
+#test_conditional_with_pane_in_mode "#{?pane_in_mode,#(echo #,),xyz}" "," "xyz"
+#test_conditional_with_pane_in_mode "#{?pane_in_mode,#(echo #,),xyz}" "," "xyz"
+
+# invalid format: '#(' is not closed in the first argument of #{?,,}.
+#test_conditional_with_pane_in_mode "#{?pane_in_mode,#(echo ,),xyz}" "" "),xyz"
+
+# Escape comma inside of #[...]
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#[fg=default#,bg=default]abc,xyz}" "#[fg=default,bg=default]abc" "xyz"
+# invalid format: '#[' is not closed in the first argument of #{?,,}
+#test_conditional_with_pane_in_mode "#{?pane_in_mode,#[fg=default,bg=default]abc,xyz}" "" "bg=default]abc,xyz"
+
+# Conditionals with comparison
+test_conditional_with_session_name "#{?#{==:#{session_name},Summer},abc,xyz}" "abc" "xyz"
+# Conditionals with comparison and escaped commas
+$TMUX rename-session ","
+test_format "#{?#{==:#,,#{session_name}},abc,xyz}" "abc"
+$TMUX rename-session "Summer" # reset to default
+
+# Conditional in conditional
+test_conditional_with_pane_in_mode "#{?pane_in_mode,#{?#{==:#{session_name},Summer},ABC,XYZ},xyz}" "ABC" "xyz"
+test_conditional_with_session_name "#{?pane_in_mode,#{?#{==:#{session_name},Summer},ABC,XYZ},xyz}" "xyz" "xyz"
+
+test_conditional_with_pane_in_mode "#{?pane_in_mode,abc,#{?#{==:#{session_name},Summer},ABC,XYZ}}" "abc" "ABC"
+test_conditional_with_session_name "#{?pane_in_mode,abc,#{?#{==:#{session_name},Summer},ABC,XYZ}}" "ABC" "XYZ"
+
+# Some fancy stackings
+test_conditional_with_pane_in_mode "#{?#{==:#{?pane_in_mode,#{session_name},#(echo Spring)},Summer},abc,xyz}" "abc" "xyz"
+
+
+
+# Format test for the literal option
+# Note: The behavior for #{l:...} with escapes is sometimes weird as #{l:...}
+# respects the escapes.
+test_format "#{l:#{}}" "#{}"
+test_format "#{l:#{pane_in_mode}}" "#{pane_in_mode}"
+test_format "#{l:#{?pane_in_mode,#{?#{==:#{session_name},Summer},ABC,XYZ},xyz}}" "#{?pane_in_mode,#{?#{==:#{session_name},Summer},ABC,XYZ},xyz}"
+
+# With escapes (which escape but are returned literally)
+test_format "#{l:##{}" "##{"
+test_format "#{l:#{#}}}" "#{#}}"
+
+# Invalid formats:
+#test_format "#{l:#{}" ""
+#test_format "#{l:#{#}}" ""
+
+exit 0

regress/kill-session-process-exit.sh

@@ -9,9 +9,9 @@ TERM=screen
 TMUX="$TEST_TMUX -Ltest"
 $TMUX kill-server 2>/dev/null
 
-$TMUX new -d 'sleep 1000' || exit 1
+$TMUX -f/dev/null new -d 'sleep 1000' || exit 1
 P=$($TMUX display -pt0:0.0 '#{pane_pid}')
-$TMUX new -d || exit 1
+$TMUX -f/dev/null new -d || exit 1
 sleep 1
 $TMUX kill-session -t0:
 sleep 1

regress/new-session-size.sh

@@ -14,14 +14,14 @@ trap "rm -f $TMP" 0 1 15
 
 $TMUX -f/dev/null new -d </dev/null || exit 1
 sleep 1
-$TMUX ls -F "#{session_width} #{session_height}" >$TMP
-printf "80 24\n"|cmp -s $TMP || exit 1
+$TMUX ls -F "#{window_width} #{window_height}" >$TMP
+printf "80 24\n"|cmp -s $TMP - || exit 1
 $TMUX kill-server 2>/dev/null
 
 $TMUX -f/dev/null new -d -x 100 -y 50 </dev/null || exit 1
 sleep 1
-$TMUX ls -F "#{session_width} #{session_height}" >$TMP
-printf "100 50\n"|cmp -s $TMP || exit 1
+$TMUX ls -F "#{window_width} #{window_height}" >$TMP
+printf "100 50\n"|cmp -s $TMP - || exit 1
 $TMUX kill-server 2>/dev/null
 
 exit 0

resize.c

@@ -22,147 +22,234 @@
 
 #include "tmux.h"
 
-/*
- * Recalculate window and session sizes.
- *
- * Every session has the size of the smallest client it is attached to and
- * every window the size of the smallest session it is attached to.
- *
- * So, when a client is resized or a session attached to or detached from a
- * client, the window sizes must be recalculated. For each session, find the
- * smallest client it is attached to, and resize it to that size. Then for
- * every window, find the smallest session it is attached to, resize it to that
- * size and clear and redraw every client with it as the current window.
- *
- * This is quite inefficient - better/additional data structures are needed
- * to make it better.
- *
- * As a side effect, this function updates the SESSION_UNATTACHED flag. This
- * flag is necessary to make sure unattached sessions do not limit the size of
- * windows that are attached both to them and to other (attached) sessions.
- */
+void
+resize_window(struct window *w, u_int sx, u_int sy)
+{
+	int	zoomed;
+
+	/* Check size limits. */
+	if (sx < WINDOW_MINIMUM)
+		sx = WINDOW_MINIMUM;
+	if (sx > WINDOW_MAXIMUM)
+		sx = WINDOW_MAXIMUM;
+	if (sy < WINDOW_MINIMUM)
+		sy = WINDOW_MINIMUM;
+	if (sy > WINDOW_MAXIMUM)
+		sy = WINDOW_MAXIMUM;
+
+	/* If the window is zoomed, unzoom. */
+	zoomed = w->flags & WINDOW_ZOOMED;
+	if (zoomed)
+		window_unzoom(w);
+
+	/* Resize the layout first. */
+	layout_resize(w, sx, sy);
+
+	/* Resize the window, it can be no smaller than the layout. */
+	if (sx < w->layout_root->sx)
+		sx = w->layout_root->sx;
+	if (sy < w->layout_root->sy)
+		sy = w->layout_root->sy;
+	window_resize(w, sx, sy);
+	log_debug("%s: @%u resized to %u,%u; layout %u,%u", __func__, w->id,
+	    sx, sy, w->layout_root->sx, w->layout_root->sy);
+
+	/* Restore the window zoom state. */
+	if (zoomed)
+		window_zoom(w->active);
+
+	tty_update_window_offset(w);
+	server_redraw_window(w);
+	notify_window("window-layout-changed", w);
+}
+
+static int
+ignore_client_size(struct client *c)
+{
+	if (c->session == NULL)
+		return (1);
+	if (c->flags & CLIENT_NOSIZEFLAGS)
+		return (1);
+	if ((c->flags & CLIENT_CONTROL) && (~c->flags & CLIENT_SIZECHANGED))
+		return (1);
+	return (0);
+}
+
+void
+default_window_size(struct session *s, struct window *w, u_int *sx, u_int *sy,
+    int type)
+{
+	struct client	*c;
+	u_int		 cx, cy;
+	const char	*value;
+
+	if (type == -1)
+		type = options_get_number(global_w_options, "window-size");
+	if (type == WINDOW_SIZE_MANUAL)
+		goto manual;
+
+	if (type == WINDOW_SIZE_LARGEST) {
+		*sx = *sy = 0;
+		TAILQ_FOREACH(c, &clients, entry) {
+			if (ignore_client_size(c))
+				continue;
+			if (w != NULL && !session_has(c->session, w))
+				continue;
+			if (w == NULL && c->session != s)
+				continue;
+
+			cx = c->tty.sx;
+			cy = c->tty.sy - status_line_size(c);
+
+			if (cx > *sx)
+				*sx = cx;
+			if (cy > *sy)
+				*sy = cy;
+		}
+		if (*sx == 0 || *sy == 0)
+			goto manual;
+	} else {
+		*sx = *sy = UINT_MAX;
+		TAILQ_FOREACH(c, &clients, entry) {
+			if (ignore_client_size(c))
+				continue;
+			if (w != NULL && !session_has(c->session, w))
+				continue;
+			if (w == NULL && c->session != s)
+				continue;
+
+			cx = c->tty.sx;
+			cy = c->tty.sy - status_line_size(c);
+
+			if (cx < *sx)
+				*sx = cx;
+			if (cy < *sy)
+				*sy = cy;
+		}
+		if (*sx == UINT_MAX || *sy == UINT_MAX)
+			goto manual;
+	}
+	goto done;
+
+manual:
+	value = options_get_string(s->options, "default-size");
+	if (sscanf(value, "%ux%u", sx, sy) != 2) {
+		*sx = 80;
+		*sy = 24;
+	}
+
+done:
+	if (*sx < WINDOW_MINIMUM)
+		*sx = WINDOW_MINIMUM;
+	if (*sx > WINDOW_MAXIMUM)
+		*sx = WINDOW_MAXIMUM;
+	if (*sy < WINDOW_MINIMUM)
+		*sy = WINDOW_MINIMUM;
+	if (*sy > WINDOW_MAXIMUM)
+		*sy = WINDOW_MAXIMUM;
+}
 
 void
 recalculate_sizes(void)
 {
-	struct session		*s;
-	struct client		*c;
-	struct window		*w;
-	struct window_pane	*wp;
-	u_int			 ssx, ssy, has, limit;
-	int			 flag, has_status, is_zoomed, forced;
+	struct session	*s;
+	struct client	*c;
+	struct window	*w;
+	u_int		 sx, sy, cx, cy;
+	int		 type, current, has, changed;
 
+	/*
+	 * Clear attached count and update saved status line information for
+	 * each session.
+	 */
 	RB_FOREACH(s, sessions, &sessions) {
-		has_status = options_get_number(s->options, "status");
-
 		s->attached = 0;
-		ssx = ssy = UINT_MAX;
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->flags & CLIENT_SUSPENDED)
-				continue;
-			if ((c->flags & (CLIENT_CONTROL|CLIENT_SIZECHANGED)) ==
-			    CLIENT_CONTROL)
-				continue;
-			if (c->session == s) {
-				if (c->tty.sx < ssx)
-					ssx = c->tty.sx;
-				if (has_status &&
-				    !(c->flags & CLIENT_CONTROL) &&
-				    c->tty.sy > 1 && c->tty.sy - 1 < ssy)
-					ssy = c->tty.sy - 1;
-				else if (c->tty.sy < ssy)
-					ssy = c->tty.sy;
-				s->attached++;
-			}
-		}
-		if (ssx == UINT_MAX || ssy == UINT_MAX) {
-			s->flags |= SESSION_UNATTACHED;
-			continue;
-		}
-		s->flags &= ~SESSION_UNATTACHED;
-
-		if (has_status && ssy == 0)
-			ssy = 1;
-
-		if (s->sx == ssx && s->sy == ssy)
-			continue;
-
-		log_debug("session $%u size %u,%u (was %u,%u)", s->id, ssx, ssy,
-		    s->sx, s->sy);
-
-		s->sx = ssx;
-		s->sy = ssy;
-
-		status_update_saved(s);
+		status_update_cache(s);
 	}
 
+	/*
+	 * Increment attached count and check the status line size for each
+	 * client.
+	 */
+	TAILQ_FOREACH(c, &clients, entry) {
+		if (ignore_client_size(c))
+			continue;
+		if (c->tty.sy <= status_line_size(c))
+			c->flags |= CLIENT_STATUSOFF;
+		else
+			c->flags &= ~CLIENT_STATUSOFF;
+		c->session->attached++;
+	}
+
+	/* Walk each window and adjust the size. */
 	RB_FOREACH(w, windows, &windows) {
 		if (w->active == NULL)
 			continue;
-		flag = options_get_number(w->options, "aggressive-resize");
+		log_debug("%s: @%u is %u,%u", __func__, w->id, w->sx, w->sy);
 
-		ssx = ssy = UINT_MAX;
-		RB_FOREACH(s, sessions, &sessions) {
-			if (s->flags & SESSION_UNATTACHED)
-				continue;
-			if (flag)
-				has = s->curw->window == w;
-			else
-				has = session_has(s, w);
-			if (has) {
-				if (s->sx < ssx)
-					ssx = s->sx;
-				if (s->sy < ssy)
-					ssy = s->sy;
+		type = options_get_number(w->options, "window-size");
+		if (type == WINDOW_SIZE_MANUAL)
+			continue;
+		current = options_get_number(w->options, "aggressive-resize");
+
+		changed = 1;
+		if (type == WINDOW_SIZE_LARGEST) {
+			sx = sy = 0;
+			TAILQ_FOREACH(c, &clients, entry) {
+				if (ignore_client_size(c))
+					continue;
+				s = c->session;
+
+				if (current)
+					has = (s->curw->window == w);
+				else
+					has = session_has(s, w);
+				if (!has)
+					continue;
+
+				cx = c->tty.sx;
+				cy = c->tty.sy - status_line_size(c);
+
+				if (cx > sx)
+					sx = cx;
+				if (cy > sy)
+					sy = cy;
 			}
+			if (sx == 0 || sy == 0)
+				changed = 0;
+		} else {
+			sx = sy = UINT_MAX;
+			TAILQ_FOREACH(c, &clients, entry) {
+				if (ignore_client_size(c))
+					continue;
+				s = c->session;
+
+				if (current)
+					has = (s->curw->window == w);
+				else
+					has = session_has(s, w);
+				if (!has)
+					continue;
+
+				cx = c->tty.sx;
+				cy = c->tty.sy - status_line_size(c);
+
+				if (cx < sx)
+					sx = cx;
+				if (cy < sy)
+					sy = cy;
+			}
+			if (sx == UINT_MAX || sy == UINT_MAX)
+				changed = 0;
 		}
-		if (ssx == UINT_MAX || ssy == UINT_MAX)
+		if (w->sx == sx && w->sy == sy)
+			changed = 0;
+
+		if (!changed) {
+			tty_update_window_offset(w);
 			continue;
-
-		forced = 0;
-		limit = options_get_number(w->options, "force-width");
-		if (limit >= PANE_MINIMUM && ssx > limit) {
-			ssx = limit;
-			forced |= WINDOW_FORCEWIDTH;
 		}
-		limit = options_get_number(w->options, "force-height");
-		if (limit >= PANE_MINIMUM && ssy > limit) {
-			ssy = limit;
-			forced |= WINDOW_FORCEHEIGHT;
-		}
-
-		if (w->sx == ssx && w->sy == ssy)
-			continue;
-		log_debug("window @%u size %u,%u (was %u,%u)", w->id, ssx, ssy,
-		    w->sx, w->sy);
-
-		w->flags &= ~(WINDOW_FORCEWIDTH|WINDOW_FORCEHEIGHT);
-		w->flags |= forced;
-
-		is_zoomed = w->flags & WINDOW_ZOOMED;
-		if (is_zoomed)
-			window_unzoom(w);
-		layout_resize(w, ssx, ssy);
-		window_resize(w, ssx, ssy);
-		if (is_zoomed && window_pane_visible(w->active))
-			window_zoom(w->active);
-
-		/*
-		 * If the current pane is now not visible, move to the next
-		 * that is.
-		 */
-		wp = w->active;
-		while (!window_pane_visible(w->active)) {
-			w->active = TAILQ_PREV(w->active, window_panes, entry);
-			if (w->active == NULL)
-				w->active = TAILQ_LAST(&w->panes, window_panes);
-			if (w->active == wp)
-			       break;
-		}
-		if (w->active == w->last)
-			w->last = NULL;
-
-		server_redraw_window(w);
-		notify_window("window-layout-changed", w);
+		log_debug("%s: @%u changed to %u,%u", __func__, w->id, sx, sy);
+		resize_window(w, sx, sy);
 	}
 }

screen-redraw.c

@@ -18,26 +18,32 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
 
-static int	screen_redraw_cell_border1(struct window_pane *, u_int, u_int);
-static int	screen_redraw_cell_border(struct client *, u_int, u_int);
-static int	screen_redraw_check_cell(struct client *, u_int, u_int, int,
-		    struct window_pane **);
-static int	screen_redraw_check_is(u_int, u_int, int, int, struct window *,
-		    struct window_pane *, struct window_pane *);
+struct screen_redraw_ctx {
+	struct client	*c;
 
-static int 	screen_redraw_make_pane_status(struct client *, struct window *,
+	u_int		 lines;
+	int		 top;
+
+	int		 pane_status;
+
+	u_int		 sx;
+	u_int		 sy;
+	u_int		 ox;
+	u_int		 oy;
+};
+
+static void	screen_redraw_draw_borders(struct screen_redraw_ctx *);
+static void	screen_redraw_draw_panes(struct screen_redraw_ctx *);
+static void	screen_redraw_draw_status(struct screen_redraw_ctx *);
+static void	screen_redraw_draw_pane(struct screen_redraw_ctx *,
+		    struct window_pane *);
+static void	screen_redraw_draw_number(struct screen_redraw_ctx *,
 		    struct window_pane *);
-static void	screen_redraw_draw_pane_status(struct client *, int);
-
-static void	screen_redraw_draw_borders(struct client *, int, int, u_int);
-static void	screen_redraw_draw_panes(struct client *, u_int);
-static void	screen_redraw_draw_status(struct client *, u_int);
-static void	screen_redraw_draw_number(struct client *, struct window_pane *,
-		    u_int);
 
 #define CELL_INSIDE 0
 #define CELL_LEFTRIGHT 1
@@ -268,8 +274,8 @@ screen_redraw_make_pane_status(struct client *c, struct window *w,
 	struct grid_cell	 gc;
 	const char		*fmt;
 	struct format_tree	*ft;
-	char			*out;
-	size_t			 outlen;
+	char			*expanded;
+	u_int			 width, i;
 	struct screen_write_ctx	 ctx;
 	struct screen		 old;
 
@@ -283,26 +289,30 @@ screen_redraw_make_pane_status(struct client *c, struct window *w,
 	ft = format_create(c, NULL, FORMAT_PANE|wp->id, 0);
 	format_defaults(ft, c, NULL, NULL, wp);
 
+	expanded = format_expand_time(ft, fmt);
+	if (wp->sx < 4)
+		wp->status_size = width = 0;
+	else
+		wp->status_size = width = wp->sx - 4;
+
 	memcpy(&old, &wp->status_screen, sizeof old);
-	screen_init(&wp->status_screen, wp->sx, 1, 0);
+	screen_init(&wp->status_screen, width, 1, 0);
 	wp->status_screen.mode = 0;
 
-	out = format_expand(ft, fmt);
-	outlen = screen_write_cstrlen("%s", out);
-	if (outlen > wp->sx - 4)
-		outlen = wp->sx - 4;
-	screen_resize(&wp->status_screen, outlen, 1, 0);
-
 	screen_write_start(&ctx, NULL, &wp->status_screen);
-	screen_write_cursormove(&ctx, 0, 0);
-	screen_write_clearline(&ctx, 8);
-	screen_write_cnputs(&ctx, outlen, &gc, "%s", out);
+
+	gc.attr |= GRID_ATTR_CHARSET;
+	for (i = 0; i < width; i++)
+		screen_write_putc(&ctx, &gc, 'q');
+	gc.attr &= ~GRID_ATTR_CHARSET;
+
+	screen_write_cursormove(&ctx, 0, 0, 0);
+	format_draw(&ctx, &gc, width, expanded, NULL);
 	screen_write_stop(&ctx);
 
+	free(expanded);
 	format_free(ft);
 
-	wp->status_size = outlen;
-
 	if (grid_compare(wp->status_screen.grid, old.grid) == 0) {
 		screen_free(&old);
 		return (0);
@@ -313,35 +323,67 @@ screen_redraw_make_pane_status(struct client *c, struct window *w,
 
 /* Draw pane status. */
 static void
-screen_redraw_draw_pane_status(struct client *c, int pane_status)
+screen_redraw_draw_pane_status(struct screen_redraw_ctx *ctx)
 {
+	struct client		*c = ctx->c;
 	struct window		*w = c->session->curw->window;
-	struct options		*oo = c->session->options;
 	struct tty		*tty = &c->tty;
 	struct window_pane	*wp;
-	int			 spos;
-	u_int			 yoff;
+	struct screen		*s;
+	u_int			 i, x, width, xoff, yoff, size;
+
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
 
-	spos = options_get_number(oo, "status-position");
 	TAILQ_FOREACH(wp, &w->panes, entry) {
 		if (!window_pane_visible(wp))
 			continue;
-		if (pane_status == CELL_STATUS_TOP)
+		s = &wp->status_screen;
+
+		size = wp->status_size;
+		if (ctx->pane_status == CELL_STATUS_TOP)
 			yoff = wp->yoff - 1;
 		else
 			yoff = wp->yoff + wp->sy;
-		if (spos == 0)
-			yoff += 1;
+		xoff = wp->xoff + 2;
 
-		tty_draw_line(tty, NULL, &wp->status_screen, 0, wp->xoff + 2,
-		    yoff);
+		if (xoff + size <= ctx->ox ||
+		    xoff >= ctx->ox + ctx->sx ||
+		    yoff < ctx->oy ||
+		    yoff >= ctx->oy + ctx->sy)
+			continue;
+
+		if (xoff >= ctx->ox && xoff + size <= ctx->ox + ctx->sx) {
+			/* All visible. */
+			i = 0;
+			x = xoff - ctx->ox;
+			width = size;
+		} else if (xoff < ctx->ox && xoff + size > ctx->ox + ctx->sx) {
+			/* Both left and right not visible. */
+			i = ctx->ox;
+			x = 0;
+			width = ctx->sx;
+		} else if (xoff < ctx->ox) {
+			/* Left not visible. */
+			i = ctx->ox - xoff;
+			x = 0;
+			width = size - i;
+		} else {
+			/* Right not visible. */
+			i = 0;
+			x = xoff - ctx->ox;
+			width = size - x;
+		}
+
+		if (ctx->top)
+			yoff += ctx->lines;
+		tty_draw_line(tty, NULL, s, i, 0, width, x, yoff - ctx->oy);
 	}
 	tty_cursor(tty, 0, 0);
 }
 
 /* Update status line and change flags if unchanged. */
-void
-screen_redraw_update(struct client *c)
+static int
+screen_redraw_update(struct client *c, int flags)
 {
 	struct window		*w = c->session->curw->window;
 	struct window_pane	*wp;
@@ -354,8 +396,8 @@ screen_redraw_update(struct client *c)
 		redraw = status_prompt_redraw(c);
 	else
 		redraw = status_redraw(c);
-	if (!redraw)
-		c->flags &= ~CLIENT_STATUS;
+	if (!redraw && (~flags & CLIENT_REDRAWSTATUSALWAYS))
+		flags &= ~CLIENT_REDRAWSTATUS;
 
 	if (options_get_number(wo, "pane-border-status") != CELL_STATUS_OFF) {
 		redraw = 0;
@@ -364,115 +406,128 @@ screen_redraw_update(struct client *c)
 				redraw = 1;
 		}
 		if (redraw)
-			c->flags |= CLIENT_BORDERS;
+			flags |= CLIENT_REDRAWBORDERS;
 	}
+	return (flags);
+}
+
+/* Set up redraw context. */
+static void
+screen_redraw_set_context(struct client *c, struct screen_redraw_ctx *ctx)
+{
+	struct session	*s = c->session;
+	struct options	*oo = s->options;
+	struct window	*w = s->curw->window;
+	struct options	*wo = w->options;
+
+	memset(ctx, 0, sizeof *ctx);
+	ctx->c = c;
+
+	ctx->lines = status_line_size(c);
+	if (c->message_string != NULL || c->prompt_string != NULL)
+		ctx->lines = (ctx->lines == 0) ? 1 : ctx->lines;
+	if (ctx->lines != 0 && options_get_number(oo, "status-position") == 0)
+		ctx->top = 1;
+	ctx->pane_status = options_get_number(wo, "pane-border-status");
+
+	tty_window_offset(&c->tty, &ctx->ox, &ctx->oy, &ctx->sx, &ctx->sy);
+
+	log_debug("%s: %s @%u ox=%u oy=%u sx=%u sy=%u %u/%d", __func__, c->name,
+	    w->id, ctx->ox, ctx->oy, ctx->sx, ctx->sy, ctx->lines, ctx->top);
 }
 
 /* Redraw entire screen. */
 void
-screen_redraw_screen(struct client *c, int draw_panes, int draw_status,
-    int draw_borders)
+screen_redraw_screen(struct client *c)
 {
-	struct options		*oo = c->session->options;
-	struct tty		*tty = &c->tty;
-	struct window		*w = c->session->curw->window;
-	struct options		*wo = w->options;
-	u_int			 top;
-	int	 		 status, pane_status, spos;
+	struct screen_redraw_ctx	ctx;
+	int				flags;
 
-	/* Suspended clients should not be updated. */
 	if (c->flags & CLIENT_SUSPENDED)
 		return;
 
-	/* Get status line, er, status. */
-	spos = options_get_number(oo, "status-position");
-	if (c->message_string != NULL || c->prompt_string != NULL)
-		status = 1;
-	else
-		status = options_get_number(oo, "status");
-	top = 0;
-	if (status && spos == 0)
-		top = 1;
-	if (!status)
-		draw_status = 0;
+	flags = screen_redraw_update(c, c->flags);
+	screen_redraw_set_context(c, &ctx);
 
-	/* Draw the elements. */
-	if (draw_borders) {
-		pane_status = options_get_number(wo, "pane-border-status");
-		screen_redraw_draw_borders(c, status, pane_status, top);
-		if (pane_status != CELL_STATUS_OFF)
-			screen_redraw_draw_pane_status(c, pane_status);
+	if (flags & (CLIENT_REDRAWWINDOW|CLIENT_REDRAWBORDERS)) {
+		if (ctx.pane_status != CELL_STATUS_OFF)
+			screen_redraw_draw_pane_status(&ctx);
+		screen_redraw_draw_borders(&ctx);
 	}
-	if (draw_panes)
-		screen_redraw_draw_panes(c, top);
-	if (draw_status)
-		screen_redraw_draw_status(c, top);
-	tty_reset(tty);
+	if (flags & CLIENT_REDRAWWINDOW)
+		screen_redraw_draw_panes(&ctx);
+	if (ctx.lines != 0 &&
+	    (flags & (CLIENT_REDRAWSTATUS|CLIENT_REDRAWSTATUSALWAYS)))
+		screen_redraw_draw_status(&ctx);
+	tty_reset(&c->tty);
 }
 
-/* Draw a single pane. */
+/* Redraw a single pane. */
 void
 screen_redraw_pane(struct client *c, struct window_pane *wp)
 {
-	u_int	i, yoff;
+	struct screen_redraw_ctx	 ctx;
 
 	if (!window_pane_visible(wp))
 		return;
 
-	yoff = wp->yoff;
-	if (status_at_line(c) == 0)
-		yoff++;
+	screen_redraw_set_context(c, &ctx);
 
-	log_debug("%s: redraw pane %%%u (at %u,%u)", c->name, wp->id,
-	    wp->xoff, yoff);
-
-	for (i = 0; i < wp->sy; i++)
-		tty_draw_pane(&c->tty, wp, i, wp->xoff, yoff);
+	screen_redraw_draw_pane(&ctx, wp);
 	tty_reset(&c->tty);
 }
 
+/* Draw a border cell. */
+static void
+screen_redraw_draw_borders_cell(struct screen_redraw_ctx *ctx, u_int i, u_int j,
+    struct grid_cell *m_active_gc, struct grid_cell *active_gc,
+    struct grid_cell *m_other_gc, struct grid_cell *other_gc)
+{
+	struct client		*c = ctx->c;
+	struct session		*s = c->session;
+	struct window		*w = s->curw->window;
+	struct tty		*tty = &c->tty;
+	struct window_pane	*wp;
+	struct window_pane	*active = w->active;
+	struct window_pane	*marked = marked_pane.wp;
+	u_int			 type, x = ctx->ox + i, y = ctx->oy + j;
+	int			 flag, pane_status = ctx->pane_status;
+
+	type = screen_redraw_check_cell(c, x, y, pane_status, &wp);
+	if (type == CELL_INSIDE)
+		return;
+	flag = screen_redraw_check_is(x, y, type, pane_status, w, active, wp);
+
+	if (server_is_marked(s, s->curw, marked_pane.wp) &&
+	    screen_redraw_check_is(x, y, type, pane_status, w, marked, wp)) {
+		if (flag)
+			tty_attributes(tty, m_active_gc, NULL);
+		else
+			tty_attributes(tty, m_other_gc, NULL);
+	} else if (flag)
+		tty_attributes(tty, active_gc, NULL);
+	else
+		tty_attributes(tty, other_gc, NULL);
+	if (ctx->top)
+		tty_cursor(tty, i, ctx->lines + j);
+	else
+		tty_cursor(tty, i, j);
+	tty_putc(tty, CELL_BORDERS[type]);
+}
+
 /* Draw the borders. */
 static void
-screen_redraw_draw_borders(struct client *c, int status, int pane_status,
-    u_int top)
+screen_redraw_draw_borders(struct screen_redraw_ctx *ctx)
 {
+	struct client		*c = ctx->c;
 	struct session		*s = c->session;
 	struct window		*w = s->curw->window;
-	struct options		*oo = w->options;
 	struct tty		*tty = &c->tty;
-	struct window_pane	*wp;
+	struct options		*oo = w->options;
 	struct grid_cell	 m_active_gc, active_gc, m_other_gc, other_gc;
-	struct grid_cell	 msg_gc;
-	u_int		 	 i, j, type, msgx = 0, msgy = 0;
-	int			 active, small, flags;
-	char			 msg[256];
-	const char		*tmp;
-	size_t			 msglen = 0;
+	u_int		 	 i, j;
 
-	small = (tty->sy - status + top > w->sy) || (tty->sx > w->sx);
-	if (small) {
-		flags = w->flags & (WINDOW_FORCEWIDTH|WINDOW_FORCEHEIGHT);
-		if (flags == (WINDOW_FORCEWIDTH|WINDOW_FORCEHEIGHT))
-			tmp = "force-width, force-height";
-		else if (flags == WINDOW_FORCEWIDTH)
-			tmp = "force-width";
-		else if (flags == WINDOW_FORCEHEIGHT)
-			tmp = "force-height";
-		else
-			tmp = "a smaller client";
-		xsnprintf(msg, sizeof msg, "(size %ux%u from %s)",
-		    w->sx, w->sy, tmp);
-		msglen = strlen(msg);
-
-		if (tty->sy - 1 - status + top > w->sy && tty->sx >= msglen) {
-			msgx = tty->sx - msglen;
-			msgy = tty->sy - 1 - status + top;
-		} else if (tty->sx - w->sx > msglen) {
-			msgx = tty->sx - msglen;
-			msgy = tty->sy - 1 - status + top;
-		} else
-			small = 0;
-	}
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
 
 	style_apply(&other_gc, oo, "pane-border-style");
 	style_apply(&active_gc, oo, "pane-active-border-style");
@@ -483,102 +538,181 @@ screen_redraw_draw_borders(struct client *c, int status, int pane_status,
 	memcpy(&m_active_gc, &active_gc, sizeof m_active_gc);
 	m_active_gc.attr ^= GRID_ATTR_REVERSE;
 
-	for (j = 0; j < tty->sy - status; j++) {
+	for (j = 0; j < tty->sy - ctx->lines; j++) {
 		for (i = 0; i < tty->sx; i++) {
-			type = screen_redraw_check_cell(c, i, j, pane_status,
-			    &wp);
-			if (type == CELL_INSIDE)
-				continue;
-			if (type == CELL_OUTSIDE && small &&
-			    i > msgx && j == msgy)
-				continue;
-			active = screen_redraw_check_is(i, j, type, pane_status,
-			    w, w->active, wp);
-			if (server_is_marked(s, s->curw, marked_pane.wp) &&
-			    screen_redraw_check_is(i, j, type, pane_status, w,
-			    marked_pane.wp, wp)) {
-				if (active)
-					tty_attributes(tty, &m_active_gc, NULL);
-				else
-					tty_attributes(tty, &m_other_gc, NULL);
-			} else if (active)
-				tty_attributes(tty, &active_gc, NULL);
-			else
-				tty_attributes(tty, &other_gc, NULL);
-			tty_cursor(tty, i, top + j);
-			tty_putc(tty, CELL_BORDERS[type]);
+			screen_redraw_draw_borders_cell(ctx, i, j,
+			    &m_active_gc, &active_gc, &m_other_gc, &other_gc);
 		}
 	}
-
-	if (small) {
-		memcpy(&msg_gc, &grid_default_cell, sizeof msg_gc);
-		tty_attributes(tty, &msg_gc, NULL);
-		tty_cursor(tty, msgx, msgy);
-		tty_puts(tty, msg);
-	}
 }
 
 /* Draw the panes. */
 static void
-screen_redraw_draw_panes(struct client *c, u_int top)
+screen_redraw_draw_panes(struct screen_redraw_ctx *ctx)
 {
+	struct client		*c = ctx->c;
 	struct window		*w = c->session->curw->window;
-	struct tty		*tty = &c->tty;
 	struct window_pane	*wp;
-	u_int		 	 i;
+
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
 
 	TAILQ_FOREACH(wp, &w->panes, entry) {
 		if (!window_pane_visible(wp))
 			continue;
-		for (i = 0; i < wp->sy; i++)
-			tty_draw_pane(tty, wp, i, wp->xoff, top + wp->yoff);
+		screen_redraw_draw_pane(ctx, wp);
 		if (c->flags & CLIENT_IDENTIFY)
-			screen_redraw_draw_number(c, wp, top);
+			screen_redraw_draw_number(ctx, wp);
 	}
 }
 
 /* Draw the status line. */
 static void
-screen_redraw_draw_status(struct client *c, u_int top)
+screen_redraw_draw_status(struct screen_redraw_ctx *ctx)
 {
+	struct client	*c = ctx->c;
+	struct window	*w = c->session->curw->window;
 	struct tty	*tty = &c->tty;
+	struct screen	*s = c->status.active;
+	u_int		 i, y;
 
-	if (top)
-		tty_draw_line(tty, NULL, &c->status, 0, 0, 0);
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
+
+	if (ctx->top)
+		y = 0;
 	else
-		tty_draw_line(tty, NULL, &c->status, 0, 0, tty->sy - 1);
+		y = c->tty.sy - ctx->lines;
+	for (i = 0; i < ctx->lines; i++)
+		tty_draw_line(tty, NULL, s, 0, i, UINT_MAX, 0, y + i);
+}
+
+/* Draw one pane. */
+static void
+screen_redraw_draw_pane(struct screen_redraw_ctx *ctx, struct window_pane *wp)
+{
+	struct client	*c = ctx->c;
+	struct window	*w = c->session->curw->window;
+	struct tty	*tty = &c->tty;
+	struct screen	*s;
+	u_int		 i, j, top, x, y, width;
+
+	log_debug("%s: %s @%u %%%u", __func__, c->name, w->id, wp->id);
+
+	if (wp->xoff + wp->sx <= ctx->ox || wp->xoff >= ctx->ox + ctx->sx)
+		return;
+	if (ctx->top)
+		top = ctx->lines;
+	else
+		top = 0;
+
+	s = wp->screen;
+	for (j = 0; j < wp->sy; j++) {
+		if (wp->yoff + j < ctx->oy || wp->yoff + j >= ctx->oy + ctx->sy)
+			continue;
+		y = top + wp->yoff + j - ctx->oy;
+
+		if (wp->xoff >= ctx->ox &&
+		    wp->xoff + wp->sx <= ctx->ox + ctx->sx) {
+			/* All visible. */
+			i = 0;
+			x = wp->xoff - ctx->ox;
+			width = wp->sx;
+		} else if (wp->xoff < ctx->ox &&
+		    wp->xoff + wp->sx > ctx->ox + ctx->sx) {
+			/* Both left and right not visible. */
+			i = ctx->ox;
+			x = 0;
+			width = ctx->sx;
+		} else if (wp->xoff < ctx->ox) {
+			/* Left not visible. */
+			i = ctx->ox - wp->xoff;
+			x = 0;
+			width = wp->sx - i;
+		} else {
+			/* Right not visible. */
+			i = 0;
+			x = wp->xoff - ctx->ox;
+			width = ctx->sx - x;
+		}
+		log_debug("%s: %s %%%u line %u,%u at %u,%u, width %u",
+		    __func__, c->name, wp->id, i, j, x, y, width);
+
+		tty_draw_line(tty, wp, s, i, j, width, x, y);
+	}
 }
 
 /* Draw number on a pane. */
 static void
-screen_redraw_draw_number(struct client *c, struct window_pane *wp, u_int top)
+screen_redraw_draw_number(struct screen_redraw_ctx *ctx, struct window_pane *wp)
 {
+	struct client		*c = ctx->c;
 	struct tty		*tty = &c->tty;
 	struct session		*s = c->session;
 	struct options		*oo = s->options;
 	struct window		*w = wp->window;
 	struct grid_cell	 gc;
-	u_int			 idx, px, py, i, j, xoff, yoff;
+	u_int			 idx, px, py, i, j, xoff, yoff, sx, sy;
 	int			 colour, active_colour;
 	char			 buf[16], *ptr;
 	size_t			 len;
 
+	if (wp->xoff + wp->sx <= ctx->ox ||
+	    wp->xoff >= ctx->ox + ctx->sx ||
+	    wp->yoff + wp->sy <= ctx->oy ||
+	    wp->yoff >= ctx->oy + ctx->sy)
+		return;
+
+	if (wp->xoff >= ctx->ox && wp->xoff + wp->sx <= ctx->ox + ctx->sx) {
+		/* All visible. */
+		xoff = wp->xoff - ctx->ox;
+		sx = wp->sx;
+	} else if (wp->xoff < ctx->ox &&
+	    wp->xoff + wp->sx > ctx->ox + ctx->sx) {
+		/* Both left and right not visible. */
+		xoff = 0;
+		sx = ctx->sx;
+	} else if (wp->xoff < ctx->ox) {
+		/* Left not visible. */
+		xoff = 0;
+		sx = wp->sx - (ctx->ox - wp->xoff);
+	} else {
+		/* Right not visible. */
+		xoff = wp->xoff - ctx->ox;
+		sx = wp->sx - xoff;
+	}
+	if (wp->yoff >= ctx->oy && wp->yoff + wp->sy <= ctx->oy + ctx->sy) {
+		/* All visible. */
+		yoff = wp->yoff - ctx->oy;
+		sy = wp->sy;
+	} else if (wp->yoff < ctx->oy &&
+	    wp->yoff + wp->sy > ctx->oy + ctx->sy) {
+		/* Both top and bottom not visible. */
+		yoff = 0;
+		sy = ctx->sy;
+	} else if (wp->yoff < ctx->oy) {
+		/* Top not visible. */
+		yoff = 0;
+		sy = wp->sy - (ctx->oy - wp->yoff);
+	} else {
+		/* Bottom not visible. */
+		yoff = wp->yoff - ctx->oy;
+		sy = wp->sy - yoff;
+	}
+
+	if (ctx->top)
+		yoff += ctx->lines;
+	px = sx / 2;
+	py = sy / 2;
+
 	if (window_pane_index(wp, &idx) != 0)
 		fatalx("index not found");
 	len = xsnprintf(buf, sizeof buf, "%u", idx);
 
-	if (wp->sx < len)
+	if (sx < len)
 		return;
 	colour = options_get_number(oo, "display-panes-colour");
 	active_colour = options_get_number(oo, "display-panes-active-colour");
 
-	px = wp->sx / 2; py = wp->sy / 2;
-	xoff = wp->xoff; yoff = wp->yoff;
-
-	if (top)
-		yoff++;
-
-	if (wp->sx < len * 6 || wp->sy < 5) {
+	if (sx < len * 6 || sy < 5) {
 		tty_cursor(tty, xoff + px - len / 2, yoff + py);
 		goto draw_text;
 	}
@@ -610,9 +744,9 @@ screen_redraw_draw_number(struct client *c, struct window_pane *wp, u_int top)
 	}
 
 	len = xsnprintf(buf, sizeof buf, "%ux%u", wp->sx, wp->sy);
-	if (wp->sx < len || wp->sy < 6)
+	if (sx < len || sy < 6)
 		return;
-	tty_cursor(tty, xoff + wp->sx - len, yoff);
+	tty_cursor(tty, xoff + sx - len, yoff);
 
 draw_text:
 	memcpy(&gc, &grid_default_cell, sizeof gc);

screen-write.c

@@ -54,12 +54,53 @@ struct screen_write_collect_line {
 	TAILQ_HEAD(, screen_write_collect_item) items;
 };
 
+static void
+screen_write_offset_timer(__unused int fd, __unused short events, void *data)
+{
+	struct window	*w = data;
+
+	tty_update_window_offset(w);
+}
+
+/* Set cursor position. */
+static void
+screen_write_set_cursor(struct screen_write_ctx *ctx, int cx, int cy)
+{
+	struct window_pane	*wp = ctx->wp;
+	struct window		*w;
+	struct screen		*s = ctx->s;
+	struct timeval		 tv = { .tv_usec = 10000 };
+
+	if (cx != -1 && (u_int)cx == s->cx && cy != -1 && (u_int)cy == s->cy)
+		return;
+
+	if (cx != -1) {
+		if ((u_int)cx > screen_size_x(s)) /* allow last column */
+			cx = screen_size_x(s) - 1;
+		s->cx = cx;
+	}
+	if (cy != -1) {
+		if ((u_int)cy > screen_size_y(s) - 1)
+			cy = screen_size_y(s) - 1;
+		s->cy = cy;
+	}
+
+	if (wp == NULL)
+		return;
+	w = wp->window;
+
+	if (!event_initialized(&w->offset_timer))
+		evtimer_set(&w->offset_timer, screen_write_offset_timer, w);
+	if (!evtimer_pending(&w->offset_timer, NULL))
+		evtimer_add(&w->offset_timer, &tv);
+}
+
 /* Initialize writing with a window. */
 void
 screen_write_start(struct screen_write_ctx *ctx, struct window_pane *wp,
     struct screen *s)
 {
-	char	tmp[16];
+	char	tmp[32];
 	u_int	y;
 
 	memset(ctx, 0, sizeof *ctx);
@@ -78,8 +119,10 @@ screen_write_start(struct screen_write_ctx *ctx, struct window_pane *wp,
 	ctx->scrolled = 0;
 	ctx->bg = 8;
 
-	if (wp != NULL)
-		snprintf(tmp, sizeof tmp, "pane %%%u", wp->id);
+	if (wp != NULL) {
+		snprintf(tmp, sizeof tmp, "pane %%%u (at %u,%u)", wp->id,
+		    wp->xoff, wp->yoff);
+	}
 	log_debug("%s: size %ux%u, %s", __func__, screen_size_x(ctx->s),
 	    screen_size_y(ctx->s), wp == NULL ? "no pane" : tmp);
 }
@@ -107,11 +150,10 @@ screen_write_reset(struct screen_write_ctx *ctx)
 	screen_reset_tabs(s);
 	screen_write_scrollregion(ctx, 0, screen_size_y(s) - 1);
 
-	s->mode &= ~(MODE_INSERT|MODE_KCURSOR|MODE_KKEYPAD|MODE_FOCUSON);
-	s->mode &= ~(ALL_MOUSE_MODES|MODE_MOUSE_UTF8|MODE_MOUSE_SGR);
+	s->mode = MODE_CURSOR | MODE_WRAP;
 
 	screen_write_clearscreen(ctx, 8);
-	screen_write_cursormove(ctx, 0, 0);
+	screen_write_set_cursor(ctx, 0, 0);
 }
 
 /* Write character. */
@@ -127,41 +169,6 @@ screen_write_putc(struct screen_write_ctx *ctx, const struct grid_cell *gcp,
 	screen_write_cell(ctx, &gc);
 }
 
-/* Calculate string length, with embedded formatting. */
-size_t
-screen_write_cstrlen(const char *fmt, ...)
-{
-	va_list	ap;
-	char   *msg, *msg2, *ptr, *ptr2;
-	size_t	size;
-
-	va_start(ap, fmt);
-	xvasprintf(&msg, fmt, ap);
-	va_end(ap);
-	msg2 = xmalloc(strlen(msg) + 1);
-
-	ptr = msg;
-	ptr2 = msg2;
-	while (*ptr != '\0') {
-		if (ptr[0] == '#' && ptr[1] == '[') {
-			while (*ptr != ']' && *ptr != '\0')
-				ptr++;
-			if (*ptr == ']')
-				ptr++;
-			continue;
-		}
-		*ptr2++ = *ptr++;
-	}
-	*ptr2 = '\0';
-
-	size = screen_write_strlen("%s", msg2);
-
-	free(msg);
-	free(msg2);
-
-	return (size);
-}
-
 /* Calculate string length. */
 size_t
 screen_write_strlen(const char *fmt, ...)
@@ -280,82 +287,10 @@ screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
 	free(msg);
 }
 
-/* Write string, similar to nputs, but with embedded formatting (#[]). */
-void
-screen_write_cnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
-    const struct grid_cell *gcp, const char *fmt, ...)
-{
-	struct grid_cell	 gc;
-	struct utf8_data	*ud = &gc.data;
-	va_list			 ap;
-	char			*msg;
-	u_char 			*ptr, *last;
-	size_t			 left, size = 0;
-	enum utf8_state		 more;
-
-	memcpy(&gc, gcp, sizeof gc);
-
-	va_start(ap, fmt);
-	xvasprintf(&msg, fmt, ap);
-	va_end(ap);
-
-	ptr = msg;
-	while (*ptr != '\0') {
-		if (ptr[0] == '#' && ptr[1] == '[') {
-			ptr += 2;
-			last = ptr + strcspn(ptr, "]");
-			if (*last == '\0') {
-				/* No ]. Not much point in doing anything. */
-				break;
-			}
-			*last = '\0';
-
-			style_parse(gcp, &gc, ptr);
-			ptr = last + 1;
-			continue;
-		}
-
-		if (*ptr > 0x7f && utf8_open(ud, *ptr) == UTF8_MORE) {
-			ptr++;
-
-			left = strlen(ptr);
-			if (left < (size_t)ud->size - 1)
-				break;
-			while ((more = utf8_append(ud, *ptr)) == UTF8_MORE)
-				ptr++;
-			ptr++;
-
-			if (more != UTF8_DONE)
-				continue;
-			if (maxlen > 0 && size + ud->width > (size_t)maxlen) {
-				while (size < (size_t)maxlen) {
-					screen_write_putc(ctx, &gc, ' ');
-					size++;
-				}
-				break;
-			}
-			size += ud->width;
-			screen_write_cell(ctx, &gc);
-		} else {
-			if (maxlen > 0 && size + 1 > (size_t)maxlen)
-				break;
-
-			if (*ptr > 0x1f && *ptr < 0x7f) {
-				size++;
-				screen_write_putc(ctx, &gc, *ptr);
-			}
-			ptr++;
-		}
-	}
-
-	free(msg);
-}
-
-/* Copy from another screen. */
+/* Copy from another screen. Assumes target region is big enough. */
 void
 screen_write_copy(struct screen_write_ctx *ctx, struct screen *src, u_int px,
-    u_int py, u_int nx, u_int ny, bitstr_t *markbs,
-    const struct grid_cell *markgc)
+    u_int py, u_int nx, u_int ny, bitstr_t *mbs, const struct grid_cell *mgc)
 {
 	struct screen		*s = ctx->s;
 	struct grid		*gd = src->grid;
@@ -371,19 +306,53 @@ screen_write_copy(struct screen_write_ctx *ctx, struct screen *src, u_int px,
 	for (yy = py; yy < py + ny; yy++) {
 		for (xx = px; xx < px + nx; xx++) {
 			grid_get_cell(gd, xx, yy, &gc);
-			if (markbs != NULL) {
+			if (mbs != NULL) {
 				b = (yy * screen_size_x(src)) + xx;
-				if (bit_test(markbs, b)) {
-					gc.attr = markgc->attr;
-					gc.fg = markgc->fg;
-					gc.bg = markgc->bg;
+				if (bit_test(mbs, b)) {
+					gc.attr = mgc->attr;
+					gc.fg = mgc->fg;
+					gc.bg = mgc->bg;
 				}
 			}
-			screen_write_cell(ctx, &gc);
+			if (xx + gc.data.width <= px + nx)
+				screen_write_cell(ctx, &gc);
+		}
+		cy++;
+		screen_write_set_cursor(ctx, cx, cy);
+	}
+}
+
+/*
+ * Copy from another screen but without the selection stuff. Also assumes the
+ * target region is already big enough.
+ */
+void
+screen_write_fast_copy(struct screen_write_ctx *ctx, struct screen *src,
+    u_int px, u_int py, u_int nx, u_int ny)
+{
+	struct screen		*s = ctx->s;
+	struct grid		*gd = src->grid;
+	struct grid_cell	 gc;
+	u_int		 	 xx, yy, cx, cy;
+
+	if (nx == 0 || ny == 0)
+		return;
+
+	cy = s->cy;
+	for (yy = py; yy < py + ny; yy++) {
+		if (yy >= gd->hsize + gd->sy)
+			break;
+		cx = s->cx;
+		for (xx = px; xx < px + nx; xx++) {
+			if (xx >= grid_get_line(gd, yy)->cellsize)
+				break;
+			grid_get_cell(gd, xx, yy, &gc);
+			if (xx + gc.data.width > px + nx)
+				break;
+			grid_view_set_cell(ctx->s->grid, cx, cy, &gc);
+			cx++;
 		}
-
 		cy++;
-		screen_write_cursormove(ctx, cx, cy);
 	}
 }
 
@@ -406,7 +375,7 @@ screen_write_hline(struct screen_write_ctx *ctx, u_int nx, int left, int right)
 		screen_write_putc(ctx, &gc, 'q');
 	screen_write_putc(ctx, &gc, right ? 'u' : 'q');
 
-	screen_write_cursormove(ctx, cx, cy);
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* Draw a horizontal line on screen. */
@@ -425,13 +394,13 @@ screen_write_vline(struct screen_write_ctx *ctx, u_int ny, int top, int bottom)
 
 	screen_write_putc(ctx, &gc, top ? 'w' : 'x');
 	for (i = 1; i < ny - 1; i++) {
-		screen_write_cursormove(ctx, cx, cy + i);
+		screen_write_set_cursor(ctx, cx, cy + i);
 		screen_write_putc(ctx, &gc, 'x');
 	}
-	screen_write_cursormove(ctx, cx, cy + ny);
+	screen_write_set_cursor(ctx, cx, cy + ny - 1);
 	screen_write_putc(ctx, &gc, bottom ? 'v' : 'x');
 
-	screen_write_cursormove(ctx, cx, cy);
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* Draw a box on screen. */
@@ -453,25 +422,28 @@ screen_write_box(struct screen_write_ctx *ctx, u_int nx, u_int ny)
 		screen_write_putc(ctx, &gc, 'q');
 	screen_write_putc(ctx, &gc, 'k');
 
-	screen_write_cursormove(ctx, cx, cy + ny - 1);
+	screen_write_set_cursor(ctx, cx, cy + ny - 1);
 	screen_write_putc(ctx, &gc, 'm');
 	for (i = 1; i < nx - 1; i++)
 		screen_write_putc(ctx, &gc, 'q');
 	screen_write_putc(ctx, &gc, 'j');
 
 	for (i = 1; i < ny - 1; i++) {
-		screen_write_cursormove(ctx, cx, cy + i);
+		screen_write_set_cursor(ctx, cx, cy + i);
 		screen_write_putc(ctx, &gc, 'x');
 	}
 	for (i = 1; i < ny - 1; i++) {
-		screen_write_cursormove(ctx, cx + nx - 1, cy + i);
+		screen_write_set_cursor(ctx, cx + nx - 1, cy + i);
 		screen_write_putc(ctx, &gc, 'x');
 	}
 
-	screen_write_cursormove(ctx, cx, cy);
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
-/* Write a preview version of a window. */
+/*
+ * Write a preview version of a window. Assumes target area is big enough and
+ * already cleared.
+ */
 void
 screen_write_preview(struct screen_write_ctx *ctx, struct screen *src, u_int nx,
     u_int ny)
@@ -515,13 +487,12 @@ screen_write_preview(struct screen_write_ctx *ctx, struct screen *src, u_int nx,
 		py = 0;
 	}
 
-	screen_write_copy(ctx, src, px, src->grid->hsize + py, nx, ny, NULL,
-	    NULL);
+	screen_write_fast_copy(ctx, src, px, src->grid->hsize + py, nx, ny);
 
 	if (src->mode & MODE_CURSOR) {
 		grid_view_get_cell(src->grid, src->cx, src->cy, &gc);
 		gc.attr |= GRID_ATTR_REVERSE;
-		screen_write_cursormove(ctx, cx + (src->cx - px),
+		screen_write_set_cursor(ctx, cx + (src->cx - px),
 		    cy + (src->cy - py));
 		screen_write_cell(ctx, &gc);
 	}
@@ -567,25 +538,26 @@ void
 screen_write_cursorup(struct screen_write_ctx *ctx, u_int ny)
 {
 	struct screen	*s = ctx->s;
+	u_int		 cx = s->cx, cy = s->cy;
 
 	if (ny == 0)
 		ny = 1;
 
-	if (s->cy < s->rupper) {
+	if (cy < s->rupper) {
 		/* Above region. */
-		if (ny > s->cy)
-			ny = s->cy;
+		if (ny > cy)
+			ny = cy;
 	} else {
 		/* Below region. */
-		if (ny > s->cy - s->rupper)
-			ny = s->cy - s->rupper;
+		if (ny > cy - s->rupper)
+			ny = cy - s->rupper;
 	}
-	if (s->cx == screen_size_x(s))
-	    s->cx--;
-	if (ny == 0)
-		return;
+	if (cx == screen_size_x(s))
+		cx--;
 
-	s->cy -= ny;
+	cy -= ny;
+
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* Cursor down by ny. */
@@ -593,25 +565,28 @@ void
 screen_write_cursordown(struct screen_write_ctx *ctx, u_int ny)
 {
 	struct screen	*s = ctx->s;
+	u_int		 cx = s->cx, cy = s->cy;
 
 	if (ny == 0)
 		ny = 1;
 
-	if (s->cy > s->rlower) {
+	if (cy > s->rlower) {
 		/* Below region. */
-		if (ny > screen_size_y(s) - 1 - s->cy)
-			ny = screen_size_y(s) - 1 - s->cy;
+		if (ny > screen_size_y(s) - 1 - cy)
+			ny = screen_size_y(s) - 1 - cy;
 	} else {
 		/* Above region. */
-		if (ny > s->rlower - s->cy)
-			ny = s->rlower - s->cy;
+		if (ny > s->rlower - cy)
+			ny = s->rlower - cy;
 	}
-	if (s->cx == screen_size_x(s))
-	    s->cx--;
-	if (ny == 0)
+	if (cx == screen_size_x(s))
+	    cx--;
+	else if (ny == 0)
 		return;
 
-	s->cy += ny;
+	cy += ny;
+
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* Cursor right by nx. */
@@ -619,16 +594,19 @@ void
 screen_write_cursorright(struct screen_write_ctx *ctx, u_int nx)
 {
 	struct screen	*s = ctx->s;
+	u_int		 cx = s->cx, cy = s->cy;
 
 	if (nx == 0)
 		nx = 1;
 
-	if (nx > screen_size_x(s) - 1 - s->cx)
-		nx = screen_size_x(s) - 1 - s->cx;
+	if (nx > screen_size_x(s) - 1 - cx)
+		nx = screen_size_x(s) - 1 - cx;
 	if (nx == 0)
 		return;
 
-	s->cx += nx;
+	cx += nx;
+
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* Cursor left by nx. */
@@ -636,16 +614,19 @@ void
 screen_write_cursorleft(struct screen_write_ctx *ctx, u_int nx)
 {
 	struct screen	*s = ctx->s;
+	u_int		 cx = s->cx, cy = s->cy;
 
 	if (nx == 0)
 		nx = 1;
 
-	if (nx > s->cx)
-		nx = s->cx;
+	if (nx > cx)
+		nx = cx;
 	if (nx == 0)
 		return;
 
-	s->cx -= nx;
+	cx -= nx;
+
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* Backspace; cursor left unless at start of wrapped line when can move up. */
@@ -654,17 +635,20 @@ screen_write_backspace(struct screen_write_ctx *ctx)
 {
 	struct screen		*s = ctx->s;
 	struct grid_line	*gl;
+	u_int			 cx = s->cx, cy = s->cy;
 
-	if (s->cx == 0) {
-		if (s->cy == 0)
+	if (cx == 0) {
+		if (cy == 0)
 			return;
-		gl = &s->grid->linedata[s->grid->hsize + s->cy - 1];
+		gl = grid_get_line(s->grid, s->grid->hsize + cy - 1);
 		if (gl->flags & GRID_LINE_WRAPPED) {
-			s->cy--;
-			s->cx = screen_size_x(s) - 1;
+			cy--;
+			cx = screen_size_x(s) - 1;
 		}
 	} else
-		s->cx--;
+		cx--;
+
+	screen_write_set_cursor(ctx, cx, cy);
 }
 
 /* VT100 alignment test. */
@@ -676,8 +660,6 @@ screen_write_alignmenttest(struct screen_write_ctx *ctx)
 	struct grid_cell       	 gc;
 	u_int			 xx, yy;
 
-	screen_write_initctx(ctx, &ttyctx);
-
 	memcpy(&gc, &grid_default_cell, sizeof gc);
 	utf8_set(&gc.data, 'E');
 
@@ -686,12 +668,13 @@ screen_write_alignmenttest(struct screen_write_ctx *ctx)
 			grid_view_set_cell(s->grid, xx, yy, &gc);
 	}
 
-	s->cx = 0;
-	s->cy = 0;
+	screen_write_set_cursor(ctx, 0, 0);
 
 	s->rupper = 0;
 	s->rlower = screen_size_y(s) - 1;
 
+	screen_write_initctx(ctx, &ttyctx);
+
 	screen_write_collect_clear(ctx, 0, screen_size_y(s) - 1);
 	tty_write(tty_cmd_alignmenttest, &ttyctx);
 }
@@ -881,8 +864,8 @@ screen_write_clearline(struct screen_write_ctx *ctx, u_int bg)
 	struct tty_ctx		 ttyctx;
 	u_int			 sx = screen_size_x(s);
 
-	gl = &s->grid->linedata[s->grid->hsize + s->cy];
-	if (gl->cellsize == 0 && bg == 8)
+	gl = grid_get_line(s->grid, s->grid->hsize + s->cy);
+	if (gl->cellsize == 0 && COLOUR_DEFAULT(bg))
 		return;
 
 	screen_write_initctx(ctx, &ttyctx);
@@ -904,8 +887,8 @@ screen_write_clearendofline(struct screen_write_ctx *ctx, u_int bg)
 	struct tty_ctx		 ttyctx;
 	u_int			 sx = screen_size_x(s);
 
-	gl = &s->grid->linedata[s->grid->hsize + s->cy];
-	if (s->cx > sx - 1 || (s->cx >= gl->cellsize && bg == 8))
+	gl = grid_get_line(s->grid, s->grid->hsize + s->cy);
+	if (s->cx > sx - 1 || (s->cx >= gl->cellsize && COLOUR_DEFAULT(bg)))
 		return;
 
 	screen_write_initctx(ctx, &ttyctx);
@@ -943,17 +926,24 @@ screen_write_clearstartofline(struct screen_write_ctx *ctx, u_int bg)
 
 /* Move cursor to px,py. */
 void
-screen_write_cursormove(struct screen_write_ctx *ctx, u_int px, u_int py)
+screen_write_cursormove(struct screen_write_ctx *ctx, int px, int py,
+    int origin)
 {
 	struct screen	*s = ctx->s;
 
-	if (px > screen_size_x(s) - 1)
+	if (origin && py != -1 && (s->mode & MODE_ORIGIN)) {
+		if ((u_int)py > s->rlower - s->rupper)
+			py = s->rlower;
+		else
+			py += s->rupper;
+	}
+
+	if (px != -1 && (u_int)px > screen_size_x(s) - 1)
 		px = screen_size_x(s) - 1;
-	if (py > screen_size_y(s) - 1)
+	if (py != -1 && (u_int)py > screen_size_y(s) - 1)
 		py = screen_size_y(s) - 1;
 
-	s->cx = px;
-	s->cy = py;
+	screen_write_set_cursor(ctx, px, py);
 }
 
 /* Reverse index (up with scroll). */
@@ -969,7 +959,7 @@ screen_write_reverseindex(struct screen_write_ctx *ctx, u_int bg)
 	if (s->cy == s->rupper)
 		grid_view_scroll_region_down(s->grid, s->rupper, s->rlower, bg);
 	else if (s->cy > 0)
-		s->cy--;
+		screen_write_set_cursor(ctx, -1, s->cy - 1);
 
 	screen_write_collect_flush(ctx, 0);
 	tty_write(tty_cmd_reverseindex, &ttyctx);
@@ -992,8 +982,7 @@ screen_write_scrollregion(struct screen_write_ctx *ctx, u_int rupper,
 	screen_write_collect_flush(ctx, 0);
 
 	/* Cursor moves to top-left. */
-	s->cx = 0;
-	s->cy = 0;
+	screen_write_set_cursor(ctx, 0, 0);
 
 	s->rupper = rupper;
 	s->rlower = rlower;
@@ -1007,7 +996,7 @@ screen_write_linefeed(struct screen_write_ctx *ctx, int wrapped, u_int bg)
 	struct grid		*gd = s->grid;
 	struct grid_line	*gl;
 
-	gl = &gd->linedata[gd->hsize + s->cy];
+	gl = grid_get_line(gd, gd->hsize + s->cy);
 	if (wrapped)
 		gl->flags |= GRID_LINE_WRAPPED;
 	else
@@ -1026,7 +1015,7 @@ screen_write_linefeed(struct screen_write_ctx *ctx, int wrapped, u_int bg)
 		screen_write_collect_scroll(ctx);
 		ctx->scrolled++;
 	} else if (s->cy < screen_size_y(s) - 1)
-		s->cy++;
+		screen_write_set_cursor(ctx, -1, s->cy + 1);
 }
 
 /* Scroll up. */
@@ -1058,9 +1047,7 @@ screen_write_scrollup(struct screen_write_ctx *ctx, u_int lines, u_int bg)
 void
 screen_write_carriagereturn(struct screen_write_ctx *ctx)
 {
-	struct screen	*s = ctx->s;
-
-	s->cx = 0;
+	screen_write_set_cursor(ctx, 0, -1);
 }
 
 /* Clear to end of screen from cursor. */
@@ -1215,7 +1202,7 @@ screen_write_collect_flush(struct screen_write_ctx *ctx, int scroll_only)
 	cx = s->cx; cy = s->cy;
 	for (y = 0; y < screen_size_y(s); y++) {
 		TAILQ_FOREACH_SAFE(ci, &ctx->list[y].items, entry, tmp) {
-			screen_write_cursormove(ctx, ci->x, y);
+			screen_write_set_cursor(ctx, ci->x, y);
 			screen_write_initctx(ctx, &ttyctx);
 			ttyctx.cell = &ci->gc;
 			ttyctx.wrapped = ci->wrapped;
@@ -1243,6 +1230,7 @@ screen_write_collect_end(struct screen_write_ctx *ctx)
 	struct screen				*s = ctx->s;
 	struct screen_write_collect_item	*ci = ctx->item;
 	struct grid_cell			 gc;
+	u_int					 xx;
 
 	if (ci->used == 0)
 		return;
@@ -1255,9 +1243,30 @@ screen_write_collect_end(struct screen_write_ctx *ctx)
 	log_debug("%s: %u %s (at %u,%u)", __func__, ci->used, ci->data, s->cx,
 	    s->cy);
 
+	if (s->cx != 0) {
+		for (xx = s->cx; xx > 0; xx--) {
+			grid_view_get_cell(s->grid, xx, s->cy, &gc);
+			if (~gc.flags & GRID_FLAG_PADDING)
+				break;
+			grid_view_set_cell(s->grid, xx, s->cy,
+			    &grid_default_cell);
+		}
+		if (gc.data.width > 1) {
+			grid_view_set_cell(s->grid, xx, s->cy,
+			    &grid_default_cell);
+		}
+	}
+
 	memcpy(&gc, &ci->gc, sizeof gc);
 	grid_view_set_cells(s->grid, s->cx, s->cy, &gc, ci->data, ci->used);
-	s->cx += ci->used;
+	screen_write_set_cursor(ctx, s->cx + ci->used, -1);
+
+	for (xx = s->cx; xx < screen_size_x(s); xx++) {
+		grid_view_get_cell(s->grid, xx, s->cy, &gc);
+		if (~gc.flags & GRID_FLAG_PADDING)
+			break;
+		grid_view_set_cell(s->grid, xx, s->cy, &grid_default_cell);
+	}
 }
 
 /* Write cell data, collecting if necessary. */
@@ -1278,7 +1287,7 @@ screen_write_collect_add(struct screen_write_ctx *ctx,
 	 */
 
 	collect = 1;
-	if (gc->data.width != 1 || gc->data.size != 1)
+	if (gc->data.width != 1 || gc->data.size != 1 || *gc->data.data >= 0x7f)
 		collect = 0;
 	else if (gc->attr & GRID_ATTR_CHARSET)
 		collect = 0;
@@ -1286,7 +1295,7 @@ screen_write_collect_add(struct screen_write_ctx *ctx,
 		collect = 0;
 	else if (s->mode & MODE_INSERT)
 		collect = 0;
-	else if (s->sel.flag)
+	else if (s->sel != NULL)
 		collect = 0;
 	if (!collect) {
 		screen_write_collect_end(ctx);
@@ -1304,7 +1313,7 @@ screen_write_collect_add(struct screen_write_ctx *ctx,
 		log_debug("%s: wrapped at %u,%u", __func__, s->cx, s->cy);
 		ci->wrapped = 1;
 		screen_write_linefeed(ctx, 1, 8);
-		s->cx = 0;
+		screen_write_set_cursor(ctx, 0, -1);
 	}
 
 	if (ci->used == 0)
@@ -1338,7 +1347,7 @@ screen_write_cell(struct screen_write_ctx *ctx, const struct grid_cell *gc)
 		screen_write_collect_flush(ctx, 0);
 		if ((gc = screen_write_combine(ctx, &gc->data, &xx)) != 0) {
 			cx = s->cx; cy = s->cy;
-			screen_write_cursormove(ctx, xx, s->cy);
+			screen_write_set_cursor(ctx, xx, s->cy);
 			screen_write_initctx(ctx, &ttyctx);
 			ttyctx.cell = gc;
 			tty_write(tty_cmd_cell, &ttyctx);
@@ -1366,7 +1375,7 @@ screen_write_cell(struct screen_write_ctx *ctx, const struct grid_cell *gc)
 	if ((s->mode & MODE_WRAP) && s->cx > sx - width) {
 		log_debug("%s: wrapped at %u,%u", __func__, s->cx, s->cy);
 		screen_write_linefeed(ctx, 1, 8);
-		s->cx = 0;
+		screen_write_set_cursor(ctx, 0, -1);
 		screen_write_collect_flush(ctx, 1);
 	}
 
@@ -1376,7 +1385,7 @@ screen_write_cell(struct screen_write_ctx *ctx, const struct grid_cell *gc)
 	screen_write_initctx(ctx, &ttyctx);
 
 	/* Handle overwriting of UTF-8 characters. */
-	gl = &s->grid->linedata[s->grid->hsize + s->cy];
+	gl = grid_get_line(s->grid, s->grid->hsize + s->cy);
 	if (gl->flags & GRID_LINE_EXTENDED) {
 		grid_view_get_cell(gd, s->cx, s->cy, &now_gc);
 		if (screen_write_overwrite(ctx, &now_gc, width))
@@ -1388,6 +1397,7 @@ screen_write_cell(struct screen_write_ctx *ctx, const struct grid_cell *gc)
 	 * already ensured there is enough room.
 	 */
 	for (xx = s->cx + 1; xx < s->cx + width; xx++) {
+		log_debug("%s: new padding at %u,%u", __func__, xx, s->cy);
 		grid_view_set_cell(gd, xx, s->cy, &screen_write_pad_cell);
 		skip = 0;
 	}
@@ -1438,9 +1448,9 @@ screen_write_cell(struct screen_write_ctx *ctx, const struct grid_cell *gc)
 	 */
 	last = !(s->mode & MODE_WRAP);
 	if (s->cx <= sx - last - width)
-		s->cx += width;
+		screen_write_set_cursor(ctx, s->cx + width, -1);
 	else
-		s->cx = sx - last;
+		screen_write_set_cursor(ctx,  sx - last, -1);
 
 	/* Create space for character in insert mode. */
 	if (s->mode & MODE_INSERT) {
@@ -1537,10 +1547,12 @@ screen_write_overwrite(struct screen_write_ctx *ctx, struct grid_cell *gc,
 			grid_view_get_cell(gd, xx, s->cy, &tmp_gc);
 			if (~tmp_gc.flags & GRID_FLAG_PADDING)
 				break;
+			log_debug("%s: padding at %u,%u", __func__, xx, s->cy);
 			grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
 		}
 
 		/* Overwrite the character at the start of this padding. */
+		log_debug("%s: character at %u,%u", __func__, xx, s->cy);
 		grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
 		done = 1;
 	}
@@ -1557,6 +1569,7 @@ screen_write_overwrite(struct screen_write_ctx *ctx, struct grid_cell *gc,
 			grid_view_get_cell(gd, xx, s->cy, &tmp_gc);
 			if (~tmp_gc.flags & GRID_FLAG_PADDING)
 				break;
+			log_debug("%s: overwrite at %u,%u", __func__, xx, s->cy);
 			grid_view_set_cell(gd, xx, s->cy, &grid_default_cell);
 			done = 1;
 		}

screen.c

@@ -24,21 +24,64 @@
 
 #include "tmux.h"
 
-static void	screen_resize_x(struct screen *, u_int);
+/* Selected area in screen. */
+struct screen_sel {
+	int		 hidden;
+	int		 rectangle;
+	int		 modekeys;
+
+	u_int		 sx;
+	u_int		 sy;
+
+	u_int		 ex;
+	u_int		 ey;
+
+	struct grid_cell cell;
+};
+
+/* Entry on title stack. */
+struct screen_title_entry {
+	char				*text;
+
+	TAILQ_ENTRY(screen_title_entry)	 entry;
+};
+TAILQ_HEAD(screen_titles, screen_title_entry);
+
 static void	screen_resize_y(struct screen *, u_int);
 
 static void	screen_reflow(struct screen *, u_int);
 
+/* Free titles stack. */
+static void
+screen_free_titles(struct screen *s)
+{
+	struct screen_title_entry	*title_entry;
+
+	if (s->titles == NULL)
+		return;
+
+	while ((title_entry = TAILQ_FIRST(s->titles)) != NULL) {
+		TAILQ_REMOVE(s->titles, title_entry, entry);
+		free(title_entry->text);
+		free(title_entry);
+	}
+
+	free(s->titles);
+	s->titles = NULL;
+}
+
 /* Create a new screen. */
 void
 screen_init(struct screen *s, u_int sx, u_int sy, u_int hlimit)
 {
 	s->grid = grid_create(sx, sy, hlimit);
 	s->title = xstrdup("");
+	s->titles = NULL;
 
 	s->cstyle = 0;
 	s->ccolour = xstrdup("");
 	s->tabs = NULL;
+	s->sel = NULL;
 
 	screen_reinit(s);
 }
@@ -60,16 +103,21 @@ screen_reinit(struct screen *s)
 	grid_clear_lines(s->grid, s->grid->hsize, s->grid->sy, 8);
 
 	screen_clear_selection(s);
+	screen_free_titles(s);
 }
 
 /* Destroy a screen. */
 void
 screen_free(struct screen *s)
 {
+	free(s->sel);
 	free(s->tabs);
 	free(s->title);
 	free(s->ccolour);
+
 	grid_destroy(s->grid);
+
+	screen_free_titles(s);
 }
 
 /* Reset tabs to default, eight spaces apart. */
@@ -110,6 +158,43 @@ screen_set_title(struct screen *s, const char *title)
 	utf8_stravis(&s->title, title, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL);
 }
 
+/* Push the current title onto the stack. */
+void
+screen_push_title(struct screen *s)
+{
+	struct screen_title_entry *title_entry;
+
+	if (s->titles == NULL) {
+		s->titles = xmalloc(sizeof *s->titles);
+		TAILQ_INIT(s->titles);
+	}
+	title_entry = xmalloc(sizeof *title_entry);
+	title_entry->text = xstrdup(s->title);
+	TAILQ_INSERT_HEAD(s->titles, title_entry, entry);
+}
+
+/*
+ * Pop a title from the stack and set it as the screen title. If the stack is
+ * empty, do nothing.
+ */
+void
+screen_pop_title(struct screen *s)
+{
+	struct screen_title_entry *title_entry;
+
+	if (s->titles == NULL)
+		return;
+
+	title_entry = TAILQ_FIRST(s->titles);
+	if (title_entry != NULL) {
+		screen_set_title(s, title_entry->text);
+
+		TAILQ_REMOVE(s->titles, title_entry, entry);
+		free(title_entry->text);
+		free(title_entry);
+	}
+}
+
 /* Resize screen. */
 void
 screen_resize(struct screen *s, u_int sx, u_int sy, int reflow)
@@ -120,15 +205,10 @@ screen_resize(struct screen *s, u_int sx, u_int sy, int reflow)
 		sy = 1;
 
 	if (sx != screen_size_x(s)) {
-		screen_resize_x(s, sx);
-
-		/*
-		 * It is unclear what should happen to tabs on resize. xterm
-		 * seems to try and maintain them, rxvt resets them. Resetting
-		 * is simpler and more reliable so let's do that.
-		 */
+		s->grid->sx = sx;
 		screen_reset_tabs(s);
-	}
+	} else
+		reflow = 0;
 
 	if (sy != screen_size_y(s))
 		screen_resize_y(s, sy);
@@ -137,28 +217,6 @@ screen_resize(struct screen *s, u_int sx, u_int sy, int reflow)
 		screen_reflow(s, sx);
 }
 
-static void
-screen_resize_x(struct screen *s, u_int sx)
-{
-	struct grid		*gd = s->grid;
-
-	if (sx == 0)
-		fatalx("zero size");
-
-	/*
-	 * Treat resizing horizontally simply: just ensure the cursor is
-	 * on-screen and change the size. Don't bother to truncate any lines -
-	 * then the data should be accessible if the size is then increased.
-	 *
-	 * The only potential wrinkle is if UTF-8 double-width characters are
-	 * left in the last column, but UTF-8 terminals should deal with this
-	 * sanely.
-	 */
-	if (s->cx >= sx)
-		s->cx = sx - 1;
-	gd->sx = sx;
-}
-
 static void
 screen_resize_y(struct screen *s, u_int sy)
 {
@@ -211,9 +269,8 @@ screen_resize_y(struct screen *s, u_int sy)
 		s->cy -= needed;
 	}
 
-	/* Resize line arrays. */
-	gd->linedata = xreallocarray(gd->linedata, gd->hsize + sy,
-	    sizeof *gd->linedata);
+	/* Resize line array. */
+	grid_adjust_lines(gd, gd->hsize + sy);
 
 	/* Size increasing. */
 	if (sy > oldy) {
@@ -236,7 +293,7 @@ screen_resize_y(struct screen *s, u_int sy)
 
 		/* Then fill the rest in with blanks. */
 		for (i = gd->hsize + sy - needed; i < gd->hsize + sy; i++)
-			memset(&gd->linedata[i], 0, sizeof gd->linedata[i]);
+			memset(grid_get_line(gd, i), 0, sizeof(struct grid_line));
 	}
 
 	/* Set the new size, and reset the scroll region. */
@@ -248,51 +305,49 @@ screen_resize_y(struct screen *s, u_int sy)
 /* Set selection. */
 void
 screen_set_selection(struct screen *s, u_int sx, u_int sy,
-    u_int ex, u_int ey, u_int rectflag, struct grid_cell *gc)
+    u_int ex, u_int ey, u_int rectangle, int modekeys, struct grid_cell *gc)
 {
-	struct screen_sel	*sel = &s->sel;
+	if (s->sel == NULL)
+		s->sel = xcalloc(1, sizeof *s->sel);
 
-	memcpy(&sel->cell, gc, sizeof sel->cell);
-	sel->flag = 1;
-	sel->hidden = 0;
+	memcpy(&s->sel->cell, gc, sizeof s->sel->cell);
+	s->sel->hidden = 0;
+	s->sel->rectangle = rectangle;
+	s->sel->modekeys = modekeys;
 
-	sel->rectflag = rectflag;
-
-	sel->sx = sx; sel->sy = sy;
-	sel->ex = ex; sel->ey = ey;
+	s->sel->sx = sx;
+	s->sel->sy = sy;
+	s->sel->ex = ex;
+	s->sel->ey = ey;
 }
 
 /* Clear selection. */
 void
 screen_clear_selection(struct screen *s)
 {
-	struct screen_sel	*sel = &s->sel;
-
-	sel->flag = 0;
-	sel->hidden = 0;
-	sel->lineflag = LINE_SEL_NONE;
+	free(s->sel);
+	s->sel = NULL;
 }
 
 /* Hide selection. */
 void
 screen_hide_selection(struct screen *s)
 {
-	struct screen_sel	*sel = &s->sel;
-
-	sel->hidden = 1;
+	if (s->sel != NULL)
+		s->sel->hidden = 1;
 }
 
 /* Check if cell in selection. */
 int
 screen_check_selection(struct screen *s, u_int px, u_int py)
 {
-	struct screen_sel	*sel = &s->sel;
+	struct screen_sel	*sel = s->sel;
 	u_int			 xx;
 
-	if (!sel->flag || sel->hidden)
+	if (sel == NULL || sel->hidden)
 		return (0);
 
-	if (sel->rectflag) {
+	if (sel->rectangle) {
 		if (sel->sy < sel->ey) {
 			/* start line < end line -- downward selection. */
 			if (py < sel->sy || py > sel->ey)
@@ -340,7 +395,11 @@ screen_check_selection(struct screen *s, u_int px, u_int py)
 			if (py == sel->sy && px < sel->sx)
 				return (0);
 
-			if (py == sel->ey && px > sel->ex)
+			if (sel->modekeys == MODEKEY_EMACS)
+				xx = (sel->ex == 0 ? 0 : sel->ex - 1);
+			else
+				xx = sel->ex;
+			if (py == sel->ey && px > xx)
 				return (0);
 		} else if (sel->sy > sel->ey) {
 			/* starting line > ending line -- upward selection. */
@@ -371,7 +430,11 @@ screen_check_selection(struct screen *s, u_int px, u_int py)
 					return (0);
 			} else {
 				/* selection start (sx) is on the left */
-				if (px < sel->sx || px > sel->ex)
+				if (sel->modekeys == MODEKEY_EMACS)
+					xx = (sel->ex == 0 ? 0 : sel->ex - 1);
+				else
+					xx = sel->ex;
+				if (px < sel->sx || px > xx)
 					return (0);
 			}
 		}
@@ -385,10 +448,10 @@ void
 screen_select_cell(struct screen *s, struct grid_cell *dst,
     const struct grid_cell *src)
 {
-	if (!s->sel.flag || s->sel.hidden)
+	if (s->sel == NULL || s->sel->hidden)
 		return;
 
-	memcpy(dst, &s->sel.cell, sizeof *dst);
+	memcpy(dst, &s->sel->cell, sizeof *dst);
 
 	utf8_copy(&dst->data, &src->data);
 	dst->attr = dst->attr & ~GRID_ATTR_CHARSET;
@@ -400,14 +463,30 @@ screen_select_cell(struct screen *s, struct grid_cell *dst,
 static void
 screen_reflow(struct screen *s, u_int new_x)
 {
-	struct grid	*old = s->grid;
-	u_int		 change;
+	u_int		cx = s->cx, cy = s->grid->hsize + s->cy, wx, wy;
+	struct timeval	start, tv;
 
-	s->grid = grid_create(old->sx, old->sy, old->hlimit);
+	gettimeofday(&start, NULL);
 
-	change = grid_reflow(s->grid, old, new_x);
-	if (change < s->cy)
-		s->cy -= change;
-	else
+	grid_wrap_position(s->grid, cx, cy, &wx, &wy);
+	log_debug("%s: cursor %u,%u is %u,%u", __func__, cx, cy, wx, wy);
+
+	grid_reflow(s->grid, new_x);
+
+	grid_unwrap_position(s->grid, &cx, &cy, wx, wy);
+	log_debug("%s: new cursor is %u,%u", __func__, cx, cy);
+
+	if (cy >= s->grid->hsize) {
+		s->cx = cx;
+		s->cy = cy - s->grid->hsize;
+	} else {
+		s->cx = 0;
 		s->cy = 0;
+	}
+
+	gettimeofday(&tv, NULL);
+	timersub(&tv, &start, &tv);
+
+	log_debug("%s: reflow took %llu.%06u seconds", __func__,
+	    (unsigned long long)tv.tv_sec, (u_int)tv.tv_usec);
 }

server-client.c

@@ -41,6 +41,8 @@ static void	server_client_check_redraw(struct client *);
 static void	server_client_set_title(struct client *);
 static void	server_client_reset_state(struct client *);
 static int	server_client_assume_paste(struct session *);
+static void	server_client_clear_identify(struct client *,
+		    struct window_pane *);
 
 static void	server_client_dispatch(struct imsg *, void *);
 static void	server_client_dispatch_command(struct client *, struct imsg *);
@@ -91,7 +93,7 @@ server_client_set_identify(struct client *c, u_int delay)
 }
 
 /* Clear identify mode on client. */
-void
+static void
 server_client_clear_identify(struct client *c, struct window_pane *wp)
 {
 	if (~c->flags & CLIENT_IDENTIFY)
@@ -159,7 +161,7 @@ server_client_is_default_key_table(struct client *c, struct key_table *table)
 }
 
 /* Create a new client. */
-void
+struct client *
 server_client_create(int fd)
 {
 	struct client	*c;
@@ -182,18 +184,25 @@ server_client_create(int fd)
 	TAILQ_INIT(&c->queue);
 
 	c->stdin_data = evbuffer_new();
+	if (c->stdin_data == NULL)
+		fatalx("out of memory");
 	c->stdout_data = evbuffer_new();
+	if (c->stdout_data == NULL)
+		fatalx("out of memory");
 	c->stderr_data = evbuffer_new();
+	if (c->stderr_data == NULL)
+		fatalx("out of memory");
 
 	c->tty.fd = -1;
 	c->title = NULL;
 
 	c->session = NULL;
 	c->last_session = NULL;
+
 	c->tty.sx = 80;
 	c->tty.sy = 24;
 
-	screen_init(&c->status, c->tty.sx, 1, 0);
+	status_init(c);
 
 	c->message_string = NULL;
 	TAILQ_INIT(&c->message_log);
@@ -212,6 +221,7 @@ server_client_create(int fd)
 
 	TAILQ_INSERT_TAIL(&clients, c, entry);
 	log_debug("new client %p", c);
+	return (c);
 }
 
 /* Open client terminal if needed. */
@@ -269,13 +279,7 @@ server_client_lost(struct client *c)
 	if (c->stderr_data != c->stdout_data)
 		evbuffer_free(c->stderr_data);
 
-	if (event_initialized(&c->status_timer))
-		evtimer_del(&c->status_timer);
-	screen_free(&c->status);
-	if (c->old_status != NULL) {
-		screen_free(c->old_status);
-		free(c->old_status);
-	}
+	status_free(c);
 
 	free(c->title);
 	free((void *)c->cwd);
@@ -297,6 +301,7 @@ server_client_lost(struct client *c)
 		free(msg);
 	}
 
+	free(c->prompt_saved);
 	free(c->prompt_string);
 	free(c->prompt_buffer);
 
@@ -404,20 +409,21 @@ server_client_check_mouse(struct client *c)
 {
 	struct session		*s = c->session;
 	struct mouse_event	*m = &c->tty.mouse;
-	struct window		*w;
+	struct winlink		*wl;
 	struct window_pane	*wp;
-	u_int			 x, y, b;
+	u_int			 x, y, b, sx, sy, px, py;
 	int			 flag;
 	key_code		 key;
 	struct timeval		 tv;
+	struct style_range	*sr;
 	enum { NOTYPE, MOVE, DOWN, UP, DRAG, WHEEL, DOUBLE, TRIPLE } type;
-	enum { NOWHERE, PANE, STATUS, BORDER } where;
+	enum { NOWHERE, PANE, STATUS, STATUS_LEFT, STATUS_RIGHT, STATUS_DEFAULT, BORDER } where;
 
 	type = NOTYPE;
 	where = NOWHERE;
 
-	log_debug("mouse %02x at %u,%u (last %u,%u) (%d)", m->b, m->x, m->y,
-	    m->lx, m->ly, c->tty.mouse_drag_flag);
+	log_debug("%s mouse %02x at %u,%u (last %u,%u) (%d)", c->name, m->b,
+	    m->x, m->y, m->lx, m->ly, c->tty.mouse_drag_flag);
 
 	/* What type of event is this? */
 	if ((m->sgr_type != ' ' &&
@@ -436,7 +442,7 @@ server_client_check_mouse(struct client *c)
 			x = m->x, y = m->y, b = m->b;
 			log_debug("drag update at %u,%u", x, y);
 		} else {
-			x = m->lx, y = m->ly, b = m->lb;
+			x = m->lx - m->ox, y = m->ly - m->oy, b = m->lb;
 			log_debug("drag start at %u,%u", x, y);
 		}
 	} else if (MOUSE_WHEEL(m->b)) {
@@ -490,48 +496,88 @@ have_event:
 	if (type == NOTYPE)
 		return (KEYC_UNKNOWN);
 
-	/* Always save the session. */
+	/* Save the session. */
 	m->s = s->id;
+	m->w = -1;
 
 	/* Is this on the status line? */
 	m->statusat = status_at_line(c);
-	if (m->statusat != -1 && y == (u_int)m->statusat) {
-		w = status_get_window_at(c, x);
-		if (w == NULL)
-			return (KEYC_UNKNOWN);
-		m->w = w->id;
-		where = STATUS;
-	} else
-		m->w = -1;
+	if (m->statusat != -1 &&
+	    y >= (u_int)m->statusat &&
+	    y < m->statusat + status_line_size(c)) {
+		sr = status_get_range(c, x, y - m->statusat);
+		if (sr == NULL) {
+			where = STATUS_DEFAULT;
+		} else {
+			switch (sr->type) {
+			case STYLE_RANGE_NONE:
+				return (KEYC_UNKNOWN);
+			case STYLE_RANGE_LEFT:
+				where = STATUS_LEFT;
+				break;
+			case STYLE_RANGE_RIGHT:
+				where = STATUS_RIGHT;
+				break;
+			case STYLE_RANGE_WINDOW:
+				wl = winlink_find_by_index(&s->windows, sr->argument);
+				if (wl == NULL)
+					return (KEYC_UNKNOWN);
+				m->w = wl->window->id;
+
+				where = STATUS;
+				break;
+			}
+		}
+	}
 
 	/* Not on status line. Adjust position and check for border or pane. */
 	if (where == NOWHERE) {
+		px = x;
 		if (m->statusat == 0 && y > 0)
-			y--;
+			py = y - 1;
 		else if (m->statusat > 0 && y >= (u_int)m->statusat)
-			y = m->statusat - 1;
+			py = m->statusat - 1;
+		else
+			py = y;
 
-		TAILQ_FOREACH(wp, &s->curw->window->panes, entry) {
-			if ((wp->xoff + wp->sx == x &&
-			    wp->yoff <= 1 + y &&
-			    wp->yoff + wp->sy >= y) ||
-			    (wp->yoff + wp->sy == y &&
-			    wp->xoff <= 1 + x &&
-			    wp->xoff + wp->sx >= x))
-				break;
-		}
-		if (wp != NULL)
-			where = BORDER;
-		else {
-			wp = window_get_active_at(s->curw->window, x, y);
-			if (wp != NULL) {
-				where = PANE;
-				log_debug("mouse at %u,%u is on pane %%%u",
-				    x, y, wp->id);
+		tty_window_offset(&c->tty, &m->ox, &m->oy, &sx, &sy);
+		log_debug("mouse window @%u at %u,%u (%ux%u)",
+		    s->curw->window->id, m->ox, m->oy, sx, sy);
+		if (px > sx || py > sy)
+			return (KEYC_UNKNOWN);
+		px = px + m->ox;
+		py = py + m->oy;
+		m->x = x + m->ox;
+		m->y = y + m->oy;
+
+		/* Try the pane borders if not zoomed. */
+		if (~s->curw->window->flags & WINDOW_ZOOMED) {
+			TAILQ_FOREACH(wp, &s->curw->window->panes, entry) {
+				if ((wp->xoff + wp->sx == px &&
+				    wp->yoff <= 1 + py &&
+				    wp->yoff + wp->sy >= py) ||
+				    (wp->yoff + wp->sy == py &&
+				    wp->xoff <= 1 + px &&
+				    wp->xoff + wp->sx >= px))
+					break;
 			}
+			if (wp != NULL)
+				where = BORDER;
 		}
+
+		/* Otherwise try inside the pane. */
+		if (where == NOWHERE) {
+			wp = window_get_active_at(s->curw->window, px, py);
+			if (wp != NULL)
+				where = PANE;
+		}
+
 		if (where == NOWHERE)
 			return (KEYC_UNKNOWN);
+		if (where == PANE)
+			log_debug("mouse %u,%u on pane %%%u", x, y, wp->id);
+		else if (where == BORDER)
+			log_debug("mouse on pane %%%u border", wp->id);
 		m->wp = wp->id;
 		m->w = wp->window->id;
 	} else
@@ -555,6 +601,12 @@ have_event:
 				key = KEYC_MOUSEDRAGEND1_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEDRAGEND1_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEDRAGEND1_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEDRAGEND1_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEDRAGEND1_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEDRAGEND1_BORDER;
 			break;
@@ -563,6 +615,12 @@ have_event:
 				key = KEYC_MOUSEDRAGEND2_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEDRAGEND2_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEDRAGEND2_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEDRAGEND2_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEDRAGEND2_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEDRAGEND2_BORDER;
 			break;
@@ -571,6 +629,12 @@ have_event:
 				key = KEYC_MOUSEDRAGEND3_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEDRAGEND3_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEDRAGEND3_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEDRAGEND3_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEDRAGEND3_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEDRAGEND3_BORDER;
 			break;
@@ -593,6 +657,12 @@ have_event:
 			key = KEYC_MOUSEMOVE_PANE;
 		if (where == STATUS)
 			key = KEYC_MOUSEMOVE_STATUS;
+		if (where == STATUS_LEFT)
+			key = KEYC_MOUSEMOVE_STATUS_LEFT;
+		if (where == STATUS_RIGHT)
+			key = KEYC_MOUSEMOVE_STATUS_RIGHT;
+		if (where == STATUS_DEFAULT)
+			key = KEYC_MOUSEMOVE_STATUS_DEFAULT;
 		if (where == BORDER)
 			key = KEYC_MOUSEMOVE_BORDER;
 		break;
@@ -606,6 +676,12 @@ have_event:
 					key = KEYC_MOUSEDRAG1_PANE;
 				if (where == STATUS)
 					key = KEYC_MOUSEDRAG1_STATUS;
+				if (where == STATUS_LEFT)
+					key = KEYC_MOUSEDRAG1_STATUS_LEFT;
+				if (where == STATUS_RIGHT)
+					key = KEYC_MOUSEDRAG1_STATUS_RIGHT;
+				if (where == STATUS_DEFAULT)
+					key = KEYC_MOUSEDRAG1_STATUS_DEFAULT;
 				if (where == BORDER)
 					key = KEYC_MOUSEDRAG1_BORDER;
 				break;
@@ -614,6 +690,12 @@ have_event:
 					key = KEYC_MOUSEDRAG2_PANE;
 				if (where == STATUS)
 					key = KEYC_MOUSEDRAG2_STATUS;
+				if (where == STATUS_LEFT)
+					key = KEYC_MOUSEDRAG2_STATUS_LEFT;
+				if (where == STATUS_RIGHT)
+					key = KEYC_MOUSEDRAG2_STATUS_RIGHT;
+				if (where == STATUS_DEFAULT)
+					key = KEYC_MOUSEDRAG2_STATUS_DEFAULT;
 				if (where == BORDER)
 					key = KEYC_MOUSEDRAG2_BORDER;
 				break;
@@ -622,6 +704,12 @@ have_event:
 					key = KEYC_MOUSEDRAG3_PANE;
 				if (where == STATUS)
 					key = KEYC_MOUSEDRAG3_STATUS;
+				if (where == STATUS_LEFT)
+					key = KEYC_MOUSEDRAG3_STATUS_LEFT;
+				if (where == STATUS_RIGHT)
+					key = KEYC_MOUSEDRAG3_STATUS_RIGHT;
+				if (where == STATUS_DEFAULT)
+					key = KEYC_MOUSEDRAG3_STATUS_DEFAULT;
 				if (where == BORDER)
 					key = KEYC_MOUSEDRAG3_BORDER;
 				break;
@@ -640,6 +728,12 @@ have_event:
 				key = KEYC_WHEELUP_PANE;
 			if (where == STATUS)
 				key = KEYC_WHEELUP_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_WHEELUP_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_WHEELUP_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_WHEELUP_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_WHEELUP_BORDER;
 		} else {
@@ -647,6 +741,12 @@ have_event:
 				key = KEYC_WHEELDOWN_PANE;
 			if (where == STATUS)
 				key = KEYC_WHEELDOWN_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_WHEELDOWN_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_WHEELDOWN_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_WHEELDOWN_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_WHEELDOWN_BORDER;
 		}
@@ -658,6 +758,12 @@ have_event:
 				key = KEYC_MOUSEUP1_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEUP1_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEUP1_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEUP1_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEUP1_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEUP1_BORDER;
 			break;
@@ -666,6 +772,12 @@ have_event:
 				key = KEYC_MOUSEUP2_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEUP2_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEUP2_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEUP2_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEUP2_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEUP2_BORDER;
 			break;
@@ -674,6 +786,12 @@ have_event:
 				key = KEYC_MOUSEUP3_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEUP3_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEUP3_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEUP3_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEUP3_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEUP3_BORDER;
 			break;
@@ -686,6 +804,12 @@ have_event:
 				key = KEYC_MOUSEDOWN1_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEDOWN1_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEDOWN1_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEDOWN1_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEDOWN1_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEDOWN1_BORDER;
 			break;
@@ -694,6 +818,12 @@ have_event:
 				key = KEYC_MOUSEDOWN2_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEDOWN2_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEDOWN2_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEDOWN2_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEDOWN2_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEDOWN2_BORDER;
 			break;
@@ -702,6 +832,12 @@ have_event:
 				key = KEYC_MOUSEDOWN3_PANE;
 			if (where == STATUS)
 				key = KEYC_MOUSEDOWN3_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_MOUSEDOWN3_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_MOUSEDOWN3_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_MOUSEDOWN3_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_MOUSEDOWN3_BORDER;
 			break;
@@ -714,6 +850,12 @@ have_event:
 				key = KEYC_DOUBLECLICK1_PANE;
 			if (where == STATUS)
 				key = KEYC_DOUBLECLICK1_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_DOUBLECLICK1_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_DOUBLECLICK1_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_DOUBLECLICK1_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_DOUBLECLICK1_BORDER;
 			break;
@@ -722,6 +864,12 @@ have_event:
 				key = KEYC_DOUBLECLICK2_PANE;
 			if (where == STATUS)
 				key = KEYC_DOUBLECLICK2_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_DOUBLECLICK2_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_DOUBLECLICK2_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_DOUBLECLICK2_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_DOUBLECLICK2_BORDER;
 			break;
@@ -730,6 +878,12 @@ have_event:
 				key = KEYC_DOUBLECLICK3_PANE;
 			if (where == STATUS)
 				key = KEYC_DOUBLECLICK3_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_DOUBLECLICK3_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_DOUBLECLICK3_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_DOUBLECLICK3_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_DOUBLECLICK3_BORDER;
 			break;
@@ -742,6 +896,12 @@ have_event:
 				key = KEYC_TRIPLECLICK1_PANE;
 			if (where == STATUS)
 				key = KEYC_TRIPLECLICK1_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_TRIPLECLICK1_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_TRIPLECLICK1_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_TRIPLECLICK1_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_TRIPLECLICK1_BORDER;
 			break;
@@ -750,6 +910,12 @@ have_event:
 				key = KEYC_TRIPLECLICK2_PANE;
 			if (where == STATUS)
 				key = KEYC_TRIPLECLICK2_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_TRIPLECLICK2_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_TRIPLECLICK2_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_TRIPLECLICK2_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_TRIPLECLICK2_BORDER;
 			break;
@@ -758,6 +924,12 @@ have_event:
 				key = KEYC_TRIPLECLICK3_PANE;
 			if (where == STATUS)
 				key = KEYC_TRIPLECLICK3_STATUS;
+			if (where == STATUS_LEFT)
+				key = KEYC_TRIPLECLICK3_STATUS_LEFT;
+			if (where == STATUS_RIGHT)
+				key = KEYC_TRIPLECLICK3_STATUS_RIGHT;
+			if (where == STATUS_DEFAULT)
+				key = KEYC_TRIPLECLICK3_STATUS_DEFAULT;
 			if (where == BORDER)
 				key = KEYC_TRIPLECLICK3_BORDER;
 			break;
@@ -806,21 +978,24 @@ server_client_assume_paste(struct session *s)
 void
 server_client_handle_key(struct client *c, key_code key)
 {
-	struct mouse_event	*m = &c->tty.mouse;
-	struct session		*s = c->session;
-	struct window		*w;
-	struct window_pane	*wp;
-	struct timeval		 tv;
-	struct key_table	*table, *first;
-	struct key_binding	 bd_find, *bd;
-	int			 xtimeout, flags;
-	struct cmd_find_state	 fs;
-	key_code		 key0;
+	struct mouse_event		*m = &c->tty.mouse;
+	struct session			*s = c->session;
+	struct winlink			*wl;
+	struct window			*w;
+	struct window_pane		*wp;
+	struct window_mode_entry	*wme;
+	struct timeval			 tv;
+	struct key_table		*table, *first;
+	struct key_binding		*bd;
+	int				 xtimeout, flags;
+	struct cmd_find_state		 fs;
+	key_code			 key0;
 
 	/* Check the client is good to accept input. */
 	if (s == NULL || (c->flags & (CLIENT_DEAD|CLIENT_SUSPENDED)) != 0)
 		return;
-	w = s->curw->window;
+	wl = s->curw;
+	w = wl->window;
 
 	/* Update the activity timer. */
 	if (gettimeofday(&c->activity_time, NULL) != 0)
@@ -833,8 +1008,6 @@ server_client_handle_key(struct client *c, key_code key)
 			return;
 		window_unzoom(w);
 		wp = window_pane_at_index(w, key - '0');
-		if (wp != NULL && !window_pane_visible(wp))
-			wp = NULL;
 		server_client_clear_identify(c, wp);
 		return;
 	}
@@ -881,11 +1054,11 @@ server_client_handle_key(struct client *c, key_code key)
 
 	/* Forward mouse keys if disabled. */
 	if (KEYC_IS_MOUSE(key) && !options_get_number(s->options, "mouse"))
-		goto forward;
+		goto forward_key;
 
 	/* Treat everything as a regular key when pasting is detected. */
 	if (!KEYC_IS_MOUSE(key) && server_client_assume_paste(s))
-		goto forward;
+		goto forward_key;
 
 	/*
 	 * Work out the current key table. If the pane is in a mode, use
@@ -893,13 +1066,14 @@ server_client_handle_key(struct client *c, key_code key)
 	 */
 	if (server_client_is_default_key_table(c, c->keytable) &&
 	    wp != NULL &&
-	    wp->mode != NULL &&
-	    wp->mode->key_table != NULL)
-		table = key_bindings_get_table(wp->mode->key_table(wp), 1);
+	    (wme = TAILQ_FIRST(&wp->modes)) != NULL &&
+	    wme->mode->key_table != NULL)
+		table = key_bindings_get_table(wme->mode->key_table(wme), 1);
 	else
 		table = c->keytable;
 	first = table;
 
+table_changed:
 	/*
 	 * The prefix always takes precedence and forces a switch to the prefix
 	 * table, unless we are already there.
@@ -914,7 +1088,7 @@ server_client_handle_key(struct client *c, key_code key)
 	}
 	flags = c->flags;
 
-retry:
+try_again:
 	/* Log key table. */
 	if (wp == NULL)
 		log_debug("key table %s (no pane)", table->name);
@@ -924,8 +1098,7 @@ retry:
 		log_debug("currently repeating");
 
 	/* Try to see if there is a key binding in the current table. */
-	bd_find.key = key0;
-	bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find);
+	bd = key_bindings_get(table, key0);
 	if (bd != NULL) {
 		/*
 		 * Key was matched in this table. If currently repeating but a
@@ -934,11 +1107,13 @@ retry:
 		 */
 		if ((c->flags & CLIENT_REPEAT) &&
 		    (~bd->flags & KEY_BINDING_REPEAT)) {
+			log_debug("found in key table %s (not repeating)",
+			    table->name);
 			server_client_set_key_table(c, NULL);
+			first = table = c->keytable;
 			c->flags &= ~CLIENT_REPEAT;
 			server_status_client(c);
-			table = c->keytable;
-			goto retry;
+			goto table_changed;
 		}
 		log_debug("found in key table %s", table->name);
 
@@ -972,6 +1147,14 @@ retry:
 		return;
 	}
 
+	/*
+	 * No match, try the ANY key.
+	 */
+	if (key0 != KEYC_ANY) {
+		key0 = KEYC_ANY;
+		goto try_again;
+	}
+
 	/*
 	 * No match in this table. If not in the root table or if repeating,
 	 * switch the client back to the root table and try again.
@@ -979,11 +1162,14 @@ retry:
 	log_debug("not found in key table %s", table->name);
 	if (!server_client_is_default_key_table(c, table) ||
 	    (c->flags & CLIENT_REPEAT)) {
+		log_debug("trying in root table");
 		server_client_set_key_table(c, NULL);
+		table = c->keytable;
+		if (c->flags & CLIENT_REPEAT)
+			first = table;
 		c->flags &= ~CLIENT_REPEAT;
 		server_status_client(c);
-		table = c->keytable;
-		goto retry;
+		goto table_changed;
 	}
 
 	/*
@@ -996,11 +1182,11 @@ retry:
 		return;
 	}
 
-forward:
+forward_key:
 	if (c->flags & CLIENT_READONLY)
 		return;
 	if (wp != NULL)
-		window_pane_key(wp, c, s, key, m);
+		window_pane_key(wp, c, s, wl, key, m);
 }
 
 /* Client functions that need to happen every loop. */
@@ -1067,7 +1253,7 @@ server_client_resize_force(struct window_pane *wp)
 	memset(&ws, 0, sizeof ws);
 	ws.ws_col = wp->sx;
 	ws.ws_row = wp->sy - 1;
-	if (ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
+	if (wp->fd != -1 && ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
 #ifdef __sun
 		if (errno != EINVAL && errno != ENXIO)
 #endif
@@ -1096,7 +1282,7 @@ server_client_resize_event(__unused int fd, __unused short events, void *data)
 	memset(&ws, 0, sizeof ws);
 	ws.ws_col = wp->sx;
 	ws.ws_row = wp->sy;
-	if (ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
+	if (wp->fd != -1 && ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
 #ifdef __sun
 		/*
 		 * Some versions of Solaris apparently can return an error when
@@ -1157,10 +1343,6 @@ server_client_check_focus(struct window_pane *wp)
 	push = wp->flags & PANE_FOCUSPUSH;
 	wp->flags &= ~PANE_FOCUSPUSH;
 
-	/* If we don't care about focus, forget it. */
-	if (!(wp->base.mode & MODE_FOCUSON))
-		return;
-
 	/* If we're not the active pane in our window, we're not focused. */
 	if (wp->window->active != wp)
 		goto not_focused;
@@ -1176,7 +1358,7 @@ server_client_check_focus(struct window_pane *wp)
 	TAILQ_FOREACH(c, &clients, entry) {
 		if (c->session == NULL || !(c->flags & CLIENT_FOCUSED))
 			continue;
-		if (c->session->flags & SESSION_UNATTACHED)
+		if (c->session->attached == 0)
 			continue;
 
 		if (c->session->curw->window == wp->window)
@@ -1184,14 +1366,20 @@ server_client_check_focus(struct window_pane *wp)
 	}
 
 not_focused:
-	if (push || (wp->flags & PANE_FOCUSED))
-		bufferevent_write(wp->event, "\033[O", 3);
+	if (push || (wp->flags & PANE_FOCUSED)) {
+		if (wp->base.mode & MODE_FOCUSON)
+			bufferevent_write(wp->event, "\033[O", 3);
+		notify_pane("pane-focus-out", wp);
+	}
 	wp->flags &= ~PANE_FOCUSED;
 	return;
 
 focused:
-	if (push || !(wp->flags & PANE_FOCUSED))
-		bufferevent_write(wp->event, "\033[I", 3);
+	if (push || !(wp->flags & PANE_FOCUSED)) {
+		if (wp->base.mode & MODE_FOCUSON)
+			bufferevent_write(wp->event, "\033[I", 3);
+		notify_pane("pane-focus-in", wp);
+	}
 	wp->flags |= PANE_FOCUSED;
 }
 
@@ -1211,27 +1399,37 @@ server_client_reset_state(struct client *c)
 	struct window_pane	*wp = w->active, *loop;
 	struct screen		*s = wp->screen;
 	struct options		*oo = c->session->options;
-	int			 status, mode, o;
+	int			 mode, cursor = 0;
+	u_int			 cx = 0, cy = 0, ox, oy, sx, sy;
 
 	if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED))
 		return;
+	mode = s->mode;
 
 	tty_region_off(&c->tty);
 	tty_margin_off(&c->tty);
 
-	status = options_get_number(oo, "status");
-	if (!window_pane_visible(wp) || wp->yoff + s->cy >= c->tty.sy - status)
-		tty_cursor(&c->tty, 0, 0);
-	else {
-		o = status && options_get_number(oo, "status-position") == 0;
-		tty_cursor(&c->tty, wp->xoff + s->cx, o + wp->yoff + s->cy);
+	/* Move cursor to pane cursor and offset. */
+	cursor = 0;
+	tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
+	if (wp->xoff + s->cx >= ox && wp->xoff + s->cx <= ox + sx &&
+	    wp->yoff + s->cy >= oy && wp->yoff + s->cy <= oy + sy) {
+		cursor = 1;
+
+		cx = wp->xoff + s->cx - ox;
+		cy = wp->yoff + s->cy - oy;
+
+		if (status_at_line(c) == 0)
+			cy += status_line_size(c);
 	}
+	if (!cursor)
+		mode &= ~MODE_CURSOR;
+	tty_cursor(&c->tty, cx, cy);
 
 	/*
 	 * Set mouse mode if requested. To support dragging, always use button
 	 * mode.
 	 */
-	mode = s->mode;
 	if (options_get_number(oo, "mouse")) {
 		mode &= ~ALL_MOUSE_MODES;
 		TAILQ_FOREACH(loop, &w->panes, entry) {
@@ -1287,6 +1485,8 @@ server_client_check_exit(struct client *c)
 	if (EVBUFFER_LENGTH(c->stderr_data) != 0)
 		return;
 
+	if (c->flags & CLIENT_ATTACHED)
+		notify_client("client-detached", c);
 	proc_send(c->peer, MSG_EXIT, -1, &c->retval, sizeof c->retval);
 	c->flags &= ~CLIENT_EXIT;
 }
@@ -1306,13 +1506,19 @@ server_client_check_redraw(struct client *c)
 	struct session		*s = c->session;
 	struct tty		*tty = &c->tty;
 	struct window_pane	*wp;
-	int			 needed, flags, masked;
+	int			 needed, flags;
 	struct timeval		 tv = { .tv_usec = 1000 };
 	static struct event	 ev;
 	size_t			 left;
 
 	if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED))
 		return;
+	if (c->flags & CLIENT_ALLREDRAWFLAGS) {
+		log_debug("%s: redraw%s%s%s", c->name,
+		    (c->flags & CLIENT_REDRAWWINDOW) ? " window" : "",
+		    (c->flags & CLIENT_REDRAWSTATUS) ? " status" : "",
+		    (c->flags & CLIENT_REDRAWBORDERS) ? " borders" : "");
+	}
 
 	/*
 	 * If there is outstanding data, defer the redraw until it has been
@@ -1320,7 +1526,7 @@ server_client_check_redraw(struct client *c)
 	 * end up back here.
 	 */
 	needed = 0;
-	if (c->flags & CLIENT_REDRAW)
+	if (c->flags & CLIENT_ALLREDRAWFLAGS)
 		needed = 1;
 	else {
 		TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) {
@@ -1343,25 +1549,19 @@ server_client_check_redraw(struct client *c)
 		 * We may have got here for a single pane redraw, but force a
 		 * full redraw next time in case other panes have been updated.
 		 */
-		c->flags |= CLIENT_REDRAW;
+		c->flags |= CLIENT_ALLREDRAWFLAGS;
 		return;
 	} else if (needed)
 		log_debug("%s: redraw needed", c->name);
 
-	if (c->flags & (CLIENT_REDRAW|CLIENT_STATUS)) {
-		if (options_get_number(s->options, "set-titles"))
-			server_client_set_title(c);
-		screen_redraw_update(c); /* will adjust flags */
-	}
-
 	flags = tty->flags & (TTY_BLOCK|TTY_FREEZE|TTY_NOCURSOR);
 	tty->flags = (tty->flags & ~(TTY_BLOCK|TTY_FREEZE)) | TTY_NOCURSOR;
 
-	if (c->flags & CLIENT_REDRAW) {
-		tty_update_mode(tty, tty->mode, NULL);
-		screen_redraw_screen(c, 1, 1, 1);
-		c->flags &= ~(CLIENT_STATUS|CLIENT_BORDERS);
-	} else {
+	if (~c->flags & CLIENT_REDRAWWINDOW) {
+		/*
+		 * If not redrawing the entire window, check whether each pane
+		 * needs to be redrawn.
+		 */
 		TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) {
 			if (wp->flags & PANE_REDRAW) {
 				tty_update_mode(tty, tty->mode, NULL);
@@ -1370,21 +1570,16 @@ server_client_check_redraw(struct client *c)
 		}
 	}
 
-	masked = c->flags & (CLIENT_BORDERS|CLIENT_STATUS);
-	if (masked != 0)
-		tty_update_mode(tty, tty->mode, NULL);
-	if (masked == CLIENT_BORDERS)
-		screen_redraw_screen(c, 0, 0, 1);
-	else if (masked == CLIENT_STATUS)
-		screen_redraw_screen(c, 0, 1, 0);
-	else if (masked != 0)
-		screen_redraw_screen(c, 0, 1, 1);
+	if (c->flags & CLIENT_ALLREDRAWFLAGS) {
+		if (options_get_number(s->options, "set-titles"))
+			server_client_set_title(c);
+		screen_redraw_screen(c);
+	}
 
 	tty->flags = (tty->flags & ~(TTY_FREEZE|TTY_NOCURSOR)) | flags;
 	tty_update_mode(tty, tty->mode, NULL);
 
-	c->flags &= ~(CLIENT_REDRAW|CLIENT_BORDERS|CLIENT_STATUS|
-	    CLIENT_STATUSFORCE);
+	c->flags &= ~(CLIENT_ALLREDRAWFLAGS|CLIENT_STATUSFORCE);
 
 	if (needed) {
 		/*
@@ -1411,7 +1606,7 @@ server_client_set_title(struct client *c)
 	ft = format_create(c, NULL, FORMAT_NONE, 0);
 	format_defaults(ft, c, NULL, NULL, NULL);
 
-	title = format_expand_time(ft, template, time(NULL));
+	title = format_expand_time(ft, template);
 	if (c->title == NULL || strcmp(title, c->title) != 0) {
 		free(c->title);
 		c->title = xstrdup(title);
@@ -1559,6 +1754,9 @@ server_client_dispatch_command(struct client *c, struct imsg *imsg)
 	int			  argc;
 	char			**argv, *cause;
 
+	if (c->flags & CLIENT_EXIT)
+		return;
+
 	if (imsg->hdr.len - IMSG_HEADER_SIZE < sizeof data)
 		fatalx("bad MSG_COMMAND size");
 	memcpy(&data, imsg->data, sizeof data);
@@ -1854,15 +2052,21 @@ server_client_add_message(struct client *c, const char *fmt, ...)
 
 /* Get client working directory. */
 const char *
-server_client_get_cwd(struct client *c)
+server_client_get_cwd(struct client *c, struct session *s)
 {
-	struct session	*s;
+	const char	*home;
 
+	if (!cfg_finished && cfg_client != NULL)
+		return (cfg_client->cwd);
 	if (c != NULL && c->session == NULL && c->cwd != NULL)
 		return (c->cwd);
+	if (s != NULL && s->cwd != NULL)
+		return (s->cwd);
 	if (c != NULL && (s = c->session) != NULL && s->cwd != NULL)
 		return (s->cwd);
-	return (".");
+	if ((home = find_home()) != NULL)
+		return (home);
+	return ("/");
 }
 
 /* Resolve an absolute path or relative to client working directory. */
@@ -1874,7 +2078,7 @@ server_client_get_path(struct client *c, const char *file)
 	if (*file == '/')
 		path = xstrdup(file);
 	else
-		xasprintf(&path, "%s/%s", server_client_get_cwd(c), file);
+		xasprintf(&path, "%s/%s", server_client_get_cwd(c, NULL), file);
 	if (realpath(path, resolved) == NULL)
 		return (path);
 	free(path);