X-Git-Url: https://git.distorted.org.uk/~mdw/tig/blobdiff_plain/2e8488b4e70d3d6ebffd9afd0b801ea6ae21ae11..cfc6fa71c81e66c653fe83763d262c948b87731c:/tig.c

diff --git a/tig.c b/tig.c
index 4c2d56d..cbfa854 100644
--- a/tig.c
+++ b/tig.c
@@ -12,23 +12,25 @@
  * --------
  * [verse]
  * tig [options]
+ * tig [options] [--] [git log options]
  * tig [options] log  [git log options]
  * tig [options] diff [git diff options]
- * tig [options] <    [git log or git diff output]
+ * tig [options] show [git show options]
+ * tig [options] <    [git command output]
  *
  * DESCRIPTION
  * -----------
  * Browse changes in a git repository.
  **/
 
-#ifndef DEBUG
-#define NDEBUG
-#endif
-
 #ifndef	VERSION
 #define VERSION	"tig-0.1"
 #endif
 
+#ifndef DEBUG
+#define NDEBUG
+#endif
+
 #include <assert.h>
 #include <errno.h>
 #include <ctype.h>
@@ -37,13 +39,20 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include <time.h>
 
 #include <curses.h>
 
 static void die(const char *err, ...);
 static void report(const char *msg, ...);
-static void update_title(void);
+static void set_nonblocking_input(bool loading);
+
+#define ABS(x)		((x) >= 0  ? (x) : -(x))
+#define MIN(x, y)	((x) < (y) ? (x) :  (y))
+
+#define ARRAY_SIZE(x)	(sizeof(x) / sizeof(x[0]))
+#define STRING_SIZE(x)	(sizeof(x) - 1)
 
 #define SIZEOF_REF	256	/* Size of symbolic or SHA1 ID. */
 #define SIZEOF_CMD	1024	/* Size of command buffer. */
@@ -53,35 +62,40 @@ static void update_title(void);
 
 /* The format and size of the date column in the main view. */
 #define DATE_FORMAT	"%Y-%m-%d %H:%M"
-#define DATE_COLS	(STRING_SIZE("2006-04-29 14:21 "))
+#define DATE_COLS	STRING_SIZE("2006-04-29 14:21 ")
 
-/* The interval between line numbers. */
+/* The default interval between line numbers. */
 #define NUMBER_INTERVAL	1
 
-#define ABS(x)		((x) >= 0 ? (x) : -(x))
-#define MIN(x, y)	((x) < (y) ? (x) : (y))
+#define	SCALE_SPLIT_VIEW(height)	((height) * 2 / 3)
 
-#define ARRAY_SIZE(x)	(sizeof(x) / sizeof(x[0]))
-#define STRING_SIZE(x)	(sizeof(x) - 1)
-
-/* Some ascii-shorthands that fit into the ncurses namespace. */
-#define KEY_TAB		9
+/* Some ascii-shorthands fitted into the ncurses namespace. */
+#define KEY_TAB		'\t'
+#define KEY_RETURN	'\r'
 #define KEY_ESC		27
 
-/* User requests. */
+/* User action requests. */
 enum request {
+	/* Offset all requests to avoid conflicts with ncurses getch values. */
+	REQ_OFFSET = KEY_MAX + 1,
+
 	/* XXX: Keep the view request first and in sync with views[]. */
 	REQ_VIEW_MAIN,
 	REQ_VIEW_DIFF,
 	REQ_VIEW_LOG,
 	REQ_VIEW_HELP,
+	REQ_VIEW_PAGER,
 
+	REQ_ENTER,
 	REQ_QUIT,
-	REQ_SHOW_VERSION,
-	REQ_STOP_LOADING,
+	REQ_PROMPT,
 	REQ_SCREEN_REDRAW,
+	REQ_SCREEN_RESIZE,
 	REQ_SCREEN_UPDATE,
+	REQ_SHOW_VERSION,
+	REQ_STOP_LOADING,
 	REQ_TOGGLE_LINE_NUMBERS,
+	REQ_VIEW_NEXT,
 
 	REQ_MOVE_UP,
 	REQ_MOVE_DOWN,
@@ -97,24 +111,68 @@ enum request {
 };
 
 struct commit {
-	char id[41];
-	char title[75];
-	char author[75];
-	struct tm time;
+	char id[41];		/* SHA1 ID. */
+	char title[75];		/* The first line of the commit message. */
+	char author[75];	/* The author of the commit. */
+	struct tm time;		/* Date from the author ident. */
 };
 
+/*
+ * String helpers
+ */
 
 static inline void
 string_ncopy(char *dst, char *src, int dstlen)
 {
 	strncpy(dst, src, dstlen - 1);
 	dst[dstlen - 1] = 0;
+
 }
 
 /* Shorthand for safely copying into a fixed buffer. */
 #define string_copy(dst, src) \
 	string_ncopy(dst, src, sizeof(dst))
 
+/* Shell quoting
+ *
+ * NOTE: The following is a slightly modified copy of the git project's shell
+ * quoting routines found in the quote.c file.
+ *
+ * Help to copy the thing properly quoted for the shell safety.  any single
+ * quote is replaced with '\'', any exclamation point is replaced with '\!',
+ * and the whole thing is enclosed in a
+ *
+ * E.g.
+ *  original     sq_quote     result
+ *  name     ==> name      ==> 'name'
+ *  a b      ==> a b       ==> 'a b'
+ *  a'b      ==> a'\''b    ==> 'a'\''b'
+ *  a!b      ==> a'\!'b    ==> 'a'\!'b'
+ */
+
+static size_t
+sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
+{
+	char c;
+
+#define BUFPUT(x) ( (bufsize < SIZEOF_CMD) && (buf[bufsize++] = (x)) )
+
+	BUFPUT('\'');
+	while ((c = *src++)) {
+		if (c == '\'' || c == '!') {
+			BUFPUT('\'');
+			BUFPUT('\\');
+			BUFPUT(c);
+			BUFPUT('\'');
+		} else {
+			BUFPUT(c);
+		}
+	}
+	BUFPUT('\'');
+
+	return bufsize;
+}
+
 
 /**
  * OPTIONS
@@ -123,13 +181,12 @@ string_ncopy(char *dst, char *src, int dstlen)
 
 static int opt_line_number	= FALSE;
 static int opt_num_interval	= NUMBER_INTERVAL;
-static int opt_request		= REQ_VIEW_MAIN;
-
-char ref_head[SIZEOF_REF]	= "HEAD";
-char ref_commit[SIZEOF_REF]	= "HEAD";
+static enum request opt_request = REQ_VIEW_MAIN;
+static char opt_cmd[SIZEOF_CMD]	= "";
+static FILE *opt_pipe		= NULL;
 
 /* Returns the index of log or diff command or -1 to exit. */
-static int
+static bool
 parse_options(int argc, char *argv[])
 {
 	int i;
@@ -138,39 +195,30 @@ parse_options(int argc, char *argv[])
 		char *opt = argv[i];
 
 		/**
-		 * log [options]::
-		 *	git log options.
-		 *
-		 * diff [options]::
-		 *	git diff options.
-		 **/
-		if (!strcmp(opt, "log") ||
-		    !strcmp(opt, "diff")) {
-			opt_request = opt[0] = 'l'
-				    ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
-			return i;
-
-		/**
 		 * -l::
-		 *	Start up in log view.
+		 *	Start up in log view using the internal log command.
 		 **/
-		} else if (!strcmp(opt, "-l")) {
+		if (!strcmp(opt, "-l")) {
 			opt_request = REQ_VIEW_LOG;
+			continue;
+		}
 
 		/**
 		 * -d::
-		 *	Start up in diff view.
+		 *	Start up in diff view using the internal diff command.
 		 **/
-		} else if (!strcmp(opt, "-d")) {
+		if (!strcmp(opt, "-d")) {
 			opt_request = REQ_VIEW_DIFF;
+			continue;
+		}
 
 		/**
 		 * -n[INTERVAL], --line-number[=INTERVAL]::
 		 *	Prefix line numbers in log and diff view.
 		 *	Optionally, with interval different than each line.
 		 **/
-		} else if (!strncmp(opt, "-n", 2) ||
-		           !strncmp(opt, "--line-number", 13)) {
+		if (!strncmp(opt, "-n", 2) ||
+		    !strncmp(opt, "--line-number", 13)) {
 			char *num = opt;
 
 			if (opt[1] == 'n') {
@@ -183,56 +231,123 @@ parse_options(int argc, char *argv[])
 			if (isdigit(*num))
 				opt_num_interval = atoi(num);
 
-			opt_line_number = 1;
+			opt_line_number = TRUE;
+			continue;
+		}
 
 		/**
 		 * -v, --version::
 		 *	Show version and exit.
 		 **/
-		} else if (!strcmp(opt, "-v") ||
-			   !strcmp(opt, "--version")) {
+		if (!strcmp(opt, "-v") ||
+		    !strcmp(opt, "--version")) {
 			printf("tig version %s\n", VERSION);
-			return -1;
+			return FALSE;
+		}
 
 		/**
-		 * ref::
-		 *	Commit reference, symbolic or raw SHA1 ID.
+		 * \--::
+		 *	End of tig(1) options. Useful when specifying commands
+		 *	for the main view. Example:
+		 *
+		 *		$ tig -- --since=1.month
 		 **/
-		} else if (opt[0] && opt[0] != '-') {
-			string_copy(ref_head, opt);
-			string_copy(ref_commit, opt);
+		if (!strcmp(opt, "--")) {
+			i++;
+			break;
+		}
 
-		} else {
-			die("unknown command '%s'", opt);
+		/**
+		 * log [options]::
+		 *	Open log view using the given git log options.
+		 *
+		 * diff [options]::
+		 *	Open diff view using the given git diff options.
+		 *
+		 * show [options]::
+		 *	Open diff view using the given git show options.
+		 **/
+		if (!strcmp(opt, "log") ||
+		    !strcmp(opt, "diff") ||
+		    !strcmp(opt, "show")) {
+			opt_request = opt[0] == 'l'
+				    ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
+			break;
 		}
+
+		/* Make stuff like:
+		 *
+		 *	$ tig tag-1.0..HEAD
+		 *
+		 * work. */
+		if (opt[0] && opt[0] != '-')
+			break;
+
+		die("unknown command '%s'", opt);
 	}
 
-	return i;
+	if (!isatty(STDIN_FILENO)) {
+		/**
+		 * Pager mode
+		 * ~~~~~~~~~~
+		 * If stdin is a pipe, any log or diff options will be ignored and the
+		 * pager view will be opened loading data from stdin. The pager mode
+		 * can be used for colorizing output from various git commands.
+		 *
+		 * Example on how to colorize the output of git-show(1):
+		 *
+		 *	$ git show | tig
+		 **/
+		opt_request = REQ_VIEW_PAGER;
+		opt_pipe = stdin;
+
+	} else if (i < argc) {
+		size_t buf_size;
+
+		/**
+		 * Git command options
+		 * ~~~~~~~~~~~~~~~~~~~
+		 * All git command options specified on the command line will
+		 * be passed to the given command and all will be shell quoted
+		 * before used.
+		 *
+		 * NOTE: It is possible to specify options even for the main
+		 * view. If doing this you should not touch the `--pretty`
+		 * option.
+		 *
+		 * Example on how to open the log view and show both author and
+		 * committer information:
+		 *
+		 *	$ tig log --pretty=fuller
+		 **/
+
+		if (opt_request == REQ_VIEW_MAIN)
+			/* XXX: This is vulnerable to the user overriding
+			 * options required for the main view parser. */
+			string_copy(opt_cmd, "git log --stat --pretty=raw");
+		else
+			string_copy(opt_cmd, "git");
+		buf_size = strlen(opt_cmd);
+
+		while (buf_size < sizeof(opt_cmd) && i < argc) {
+			opt_cmd[buf_size++] = ' ';
+			buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
+		}
+
+		if (buf_size >= sizeof(opt_cmd))
+			die("command too long");
+
+		opt_cmd[buf_size] = 0;
+
+	}
+
+	return TRUE;
 }
 
 
 /**
  * KEYS
  * ----
- *
- * d::
- *	diff
- * l::
- *	log
- * q::
- *	quit
- * r::
- *	redraw screen
- * s::
- *	stop all background loading
- * j::
- *	down
- * k::
- *	up
- * h, ?::
- *	help
- * v::
- *	version
  **/
 
 #define HELP "(d)iff, (l)og, (m)ain, (q)uit, (v)ersion, (h)elp"
@@ -243,7 +358,50 @@ struct keymap {
 };
 
 struct keymap keymap[] = {
-	/* Cursor navigation */
+	/**
+	 * View switching
+	 * ~~~~~~~~~~~~~~
+	 * d::
+	 *	Switch to diff view.
+	 * l::
+	 *	Switch to log view.
+	 * m::
+	 *	Switch to main view.
+	 * p::
+	 *	Switch to pager view.
+	 * h::
+	 *	Show man page.
+	 * Return::
+	 *	If in main view split the view
+	 *	and show the diff in the bottom view.
+	 * Tab::
+	 *	Switch to next view.
+	 **/
+	{ 'm',		REQ_VIEW_MAIN },
+	{ 'd',		REQ_VIEW_DIFF },
+	{ 'l',		REQ_VIEW_LOG },
+	{ 'p',		REQ_VIEW_PAGER },
+	{ 'h',		REQ_VIEW_HELP },
+
+	{ KEY_TAB,	REQ_VIEW_NEXT },
+	{ KEY_RETURN,	REQ_ENTER },
+
+	/**
+	 * Cursor navigation
+	 * ~~~~~~~~~~~~~~~~~
+	 * Up, k::
+	 *	Move curser one line up.
+	 * Down, j::
+	 *	Move cursor one line down.
+	 * Page Up::
+	 *	Move curser one page up.
+	 * Page Down::
+	 *	Move cursor one page down.
+	 * Home::
+	 *	Jump to first line.
+	 * End::
+	 *	Jump to last line.
+	 **/
 	{ KEY_UP,	REQ_MOVE_UP },
 	{ 'k',		REQ_MOVE_UP },
 	{ KEY_DOWN,	REQ_MOVE_DOWN },
@@ -253,40 +411,68 @@ struct keymap keymap[] = {
 	{ KEY_NPAGE,	REQ_MOVE_PAGE_DOWN },
 	{ KEY_PPAGE,	REQ_MOVE_PAGE_UP },
 
-	/* Scrolling */
-	{ KEY_IC,	REQ_SCROLL_LINE_UP }, /* scroll field backward a line */
-	{ KEY_DC,	REQ_SCROLL_LINE_DOWN }, /* scroll field forward a line	*/
-	{ 's',		REQ_SCROLL_PAGE_DOWN }, /* scroll field forward a page	*/
-	{ 'w',		REQ_SCROLL_PAGE_UP }, /* scroll field backward a page */
-
-	/* View switching */
-	{ 'm',		REQ_VIEW_MAIN },
-	{ 'd',		REQ_VIEW_DIFF },
-	{ 'l',		REQ_VIEW_LOG },
-	{ 'h',		REQ_VIEW_HELP },
-
-	/* Misc */
+	/**
+	 * Scrolling
+	 * ~~~~~~~~~
+	 * Insert::
+	 *	Scroll view one line up.
+	 * Delete::
+	 *	Scroll view one line down.
+	 * w::
+	 *	Scroll view one page up.
+	 * s::
+	 *	Scroll view one page down.
+	 **/
+	{ KEY_IC,	REQ_SCROLL_LINE_UP },
+	{ KEY_DC,	REQ_SCROLL_LINE_DOWN },
+	{ 'w',		REQ_SCROLL_PAGE_UP },
+	{ 's',		REQ_SCROLL_PAGE_DOWN },
+
+	/**
+	 * Misc
+	 * ~~~~
+	 * q, Escape::
+	 *	Quit
+	 * r::
+	 *	Redraw screen.
+	 * z::
+	 *	Stop all background loading.
+	 * v::
+	 *	Show version.
+	 * n::
+	 *	Toggle line numbers on/off.
+	 * ':'::
+	 *	Open prompt. This allows you to specify what git command to run.
+	 *	Example:
+	 *
+	 *	:log -p
+	 *
+	 **/
 	{ KEY_ESC,	REQ_QUIT },
 	{ 'q',		REQ_QUIT },
 	{ 'z',		REQ_STOP_LOADING },
 	{ 'v',		REQ_SHOW_VERSION },
 	{ 'r',		REQ_SCREEN_REDRAW },
 	{ 'n',		REQ_TOGGLE_LINE_NUMBERS },
+	{ ':',		REQ_PROMPT },
 
 	/* wgetch() with nodelay() enabled returns ERR when there's no input. */
 	{ ERR,		REQ_SCREEN_UPDATE },
+
+	/* Use the ncurses SIGWINCH handler. */
+	{ KEY_RESIZE,	REQ_SCREEN_RESIZE },
 };
 
-static int
-get_request(int request)
+static enum request
+get_request(int key)
 {
 	int i;
 
 	for (i = 0; i < ARRAY_SIZE(keymap); i++)
-		if (keymap[i].alias == request)
+		if (keymap[i].alias == key)
 			return keymap[i].request;
 
-	return request;
+	return (enum request) key;
 }
 
 
@@ -294,43 +480,47 @@ get_request(int request)
  * Line-oriented content detection.
  */
 
-/*	     Line type	   String to match	Foreground	Background	Attr
- *	     ---------     ---------------      ----------      ----------      ---- */
 #define LINE_INFO \
-	/* Diff markup */ \
-	LINE(DIFF,	   "diff --git ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	LINE(INDEX,	   "index ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_CHUNK,   "@@",		COLOR_MAGENTA,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_ADD,	   "+",			COLOR_GREEN,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_DEL,	   "-",			COLOR_RED,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_OLDMODE, "old mode ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_NEWMODE, "new mode ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_COPY,	   "copy ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_RENAME,  "rename ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_SIM,	   "similarity ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	LINE(DIFF_DISSIM,  "dissimilarity ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	/* Pretty print commit header */ \
-	LINE(AUTHOR,	   "Author: ",		COLOR_CYAN,	COLOR_DEFAULT,	0), \
-	LINE(MERGE,	   "Merge: ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
-	LINE(DATE,	   "Date:   ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	/* Raw commit header */ \
-	LINE(COMMIT,	   "commit ",		COLOR_GREEN,	COLOR_DEFAULT,	0), \
-	LINE(PARENT,	   "parent ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
-	LINE(TREE,	   "tree ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
-	LINE(AUTHOR_IDENT, "author ",		COLOR_CYAN,	COLOR_DEFAULT,	0), \
-	LINE(COMMITTER,	   "committer ",	COLOR_MAGENTA,	COLOR_DEFAULT,	0), \
-	/* Misc */ \
-	LINE(DIFF_TREE,	   "diff-tree ",	COLOR_BLUE,	COLOR_DEFAULT,	0), \
-	LINE(SIGNOFF,	   "    Signed-off-by", COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-	/* UI colors */ \
-	LINE(DEFAULT,	   "",	COLOR_DEFAULT,	COLOR_DEFAULT,	A_NORMAL), \
-	LINE(CURSOR,	   "",	COLOR_WHITE,	COLOR_GREEN,	A_BOLD), \
-	LINE(STATUS,	   "",	COLOR_GREEN,	COLOR_DEFAULT,	0), \
-	LINE(TITLE,	   "",	COLOR_WHITE,	COLOR_BLUE,	A_BOLD), \
-	LINE(MAIN_DATE,    "",	COLOR_BLUE,	COLOR_DEFAULT,	0), \
-	LINE(MAIN_AUTHOR,  "",	COLOR_GREEN,	COLOR_DEFAULT,	0), \
-	LINE(MAIN_COMMIT,  "",	COLOR_DEFAULT,	COLOR_DEFAULT,	0), \
-	LINE(MAIN_DELIM,   "",	COLOR_MAGENTA,	COLOR_DEFAULT,	0),
+/*   Line type	   String to match	Foreground	Background	Attributes
+ *   ---------     ---------------      ----------      ----------      ---------- */ \
+/* Diff markup */ \
+LINE(DIFF,	   "diff --git ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_INDEX,   "index ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
+LINE(DIFF_CHUNK,   "@@",		COLOR_MAGENTA,	COLOR_DEFAULT,	0), \
+LINE(DIFF_ADD,	   "+",			COLOR_GREEN,	COLOR_DEFAULT,	0), \
+LINE(DIFF_DEL,	   "-",			COLOR_RED,	COLOR_DEFAULT,	0), \
+LINE(DIFF_OLDMODE, "old mode ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_NEWMODE, "new mode ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_COPY,	   "copy ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_RENAME,  "rename ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_SIM,	   "similarity ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_DISSIM,  "dissimilarity ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+/* Pretty print commit header */ \
+LINE(PP_AUTHOR,	   "Author: ",		COLOR_CYAN,	COLOR_DEFAULT,	0), \
+LINE(PP_COMMIT,	   "Commit: ",		COLOR_MAGENTA,	COLOR_DEFAULT,	0), \
+LINE(PP_MERGE,	   "Merge: ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
+LINE(PP_DATE,	   "Date:   ",		COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(PP_ADATE,	   "AuthorDate: ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(PP_CDATE,	   "CommitDate: ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+/* Raw commit header */ \
+LINE(COMMIT,	   "commit ",		COLOR_GREEN,	COLOR_DEFAULT,	0), \
+LINE(PARENT,	   "parent ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
+LINE(TREE,	   "tree ",		COLOR_BLUE,	COLOR_DEFAULT,	0), \
+LINE(AUTHOR,	   "author ",		COLOR_CYAN,	COLOR_DEFAULT,	0), \
+LINE(COMMITTER,	   "committer ",	COLOR_MAGENTA,	COLOR_DEFAULT,	0), \
+/* Misc */ \
+LINE(DIFF_TREE,	   "diff-tree ",	COLOR_BLUE,	COLOR_DEFAULT,	0), \
+LINE(SIGNOFF,	   "    Signed-off-by", COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+/* UI colors */ \
+LINE(DEFAULT,	   "",			COLOR_DEFAULT,	COLOR_DEFAULT,	A_NORMAL), \
+LINE(CURSOR,	   "",			COLOR_WHITE,	COLOR_GREEN,	A_BOLD), \
+LINE(STATUS,	   "",			COLOR_GREEN,	COLOR_DEFAULT,	0), \
+LINE(TITLE_BLUR,   "",			COLOR_WHITE,	COLOR_BLUE,	0), \
+LINE(TITLE_FOCUS,  "",			COLOR_WHITE,	COLOR_BLUE,	A_BOLD), \
+LINE(MAIN_DATE,    "",			COLOR_BLUE,	COLOR_DEFAULT,	0), \
+LINE(MAIN_AUTHOR,  "",			COLOR_GREEN,	COLOR_DEFAULT,	0), \
+LINE(MAIN_COMMIT,  "",			COLOR_DEFAULT,	COLOR_DEFAULT,	0), \
+LINE(MAIN_DELIM,   "",			COLOR_MAGENTA,	COLOR_DEFAULT,	0),
 
 enum line_type {
 #define LINE(type, line, fg, bg, attr) \
@@ -340,7 +530,6 @@ enum line_type {
 };
 
 struct line_info {
-	enum line_type type;	/* Returned when looking up line type. */
 	char *line;		/* The start of line to match. */
 	int linelen;		/* Size of string to match. */
 	int fg, bg, attr;	/* Color and text attributes for the lines. */
@@ -348,7 +537,7 @@ struct line_info {
 
 static struct line_info line_info[] = {
 #define LINE(type, line, fg, bg, attr) \
-	{ LINE_##type, (line), STRING_SIZE(line), (fg), (bg), (attr) }
+	{ (line), STRING_SIZE(line), (fg), (bg), (attr) }
 	LINE_INFO
 #undef	LINE
 };
@@ -357,13 +546,13 @@ static enum line_type
 get_line_type(char *line)
 {
 	int linelen = strlen(line);
-	int i;
+	enum line_type type;
 
-	for (i = 0; i < ARRAY_SIZE(line_info); i++)
+	for (type = 0; type < ARRAY_SIZE(line_info); type++)
 		/* Case insensitive search matches Signed-off-by lines better. */
-		if (linelen >= line_info[i].linelen &&
-		    !strncasecmp(line_info[i].line, line, line_info[i].linelen))
-			return line_info[i].type;
+		if (linelen >= line_info[type].linelen &&
+		    !strncasecmp(line_info[type].line, line, line_info[type].linelen))
+			return type;
 
 	return LINE_DEFAULT;
 }
@@ -380,7 +569,7 @@ init_colors(void)
 {
 	int default_bg = COLOR_BLACK;
 	int default_fg = COLOR_WHITE;
-	int i;
+	enum line_type type;
 
 	start_color();
 
@@ -389,34 +578,88 @@ init_colors(void)
 		default_fg = -1;
 	}
 
-	for (i = 0; i < ARRAY_SIZE(line_info); i++) {
-		struct line_info *info = &line_info[i];
+	for (type = 0; type < ARRAY_SIZE(line_info); type++) {
+		struct line_info *info = &line_info[type];
 		int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
 		int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
 
-		init_pair(info->type, fg, bg);
+		init_pair(type, fg, bg);
 	}
 }
 
 
+/**
+ * ENVIRONMENT VARIABLES
+ * ---------------------
+ * It is possible to alter which commands are used for the different views.
+ * If for example you prefer commits in the main to be sorted by date and
+ * only show 500 commits, use:
+ *
+ *	$ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
+ *
+ * Or set the variable permanently in your environment.
+ *
+ * Notice, how `%s` is used to specify the commit reference. There can
+ * be a maximum of 5 `%s` ref specifications.
+ *
+ * TIG_DIFF_CMD::
+ *	The command used for the diff view. By default, git show is used
+ *	as a backend.
+ *
+ * TIG_LOG_CMD::
+ *	The command used for the log view.
+ *
+ * TIG_MAIN_CMD::
+ *	The command used for the main view. Note, you must always specify
+ *	the option: `--pretty=raw` since the main view parser expects to
+ *	read that format.
+ **/
+
+#define TIG_DIFF_CMD \
+	"git show --patch-with-stat --find-copies-harder -B -C %s"
+
+#define TIG_LOG_CMD	\
+	"git log --cc --stat -n100 %s"
+
+#define TIG_MAIN_CMD \
+	"git log --topo-order --stat --pretty=raw %s"
+
+/* We silently ignore that the following are also exported. */
+
+#define TIG_HELP_CMD \
+	"man tig 2> /dev/null"
+
+#define TIG_PAGER_CMD \
+	""
+
+
 /*
  * Viewer
  */
 
 struct view {
-	char *name;
-	char *cmd;
-	char *id;
-
-	/* Rendering */
-	int (*read)(struct view *, char *);
-	int (*draw)(struct view *, unsigned int);
+	const char *name;	/* View name */
+	char *cmd_fmt;		/* Default command line format */
+	char *cmd_env;		/* Command line set via environment */
+	char *id;		/* Points to either of ref_{head,commit} */
 	size_t objsize;		/* Size of objects in the line index */
 
-	char cmdbuf[SIZEOF_CMD];
+	struct view_ops {
+		/* Draw one line; @lineno must be < view->height. */
+		bool (*draw)(struct view *view, unsigned int lineno);
+		/* Read one line; updates view->line. */
+		bool (*read)(struct view *view, char *line);
+		/* Depending on view, change display based on current line. */
+		bool (*enter)(struct view *view);
+	} *ops;
 
-	WINDOW *win;
-	int height, width;
+	char cmd[SIZEOF_CMD];	/* Command buffer */
+	char ref[SIZEOF_REF];	/* Hovered commit reference */
+	char vid[SIZEOF_REF];	/* View ID. Set to id member when updating. */
+
+	int height, width;	/* The width and height of the main window */
+	WINDOW *win;		/* The main window */
+	WINDOW *title;		/* The title window living below the main window */
 
 	/* Navigation */
 	unsigned long offset;	/* Offset of the window top */
@@ -424,53 +667,42 @@ struct view {
 
 	/* Buffering */
 	unsigned long lines;	/* Total number of lines */
-	void **line;		/* Line index */
+	void **line;		/* Line index; each line contains user data */
+	unsigned int digits;	/* Number of digits in the lines member. */
 
 	/* Loading */
 	FILE *pipe;
 	time_t start_time;
 };
 
-static int pager_draw(struct view *view, unsigned int lineno);
-static int pager_read(struct view *view, char *line);
-
-static int main_draw(struct view *view, unsigned int lineno);
-static int main_read(struct view *view, char *line);
-
-#define DIFF_CMD \
-	"git log --stat -n1 %s ; echo; " \
-	"git diff --find-copies-harder -B -C %s^ %s"
-
-#define LOG_CMD	\
-	"git log --cc --stat -n100 %s"
-
-#define MAIN_CMD \
-	"git log --stat --pretty=raw %s"
+static struct view_ops pager_ops;
+static struct view_ops main_ops;
 
-#define HELP_CMD \
-	"man tig 2> /dev/null"
+char ref_head[SIZEOF_REF]	= "HEAD";
+char ref_commit[SIZEOF_REF]	= "HEAD";
 
-/* The status window is used for polling keystrokes. */
-static WINDOW *status_win;
-static WINDOW *title_win;
+#define VIEW_STR(name, cmd, env, ref, objsize, ops) \
+	{ name, cmd, #env, ref, objsize, ops }
 
-/* The number of loading views. Controls when nodelay should be in effect when
- * polling user input. */
-static unsigned int nloading;
+#define VIEW_(id, name, ops, ref, objsize) \
+	VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, objsize, ops)
 
 static struct view views[] = {
-	{ "main",  MAIN_CMD,   ref_head,    main_read,   main_draw,  sizeof(struct commit) },
-	{ "diff",  DIFF_CMD,   ref_commit,  pager_read,  pager_draw, sizeof(char) },
-	{ "log",   LOG_CMD,    ref_head,    pager_read,  pager_draw, sizeof(char) },
-	{ "help",  HELP_CMD,   ref_head,    pager_read,  pager_draw, sizeof(char) },
+	VIEW_(MAIN,  "main",  &main_ops,  ref_head,   sizeof(struct commit)),
+	VIEW_(DIFF,  "diff",  &pager_ops, ref_commit, sizeof(char)),
+	VIEW_(LOG,   "log",   &pager_ops, ref_head,   sizeof(char)),
+	VIEW_(HELP,  "help",  &pager_ops, ref_head,   sizeof(char)),
+	VIEW_(PAGER, "pager", &pager_ops, "static",   sizeof(char)),
 };
 
+#define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
+
 /* The display array of active views and the index of the current view. */
-static struct view *display[ARRAY_SIZE(views)];
+static struct view *display[2];
 static unsigned int current_view;
 
 #define foreach_view(view, i) \
-	for (i = 0; i < sizeof(display) && (view = display[i]); i++)
+	for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
 
 
 static void
@@ -479,7 +711,7 @@ redraw_view_from(struct view *view, int lineno)
 	assert(0 <= lineno && lineno < view->height);
 
 	for (; lineno < view->height; lineno++) {
-		if (!view->draw(view, lineno))
+		if (!view->ops->draw(view, lineno))
 			break;
 	}
 
@@ -495,28 +727,87 @@ redraw_view(struct view *view)
 }
 
 static void
-resize_view(struct view *view)
+resize_display(void)
 {
-	int lines, cols;
+	int offset, i;
+	struct view *base = display[0];
+	struct view *view = display[1] ? display[1] : display[0];
 
-	getmaxyx(stdscr, lines, cols);
+	/* Setup window dimensions */
 
-	if (view->win) {
-		mvwin(view->win, 0, 0);
-		wresize(view->win, lines - 2, cols);
+	getmaxyx(stdscr, base->height, base->width);
 
-	} else {
-		view->win = newwin(lines - 2, 0, 0, 0);
+	/* Make room for the status window. */
+	base->height -= 1;
+
+	if (view != base) {
+		/* Horizontal split. */
+		view->width   = base->width;
+		view->height  = SCALE_SPLIT_VIEW(base->height);
+		base->height -= view->height;
+
+		/* Make room for the title bar. */
+		view->height -= 1;
+	}
+
+	/* Make room for the title bar. */
+	base->height -= 1;
+
+	offset = 0;
+
+	foreach_view (view, i) {
 		if (!view->win) {
-			report("Failed to create %s view", view->name);
-			return;
+			view->win = newwin(view->height, 0, offset, 0);
+			if (!view->win)
+				die("Failed to create %s view", view->name);
+
+			scrollok(view->win, TRUE);
+
+			view->title = newwin(1, 0, offset + view->height, 0);
+			if (!view->title)
+				die("Failed to create title window");
+
+		} else {
+			wresize(view->win, view->height, view->width);
+			mvwin(view->win,   offset, 0);
+			mvwin(view->title, offset + view->height, 0);
+			wrefresh(view->win);
 		}
-		scrollok(view->win, TRUE);
-	}
 
-	getmaxyx(view->win, view->height, view->width);
+		offset += view->height + 1;
+	}
 }
 
+static void
+update_view_title(struct view *view)
+{
+	if (view == display[current_view])
+		wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
+	else
+		wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
+
+	werase(view->title);
+	wmove(view->title, 0, 0);
+
+	/* [main] ref: 334b506... - commit 6 of 4383 (0%) */
+
+	if (*view->ref)
+		wprintw(view->title, "[%s] ref: %s", view->name, view->ref);
+	else
+		wprintw(view->title, "[%s]", view->name);
+
+	if (view->lines) {
+		char *type = view == VIEW(REQ_VIEW_MAIN) ? "commit" : "line";
+
+		wprintw(view->title, " - %s %d of %d (%d%%)",
+			type,
+			view->lineno + 1,
+			view->lines,
+			(view->lineno + 1) * 100 / view->lines);
+	}
+
+	wrefresh(view->title);
+}
 
 /*
  * Navigation
@@ -543,7 +834,7 @@ do_scroll_view(struct view *view, int lines)
 		wscrl(view->win, lines);
 
 		for (; line < end; line++) {
-			if (!view->draw(view, line))
+			if (!view->ops->draw(view, line))
 				break;
 		}
 	}
@@ -551,11 +842,11 @@ do_scroll_view(struct view *view, int lines)
 	/* Move current line into the view. */
 	if (view->lineno < view->offset) {
 		view->lineno = view->offset;
-		view->draw(view, 0);
+		view->ops->draw(view, 0);
 
 	} else if (view->lineno >= view->offset + view->height) {
 		view->lineno = view->offset + view->height - 1;
-		view->draw(view, view->lineno - view->offset);
+		view->ops->draw(view, view->lineno - view->offset);
 	}
 
 	assert(view->offset <= view->lineno && view->lineno < view->lines);
@@ -567,7 +858,7 @@ do_scroll_view(struct view *view, int lines)
 
 /* Scroll frontend */
 static void
-scroll_view(struct view *view, int request)
+scroll_view(struct view *view, enum request request)
 {
 	int lines = 1;
 
@@ -579,7 +870,7 @@ scroll_view(struct view *view, int request)
 			lines = view->lines - view->offset;
 
 		if (lines == 0 || view->offset + view->height >= view->lines) {
-			report("Already at last line");
+			report("Cannot scroll beyond the last line");
 			return;
 		}
 		break;
@@ -591,12 +882,15 @@ scroll_view(struct view *view, int request)
 			lines = view->offset;
 
 		if (lines == 0) {
-			report("Already at first line");
+			report("Cannot scroll beyond the first line");
 			return;
 		}
 
 		lines = -lines;
 		break;
+
+	default:
+		die("request %d not handled in switch", request);
 	}
 
 	do_scroll_view(view, lines);
@@ -604,7 +898,7 @@ scroll_view(struct view *view, int request)
 
 /* Cursor moving */
 static void
-move_view(struct view *view, int request)
+move_view(struct view *view, enum request request)
 {
 	int steps;
 
@@ -634,14 +928,17 @@ move_view(struct view *view, int request)
 	case REQ_MOVE_DOWN:
 		steps = 1;
 		break;
+
+	default:
+		die("request %d not handled in switch", request);
 	}
 
 	if (steps <= 0 && view->lineno == 0) {
-		report("Already at first line");
+		report("Cannot move beyond the first line");
 		return;
 
-	} else if (steps >= 0 && view->lineno + 1 == view->lines) {
-		report("Already at last line");
+	} else if (steps >= 0 && view->lineno + 1 >= view->lines) {
+		report("Cannot move beyond the last line");
 		return;
 	}
 
@@ -655,7 +952,7 @@ move_view(struct view *view, int request)
 
 		wmove(view->win, prev_lineno, 0);
 		wclrtoeol(view->win);
-		view->draw(view, view->lineno - steps - view->offset);
+		view->ops->draw(view, prev_lineno);
 	}
 
 	/* Check whether the view needs to be scrolled */
@@ -678,7 +975,7 @@ move_view(struct view *view, int request)
 	}
 
 	/* Draw the current line */
-	view->draw(view, view->lineno - view->offset);
+	view->ops->draw(view, view->lineno - view->offset);
 
 	redrawwin(view->win);
 	wrefresh(view->win);
@@ -695,19 +992,37 @@ begin_update(struct view *view)
 {
 	char *id = view->id;
 
-	if (snprintf(view->cmdbuf, sizeof(view->cmdbuf), view->cmd,
-		     id, id, id) < sizeof(view->cmdbuf))
-		view->pipe = popen(view->cmdbuf, "r");
+	if (opt_cmd[0]) {
+		string_copy(view->cmd, opt_cmd);
+		opt_cmd[0] = 0;
+		/* When running random commands, the view ref could have become
+		 * invalid so clear it. */
+		view->ref[0] = 0;
+	} else {
+		char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
+
+		if (snprintf(view->cmd, sizeof(view->cmd), format,
+			     id, id, id, id, id) >= sizeof(view->cmd))
+			return FALSE;
+	}
+
+	/* Special case for the pager view. */
+	if (opt_pipe) {
+		view->pipe = opt_pipe;
+		opt_pipe = NULL;
+	} else {
+		view->pipe = popen(view->cmd, "r");
+	}
 
 	if (!view->pipe)
 		return FALSE;
 
-	if (nloading++ == 0)
-		nodelay(status_win, TRUE);
+	set_nonblocking_input(TRUE);
 
 	view->offset = 0;
 	view->lines  = 0;
 	view->lineno = 0;
+	string_copy(view->vid, id);
 
 	if (view->line) {
 		int i;
@@ -728,14 +1043,17 @@ begin_update(struct view *view)
 static void
 end_update(struct view *view)
 {
-	if (nloading-- == 1)
-		nodelay(status_win, FALSE);
-
-	pclose(view->pipe);
+	if (!view->pipe)
+		return;
+	set_nonblocking_input(FALSE);
+	if (view->pipe == stdin)
+		fclose(view->pipe);
+	else
+		pclose(view->pipe);
 	view->pipe = NULL;
 }
 
-static int
+static bool
 update_view(struct view *view)
 {
 	char buffer[BUFSIZ];
@@ -744,7 +1062,7 @@ update_view(struct view *view)
 	/* The number of lines to read. If too low it will cause too much
 	 * redrawing (and possible flickering), if too high responsiveness
 	 * will suffer. */
-	int lines = view->height;
+	unsigned long lines = view->height;
 	int redraw_from = -1;
 
 	if (!view->pipe)
@@ -767,19 +1085,31 @@ update_view(struct view *view)
 		if (linelen)
 			line[linelen - 1] = 0;
 
-		if (!view->read(view, line))
+		if (!view->ops->read(view, line))
 			goto alloc_error;
 
 		if (lines-- == 1)
 			break;
 	}
 
-	/* CPU hogilicious! */
-	update_title();
+	{
+		int digits;
+
+		lines = view->lines;
+		for (digits = 0; lines; digits++)
+			lines /= 10;
+
+		/* Keep the displayed view in sync with line number scaling. */
+		if (digits != view->digits) {
+			view->digits = digits;
+			redraw_from = 0;
+		}
+	}
 
 	if (redraw_from >= 0) {
 		/* If this is an incremental update, redraw the previous line
-		 * since for commits some members could have changed. */
+		 * since for commits some members could have changed when
+		 * loading the main view. */
 		if (redraw_from > 0)
 			redraw_from--;
 
@@ -787,15 +1117,19 @@ update_view(struct view *view)
 		redraw_view_from(view, redraw_from);
 	}
 
+	/* Update the title _after_ the redraw so that if the redraw picks up a
+	 * commit reference in view->ref it'll be available here. */
+	update_view_title(view);
+
 	if (ferror(view->pipe)) {
-		report("Failed to read %s: %s", view->cmd, strerror(errno));
+		report("Failed to read: %s", strerror(errno));
 		goto end;
 
 	} else if (feof(view->pipe)) {
 		time_t secs = time(NULL) - view->start_time;
 
-		if (view == &views[REQ_VIEW_HELP]){
-			report(HELP);
+		if (view == VIEW(REQ_VIEW_HELP)) {
+			report("%s", HELP);
 			goto end;
 		}
 
@@ -814,58 +1148,97 @@ end:
 	return FALSE;
 }
 
-static struct view *
-switch_view(struct view *prev, int request)
+enum open_flags {
+	OPEN_DEFAULT = 0,	/* Use default view switching. */
+	OPEN_SPLIT = 1,		/* Split current view. */
+	OPEN_BACKGROUNDED = 2,	/* Backgrounded. */
+	OPEN_RELOAD = 4,	/* Reload view even if it is the current. */
+};
+
+static void
+open_view(struct view *prev, enum request request, enum open_flags flags)
 {
-	struct view *view = &views[request];
+	bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
+	bool split = !!(flags & OPEN_SPLIT);
+	bool reload = !!(flags & OPEN_RELOAD);
+	struct view *view = VIEW(request);
 	struct view *displayed;
-	int i;
+	int nviews;
+
+	/* Cycle between displayed views and count the views. */
+	foreach_view (displayed, nviews) {
+		if (prev != view &&
+		    view == displayed &&
+		    !strcmp(view->vid, prev->vid)) {
+			current_view = nviews;
+			/* Blur out the title of the previous view. */
+			update_view_title(prev);
+			report("Switching to %s view", view->name);
+			return;
+		}
+	}
+
+	if (view == prev && nviews == 1 && !reload) {
+		report("Already in %s view", view->name);
+		return;
+	}
 
-	if (prev && prev->pipe)
-		end_update(prev);
+	if ((reload || strcmp(view->vid, view->id)) &&
+	    !begin_update(view)) {
+		report("Failed to load %s view", view->name);
+		return;
+	}
 
-	if (view == prev) {
-		foreach_view (displayed, i) ;
+	if (split) {
+		display[current_view + 1] = view;
+		if (!backgrounded)
+			current_view++;
+	} else {
+		/* Maximize the current view. */
+		memset(display, 0, sizeof(display));
+		current_view = 0;
+		display[current_view] = view;
+	}
 
-		if (i == 1)
-			report("Already in %s view", view->name);
-		else
-			report("FIXME: Maximize");
+	resize_display();
 
-		return view;
+	if (split && prev->lineno - prev->offset >= prev->height) {
+		/* Take the title line into account. */
+		int lines = prev->lineno - prev->offset - prev->height + 1;
 
-	} else {
-		foreach_view (displayed, i) {
-			if (view == displayed) {
-				current_view = i;
-				report("new current view");
-				return view;
-			}
-		}
+		/* Scroll the view that was split if the current line is
+		 * outside the new limited view. */
+		do_scroll_view(prev, lines);
 	}
 
-	if (!view->win)
-		resize_view(view);
+	if (prev && view != prev) {
+		/* "Blur" the previous view. */
+		update_view_title(prev);
 
-	/* Reload */
+		/* Continue loading split views in the background. */
+		if (!split)
+			end_update(prev);
+	}
 
-	if (begin_update(view)) {
+	if (view->pipe) {
 		/* Clear the old view and let the incremental updating refill
 		 * the screen. */
-		display[current_view] = view;
 		wclear(view->win);
 		report("Loading...");
+	} else {
+		redraw_view(view);
+		report("");
 	}
-
-	return view;
 }
 
 
-/* Process keystrokes */
+/*
+ * User request switch noodle
+ */
+
 static int
-view_driver(struct view *view, int key)
+view_driver(struct view *view, enum request request)
 {
-	int request = get_request(key);
 	int i;
 
 	switch (request) {
@@ -875,43 +1248,77 @@ view_driver(struct view *view, int key)
 	case REQ_MOVE_PAGE_DOWN:
 	case REQ_MOVE_FIRST_LINE:
 	case REQ_MOVE_LAST_LINE:
-		if (view)
-			move_view(view, request);
+		move_view(view, request);
 		break;
 
 	case REQ_SCROLL_LINE_DOWN:
 	case REQ_SCROLL_LINE_UP:
 	case REQ_SCROLL_PAGE_DOWN:
 	case REQ_SCROLL_PAGE_UP:
-		if (view)
-			scroll_view(view, request);
+		scroll_view(view, request);
 		break;
 
 	case REQ_VIEW_MAIN:
 	case REQ_VIEW_DIFF:
 	case REQ_VIEW_LOG:
 	case REQ_VIEW_HELP:
-		view = switch_view(view, request);
+	case REQ_VIEW_PAGER:
+		open_view(view, request, OPEN_DEFAULT);
 		break;
 
+	case REQ_ENTER:
+		if (!view->lines) {
+			report("Nothing to enter");
+			break;
+		}
+		return view->ops->enter(view);
+
+	case REQ_VIEW_NEXT:
+	{
+		int nviews = display[1] ? 2 : 1;
+		int next_view = (current_view + 1) % nviews;
+
+		if (next_view == current_view) {
+			report("Only one view is displayed");
+			break;
+		}
+
+		current_view = next_view;
+		/* Blur out the title of the previous view. */
+		update_view_title(view);
+		report("Switching to %s view", display[current_view]->name);
+		break;
+	}
 	case REQ_TOGGLE_LINE_NUMBERS:
 		opt_line_number = !opt_line_number;
-		if (view)
-			redraw_view(view);
+		redraw_view(view);
+		break;
+
+	case REQ_PROMPT:
+		/* Always reload^Wrerun commands from the prompt. */
+		open_view(view, opt_request, OPEN_RELOAD);
 		break;
 
 	case REQ_STOP_LOADING:
-		foreach_view (view, i)
+		foreach_view (view, i) {
 			if (view->pipe)
-				end_update(view);
+				report("Stopped loaded of %s view", view->name),
+			end_update(view);
+		}
 		break;
 
 	case REQ_SHOW_VERSION:
 		report("Version: %s", VERSION);
 		return TRUE;
 
+	case REQ_SCREEN_RESIZE:
+		resize_display();
+		/* Fall-through */
 	case REQ_SCREEN_REDRAW:
-		redraw_view(view);
+		foreach_view (view, i) {
+			redraw_view(view);
+			update_view_title(view);
+		}
 		break;
 
 	case REQ_SCREEN_UPDATE:
@@ -923,7 +1330,7 @@ view_driver(struct view *view, int key)
 
 	default:
 		/* An unknown key will show most commonly used commands. */
-		report(HELP);
+		report("%s", HELP);
 		return TRUE;
 	}
 
@@ -932,10 +1339,10 @@ view_driver(struct view *view, int key)
 
 
 /*
- * Rendering
+ * View backend handlers
  */
 
-static int
+static bool
 pager_draw(struct view *view, unsigned int lineno)
 {
 	enum line_type type;
@@ -950,8 +1357,11 @@ pager_draw(struct view *view, unsigned int lineno)
 	type = get_line_type(line);
 
 	if (view->offset + lineno == view->lineno) {
-		if (type == LINE_COMMIT)
-			string_copy(ref_commit, line + 7);
+		if (type == LINE_COMMIT) {
+			string_copy(view->ref, line + 7);
+			string_copy(ref_commit, view->ref);
+		}
+
 		type = LINE_CURSOR;
 	}
 
@@ -962,13 +1372,17 @@ pager_draw(struct view *view, unsigned int lineno)
 	linelen = MIN(linelen, view->width);
 
 	if (opt_line_number) {
-		unsigned int real_lineno = view->offset + lineno + 1;
-		int col = 1;
+		static char indent[] = "                    ";
+		unsigned long real_lineno = view->offset + lineno + 1;
+		int col = 0;
 
 		if (real_lineno == 1 || (real_lineno % opt_num_interval) == 0)
-			mvwprintw(view->win, lineno, 0, "%4d: ", real_lineno);
-		else
-			mvwaddstr(view->win, lineno, 0, "    : ");
+			mvwprintw(view->win, lineno, 0, "%.*d", view->digits, real_lineno);
+
+		else if (view->digits < sizeof(indent))
+			mvwaddnstr(view->win, lineno, 0, indent, view->digits);
+
+		waddstr(view->win, ": ");
 
 		while (line) {
 			if (*line == '\t') {
@@ -1008,7 +1422,7 @@ pager_draw(struct view *view, unsigned int lineno)
 	return TRUE;
 }
 
-static int
+static bool
 pager_read(struct view *view, char *line)
 {
 	view->line[view->lines] = strdup(line);
@@ -1019,7 +1433,26 @@ pager_read(struct view *view, char *line)
 	return TRUE;
 }
 
-static int
+static bool
+pager_enter(struct view *view)
+{
+	char *line = view->line[view->lineno];
+
+	if (get_line_type(line) == LINE_COMMIT) {
+		open_view(view, REQ_VIEW_DIFF, OPEN_DEFAULT);
+	}
+
+	return TRUE;
+}
+
+static struct view_ops pager_ops = {
+	pager_draw,
+	pager_read,
+	pager_enter,
+};
+
+
+static bool
 main_draw(struct view *view, unsigned int lineno)
 {
 	char buf[DATE_COLS + 1];
@@ -1036,7 +1469,8 @@ main_draw(struct view *view, unsigned int lineno)
 		return FALSE;
 
 	if (view->offset + lineno == view->lineno) {
-		string_copy(ref_commit, commit->id);
+		string_copy(view->ref, commit->id);
+		string_copy(ref_commit, view->ref);
 		type = LINE_CURSOR;
 	} else {
 		type = LINE_MAIN_COMMIT;
@@ -1072,7 +1506,7 @@ main_draw(struct view *view, unsigned int lineno)
 }
 
 /* Reads git log --pretty=raw output and parses it into the commit struct. */
-static int
+static bool
 main_read(struct view *view, char *line)
 {
 	enum line_type type = get_line_type(line);
@@ -1090,7 +1524,7 @@ main_read(struct view *view, char *line)
 		string_copy(commit->id, line);
 		break;
 
-	case LINE_AUTHOR_IDENT:
+	case LINE_AUTHOR:
 	{
 		char *ident = line + STRING_SIZE("author ");
 		char *end = strchr(ident, '<');
@@ -1146,8 +1580,10 @@ main_read(struct view *view, char *line)
 
 		/* Require titles to start with a non-space character at the
 		 * offset used by git log. */
+		/* FIXME: More gracefull handling of titles; append "..." to
+		 * shortened titles, etc. */
 		if (strncmp(line, "    ", 4) ||
-		    isspace(line[5]))
+		    isspace(line[4]))
 			break;
 
 		string_copy(commit->title, line + 4);
@@ -1156,61 +1592,28 @@ main_read(struct view *view, char *line)
 	return TRUE;
 }
 
-
-/*
- * Main
- */
-
-static void
-quit(int sig)
-{
-	if (status_win)
-		delwin(status_win);
-	if (title_win)
-		delwin(title_win);
-	endwin();
-
-	/* FIXME: Shutdown gracefully. */
-
-	exit(0);
-}
-
-static void die(const char *err, ...)
+static bool
+main_enter(struct view *view)
 {
-	va_list args;
-
-	endwin();
-
-	va_start(args, err);
-	fputs("tig: ", stderr);
-	vfprintf(stderr, err, args);
-	fputs("\n", stderr);
-	va_end(args);
-
-	exit(1);
+	open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT | OPEN_BACKGROUNDED);
+	return TRUE;
 }
 
-static void
-update_title(void)
-{
-	struct view *view = display[current_view];
-
-	assert(view);
+static struct view_ops main_ops = {
+	main_draw,
+	main_read,
+	main_enter,
+};
 
-	werase(title_win);
-	wmove(title_win, 0, 0);
+/*
+ * Status management
+ */
 
-	/* [main] ref: 334b506... - line 6 of 4383 (0%) */
-	wprintw(title_win, "[%s] ref: %s", view->name, ref_commit);
-	if (view->lines) {
-		wprintw(title_win, " - line %d of %d (%d%%)",
-			view->lineno + 1,
-			view->lines,
-			(view->lineno + 1) * 100 / view->lines);
-	}
+/* Whether or not the curses interface has been initialized. */
+bool cursed = FALSE;
 
-	wrefresh(title_win);
-}
+/* The status window is used for polling keystrokes. */
+static WINDOW *status_win;
 
 /* Update status and title window. */
 static void
@@ -1218,39 +1621,51 @@ report(const char *msg, ...)
 {
 	va_list args;
 
-	va_start(args, msg);
-
 	/* Update the title window first, so the cursor ends up in the status
 	 * window. */
-	update_title();
+	update_view_title(display[current_view]);
+
+	va_start(args, msg);
 
 	werase(status_win);
 	wmove(status_win, 0, 0);
-	vwprintw(status_win, msg, args);
+	if (*msg)
+		vwprintw(status_win, msg, args);
 	wrefresh(status_win);
 
 	va_end(args);
 }
 
-int
-main(int argc, char *argv[])
+/* Controls when nodelay should be in effect when polling user input. */
+static void
+set_nonblocking_input(bool loading)
+{
+	/* The number of loading views. */
+	static unsigned int nloading;
+
+	if ((loading == FALSE && nloading-- == 1) ||
+	    (loading == TRUE  && nloading++ == 0))
+		nodelay(status_win, loading);
+}
+
+static void
+init_display(void)
 {
 	int x, y;
-	int request;
-	int git_cmd;
 
-	signal(SIGINT, quit);
+	/* Initialize the curses library */
+	if (isatty(STDIN_FILENO)) {
+		cursed = !!initscr();
+	} else {
+		/* Leave stdin and stdout alone when acting as a pager. */
+		FILE *io = fopen("/dev/tty", "r+");
 
-	git_cmd = parse_options(argc, argv);
-	if (git_cmd < 0)
-		return 0;
-	if (git_cmd < argc) {
-		die("Too many options");
+		cursed = !!newterm(NULL, io, io);
 	}
 
-	request = opt_request;
+	if (!cursed)
+		die("Failed to initialize curses");
 
-	initscr();      /* Initialize the curses library */
 	nonl();         /* Tell curses not to do NL->CR/NL on output */
 	cbreak();       /* Take input chars one at a time, no wait for \n */
 	noecho();       /* Don't echo input */
@@ -1264,37 +1679,105 @@ main(int argc, char *argv[])
 	if (!status_win)
 		die("Failed to create status window");
 
-	title_win = newwin(1, 0, y - 2, 0);
-	if (!title_win)
-		die("Failed to create title window");
-
 	/* Enable keyboard mapping */
 	keypad(status_win, TRUE);
 	wbkgdset(status_win, get_line_attr(LINE_STATUS));
-	wbkgdset(title_win, get_line_attr(LINE_TITLE));
+}
+
+/*
+ * Main
+ */
+
+static void
+quit(int sig)
+{
+	/* XXX: Restore tty modes and let the OS cleanup the rest! */
+	if (cursed)
+		endwin();
+	exit(0);
+}
+
+static void die(const char *err, ...)
+{
+	va_list args;
+
+	endwin();
+
+	va_start(args, err);
+	fputs("tig: ", stderr);
+	vfprintf(stderr, err, args);
+	fputs("\n", stderr);
+	va_end(args);
+
+	exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+	struct view *view;
+	enum request request;
+	size_t i;
+
+	signal(SIGINT, quit);
+
+	if (!parse_options(argc, argv))
+		return 0;
+
+	for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
+		view->cmd_env = getenv(view->cmd_env);
+
+	request = opt_request;
+
+	init_display();
 
 	while (view_driver(display[current_view], request)) {
-		struct view *view;
+		int key;
 		int i;
 
-		foreach_view (view, i) {
-			if (view->pipe) {
-				update_view(view);
-			}
-		}
+		foreach_view (view, i)
+			update_view(view);
 
 		/* Refresh, accept single keystroke of input */
-		request = wgetch(status_win);
-		if (request == KEY_RESIZE) {
-			int lines, cols;
+		key = wgetch(status_win);
+		request = get_request(key);
+
+		/* Some low-level request handling. This keeps handling of
+		 * status_win restricted. */
+		switch (request) {
+		case REQ_PROMPT:
+			report(":");
+			/* Temporarily switch to line-oriented and echoed
+			 * input. */
+			nocbreak();
+			echo();
+
+			if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
+				memcpy(opt_cmd, "git ", 4);
+				opt_request = REQ_VIEW_PAGER;
+			} else {
+				request = ERR;
+			}
+
+			noecho();
+			cbreak();
+			break;
 
-			getmaxyx(stdscr, lines, cols);
+		case REQ_SCREEN_RESIZE:
+		{
+			int height, width;
 
-			mvwin(status_win, lines - 1, 0);
-			wresize(status_win, 1, cols - 1);
+			getmaxyx(stdscr, height, width);
 
-			mvwin(title_win, lines - 2, 0);
-			wresize(title_win, 1, cols - 1);
+			/* Resize the status view and let the view driver take
+			 * care of resizing the displayed views. */
+			wresize(status_win, 1, width);
+			mvwin(status_win, height - 1, 0);
+			wrefresh(status_win);
+			break;
+		}
+		default:
+			break;
 		}
 	}
 
@@ -1308,20 +1791,7 @@ main(int argc, char *argv[])
  * ----
  * Features that should be explored.
  *
- * - Dynamic scaling of line number indentation.
- *
- * - Proper command line handling; ability to take the command that should be
- *   shown. Example:
- *
- *	$ tig log -p
- *
- * - Internal command line (exmode-inspired) which allows to specify what git
- *   log or git diff command to run. Example:
- *
- *	:log -p
- *
- * - Proper resizing support. I am yet to figure out whether catching SIGWINCH
- *   is preferred over using ncurses' built-in support for resizing.
+ * - Searching.
  *
  * - Locale support.
  *