X-Git-Url: https://git.distorted.org.uk/~mdw/tig/blobdiff_plain/6908bdbdb5996f30f7dcb5e2dd71f8c8bbbab8a3..4b8c01a390e2118e6a1c8fc0c50a3be09787166f:/tig.c

diff --git a/tig.c b/tig.c
index 882b2fd..00791a7 100644
--- a/tig.c
+++ b/tig.c
@@ -15,19 +15,28 @@
  * 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.
+ * Browse changes in a git repository. Additionally, tig(1) can also act
+ * as a pager for output of various git commands.
+ *
+ * When browsing repositories, tig(1) uses the underlying git commands
+ * to present the user with various views, such as summarized commit log
+ * and showing the commit with the log message, diffstat, and the diff.
+ *
+ * Using tig(1) as a pager, it will display input from stdin and try
+ * to colorize it.
  **/
 
-#ifndef DEBUG
-#define NDEBUG
+#ifndef	VERSION
+#define VERSION	"tig-0.3"
 #endif
 
-#ifndef	VERSION
-#define VERSION	"tig-0.1"
+#ifndef DEBUG
+#define NDEBUG
 #endif
 
 #include <assert.h>
@@ -45,7 +54,8 @@
 
 static void die(const char *err, ...);
 static void report(const char *msg, ...);
-static void set_nonblocking_input(int boolean);
+static void set_nonblocking_input(bool loading);
+static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
 
 #define ABS(x)		((x) >= 0  ? (x) : -(x))
 #define MIN(x, y)	((x) < (y) ? (x) :  (y))
@@ -59,20 +69,27 @@ static void set_nonblocking_input(int boolean);
 /* This color name can be used to refer to the default term colors. */
 #define COLOR_DEFAULT	(-1)
 
+#define TIG_HELP	"(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
+
 /* 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 AUTHOR_COLS	20
+
 /* The default interval between line numbers. */
 #define NUMBER_INTERVAL	1
 
+#define TABSIZE		8
+
 #define	SCALE_SPLIT_VIEW(height)	((height) * 2 / 3)
 
-/* Some ascii-shorthands that fit into the ncurses namespace. */
+/* Some ascii-shorthands fitted into the ncurses namespace. */
 #define KEY_TAB		'\t'
 #define KEY_RETURN	'\r'
 #define KEY_ESC		27
 
+
 /* User action requests. */
 enum request {
 	/* Offset all requests to avoid conflicts with ncurses getch values. */
@@ -89,14 +106,18 @@ enum request {
 	REQ_QUIT,
 	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_VIEW_CLOSE,
 
 	REQ_MOVE_UP,
+	REQ_MOVE_UP_ENTER,
 	REQ_MOVE_DOWN,
+	REQ_MOVE_DOWN_ENTER,
 	REQ_MOVE_PAGE_UP,
 	REQ_MOVE_PAGE_DOWN,
 	REQ_MOVE_FIRST_LINE,
@@ -108,19 +129,28 @@ enum request {
 	REQ_SCROLL_PAGE_DOWN,
 };
 
+struct ref {
+	char *name;		/* Ref name; tag or head names are shortened. */
+	char id[41];		/* Commit SHA1 ID */
+	unsigned int tag:1;	/* Is it a tag? */
+	unsigned int next:1;	/* For ref lists: are there more refs? */
+};
+
 struct commit {
 	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. */
+	struct ref **refs;	/* Repository references; tags & branch heads. */
 };
 
+
 /*
  * String helpers
  */
 
 static inline void
-string_ncopy(char *dst, char *src, int dstlen)
+string_ncopy(char *dst, const char *src, int dstlen)
 {
 	strncpy(dst, src, dstlen - 1);
 	dst[dstlen - 1] = 0;
@@ -131,6 +161,7 @@ string_ncopy(char *dst, char *src, int dstlen)
 #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
@@ -153,7 +184,7 @@ sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
 {
 	char c;
 
-#define BUFPUT(x) ( (bufsize < SIZEOF_CMD) && (buf[bufsize++] = (x)) )
+#define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
 
 	BUFPUT('\'');
 	while ((c = *src++)) {
@@ -177,17 +208,35 @@ sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
  * -------
  **/
 
-static int opt_line_number	= FALSE;
+static const char usage[] =
+VERSION " (" __DATE__ ")\n"
+"\n"
+"Usage: tig [options]\n"
+"   or: tig [options] [--] [git log options]\n"
+"   or: tig [options] log  [git log options]\n"
+"   or: tig [options] diff [git diff options]\n"
+"   or: tig [options] show [git show options]\n"
+"   or: tig [options] <    [git command output]\n"
+"\n"
+"Options:\n"
+"  -l                          Start up in log view\n"
+"  -d                          Start up in diff view\n"
+"  -n[I], --line-number[=I]    Show line numbers with given interval\n"
+"  -t[N], --tab-size[=N]       Set number of spaces for tab expansion\n"
+"  --                          Mark end of tig options\n"
+"  -v, --version               Show version and exit\n"
+"  -h, --help                  Show help message and exit\n";
+
+/* Option and state variables. */
+static bool opt_line_number	= FALSE;
 static int opt_num_interval	= NUMBER_INTERVAL;
+static int opt_tab_size		= TABSIZE;
 static enum request opt_request = REQ_VIEW_MAIN;
 static char opt_cmd[SIZEOF_CMD]	= "";
 static FILE *opt_pipe		= NULL;
 
-char ref_head[SIZEOF_REF]	= "HEAD";
-char ref_commit[SIZEOF_REF]	= "HEAD";
-
 /* Returns the index of log or diff command or -1 to exit. */
-static int
+static bool
 parse_options(int argc, char *argv[])
 {
 	int i;
@@ -196,22 +245,8 @@ 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;
-			break;
-		}
-
-		/**
 		 * -l::
-		 *	Start up in log view.
+		 *	Start up in log view using the internal log command.
 		 **/
 		if (!strcmp(opt, "-l")) {
 			opt_request = REQ_VIEW_LOG;
@@ -220,7 +255,7 @@ parse_options(int argc, char *argv[])
 
 		/**
 		 * -d::
-		 *	Start up in diff view.
+		 *	Start up in diff view using the internal diff command.
 		 **/
 		if (!strcmp(opt, "-d")) {
 			opt_request = REQ_VIEW_DIFF;
@@ -233,7 +268,7 @@ parse_options(int argc, char *argv[])
 		 *	Optionally, with interval different than each line.
 		 **/
 		if (!strncmp(opt, "-n", 2) ||
-		           !strncmp(opt, "--line-number", 13)) {
+		    !strncmp(opt, "--line-number", 13)) {
 			char *num = opt;
 
 			if (opt[1] == 'n') {
@@ -251,33 +286,85 @@ parse_options(int argc, char *argv[])
 		}
 
 		/**
+		 * -t[NSPACES], --tab-size[=NSPACES]::
+		 *	Set the number of spaces tabs should be expanded to.
+		 **/
+		if (!strncmp(opt, "-t", 2) ||
+		    !strncmp(opt, "--tab-size", 10)) {
+			char *num = opt;
+
+			if (opt[1] == 't') {
+				num = opt + 2;
+
+			} else if (opt[STRING_SIZE("--tab-size")] == '=') {
+				num = opt + STRING_SIZE("--tab-size=");
+			}
+
+			if (isdigit(*num))
+				opt_tab_size = MIN(atoi(num), TABSIZE);
+			continue;
+		}
+
+		/**
 		 * -v, --version::
 		 *	Show version and exit.
 		 **/
 		if (!strcmp(opt, "-v") ||
-			   !strcmp(opt, "--version")) {
+		    !strcmp(opt, "--version")) {
 			printf("tig version %s\n", VERSION);
-			return -1;
+			return FALSE;
+		}
+
+		/**
+		 * -h, --help::
+		 *	Show help message and exit.
+		 **/
+		if (!strcmp(opt, "-h") ||
+		    !strcmp(opt, "--help")) {
+			printf(usage);
+			return FALSE;
 		}
 
 		/**
 		 * \--::
-		 *	End of tig options. Useful when specifying commands
-		 *	for the main view. Example:
+		 *	End of tig(1) options. Useful when specifying command
+		 *	options for the main view. Example:
 		 *
-		 *		$ tig -- --pretty=raw tag-1.0..HEAD
+		 *		$ tig -- --since=1.month
 		 **/
 		if (!strcmp(opt, "--")) {
 			i++;
 			break;
 		}
 
-		 /* Make stuff like:
-		  *
-		 *	$ tig tag-1.0..HEAD
+		/**
+		 * log [git log options]::
+		 *	Open log view using the given git log options.
 		 *
-		 * work.
-		 */
+		 * diff [git diff options]::
+		 *	Open diff view using the given git diff options.
+		 *
+		 * show [git 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;
+		}
+
+		/**
+		 * [git log options]::
+		 *	tig(1) will stop the option parsing when the first
+		 *	command line parameter not starting with "-" is
+		 *	encountered. All options including this one will be
+		 *	passed to git log when loading the main view.
+		 *	This makes it possible to say:
+		 *
+		 *	$ tig tag-1.0..HEAD
+		 **/
 		if (opt[0] && opt[0] != '-')
 			break;
 
@@ -285,17 +372,48 @@ parse_options(int argc, char *argv[])
 	}
 
 	if (!isatty(STDIN_FILENO)) {
-		/* XXX: When pager mode has been requested, silently override
-		 * view startup options. */
+		/**
+		 * 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;
 
-		/* XXX: This is vulnerable to the user overriding options
-		 * required for the main view parser. */
+		/**
+		 * 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 they are passed to the shell.
+		 *
+		 * NOTE: If you specify options for the main view, you should
+		 * not use the `--pretty` option as this option will be set
+		 * automatically to the format expected by the main view.
+		 *
+		 * Example on how to open the log view and show both author and
+		 * committer information:
+		 *
+		 *	$ tig log --pretty=fuller
+		 *
+		 * See the <<refspec, "Specifying revisions">> section below
+		 * for an introduction to revision options supported by the git
+		 * commands. For details on specific git command options, refer
+		 * to the man page of the command in question.
+		 **/
+
 		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");
@@ -313,128 +431,7 @@ parse_options(int argc, char *argv[])
 
 	}
 
-	return i;
-}
-
-
-/**
- * KEYS
- * ----
- **/
-
-#define HELP "(d)iff, (l)og, (m)ain, (q)uit, (v)ersion, (h)elp"
-
-struct keymap {
-	int alias;
-	int request;
-};
-
-struct keymap keymap[] = {
-	/**
-	 * View switching
-	 * ~~~~~~~~~~~~~~
-	 * d::
-	 *	Switch to diff view.
-	 * l::
-	 *	Switch to log view.
-	 * m::
-	 *	Switch to main 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 },
-	{ '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 },
-	{ 'j',		REQ_MOVE_DOWN },
-	{ KEY_HOME,	REQ_MOVE_FIRST_LINE },
-	{ KEY_END,	REQ_MOVE_LAST_LINE },
-	{ KEY_NPAGE,	REQ_MOVE_PAGE_DOWN },
-	{ KEY_PPAGE,	REQ_MOVE_PAGE_UP },
-
-	/**
-	 * 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.
-	 **/
-	{ 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 },
-};
-
-static enum request
-get_request(int key)
-{
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(keymap); i++)
-		if (keymap[i].alias == key)
-			return keymap[i].request;
-
-	return (enum request) key;
+	return TRUE;
 }
 
 
@@ -447,26 +444,28 @@ get_request(int key)
  *   ---------     ---------------      ----------      ----------      ---------- */ \
 /* Diff markup */ \
 LINE(DIFF,	   "diff --git ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
-LINE(INDEX,	   "index ",		COLOR_BLUE,	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_OLDMODE, "old file mode ",	COLOR_YELLOW,	COLOR_DEFAULT,	0), \
+LINE(DIFF_NEWMODE, "new file 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_COMMIT,	   "Commit: ",		COLOR_GREEN,	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_IDENT, "author ",		COLOR_CYAN,	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), \
@@ -480,7 +479,9 @@ 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),
+LINE(MAIN_DELIM,   "",			COLOR_MAGENTA,	COLOR_DEFAULT,	0), \
+LINE(MAIN_TAG,     "",			COLOR_MAGENTA,	COLOR_DEFAULT,	A_BOLD), \
+LINE(MAIN_REF,     "",			COLOR_CYAN,	COLOR_DEFAULT,	A_BOLD),
 
 enum line_type {
 #define LINE(type, line, fg, bg, attr) \
@@ -490,7 +491,7 @@ enum line_type {
 };
 
 struct line_info {
-	char *line;		/* The start of line to match. */
+	const 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. */
 };
@@ -548,30 +549,152 @@ init_colors(void)
 }
 
 
-/*
- * Viewer
- */
+/**
+ * ENVIRONMENT VARIABLES
+ * ---------------------
+ * Several options related to the interface with git can be configured
+ * via environment options.
+ *
+ * Repository references
+ * ~~~~~~~~~~~~~~~~~~~~~
+ * Commits that are referenced by tags and branch heads will be marked
+ * by the reference name surrounded by '[' and ']':
+ *
+ *	2006-03-26 19:42 Petr Baudis         | [cogito-0.17.1] Cogito 0.17.1
+ *
+ * If you want to filter out certain directories under `.git/refs/`, say
+ * `tmp` you can do it by setting the following variable:
+ *
+ *	$ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
+ *
+ * Or set the variable permanently in your environment.
+ *
+ * TIG_LS_REMOTE::
+ *	Set command for retrieving all repository references. The command
+ *	should output data in the same format as git-ls-remote(1).
+ **/
+
+#define TIG_LS_REMOTE \
+	"git ls-remote . 2>/dev/null"
+
+/**
+ * [[view-commands]]
+ * View commands
+ * ~~~~~~~~~~~~~
+ * It is possible to alter which commands are used for the different views.
+ * If for example you prefer commits in the main view 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. If you prefer to have both
+ *	author and committer shown in the log view be sure to pass
+ *	`--pretty=fuller` to git log.
+ *
+ * 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"
+
+/* ... silently ignore that the following are also exported. */
+
+#define TIG_HELP_CMD \
+	"man tig 2>/dev/null"
+
+#define TIG_PAGER_CMD \
+	""
+
+
+/**
+ * The viewer
+ * ----------
+ * The display consists of a status window on the last line of the screen and
+ * one or more views. The default is to only show one view at the time but it
+ * is possible to split both the main and log view to also show the commit
+ * diff.
+ *
+ * If you are in the log view and press 'Enter' when the current line is a
+ * commit line, such as:
+ *
+ *	commit 4d55caff4cc89335192f3e566004b4ceef572521
+ *
+ * You will split the view so that the log view is displayed in the top window
+ * and the diff view in the bottom window. You can switch between the two
+ * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
+ **/
+
+struct view;
+
+/* The display array of active views and the index of the current view. */
+static struct view *display[2];
+static unsigned int current_view;
+
+#define foreach_view(view, i) \
+	for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
+
+
+/**
+ * Current head and commit ID
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * The viewer keeps track of both what head and commit ID you are currently
+ * viewing. The commit ID will follow the cursor line and change everytime time
+ * you highlight a different commit. Whenever you reopen the diff view it
+ * will be reloaded, if the commit ID changed.
+ *
+ * The head ID is used when opening the main and log view to indicate from
+ * what revision to show history.
+ **/
+
+static char ref_commit[SIZEOF_REF]	= "HEAD";
+static char ref_head[SIZEOF_REF]	= "HEAD";
+
 
 struct view {
 	const char *name;	/* View name */
-	const char *defcmd;	/* Default command line */
-	char *id;		/* Points to either of ref_{head,commit} */
+	const char *cmd_fmt;	/* Default command line format */
+	const char *cmd_env;	/* Command line set via environment */
+	const char *id;		/* Points to either of ref_{head,commit} */
 	size_t objsize;		/* Size of objects in the line index */
 
 	struct view_ops {
+		/* What type of content being displayed. Used in the
+		 * title bar. */
+		const char *type;
+		/* 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;
 
 	char cmd[SIZEOF_CMD];	/* Command buffer */
-	char ref[SIZEOF_REF];	/* Hovered Commit reference */
-	/* The view reference that describes the content of this view. */
-	char vref[SIZEOF_REF];
+	char ref[SIZEOF_REF];	/* Hovered commit reference */
+	char vid[SIZEOF_REF];	/* View ID. Set to id member when updating. */
 
-	WINDOW *win;
-	WINDOW *title;
-	int height, width;
+	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 */
@@ -579,7 +702,8 @@ 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;
@@ -589,36 +713,52 @@ struct view {
 static struct view_ops pager_ops;
 static struct view_ops main_ops;
 
-#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 VIEW_STR(name, cmd, env, ref, objsize, ops) \
+	{ name, cmd, #env, ref, objsize, ops }
 
-#define MAIN_CMD \
-	"git log --stat --pretty=raw %s"
+#define VIEW_(id, name, ops, ref, objsize) \
+	VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, objsize, ops)
 
-#define HELP_CMD \
-	"man tig 2> /dev/null"
+/**
+ * Views
+ * ~~~~~
+ * tig(1) presents various 'views' of a repository. Each view is based on output
+ * from an external command, most often 'git log', 'git diff', or 'git show'.
+ *
+ * The main view::
+ *	Is the default view, and it shows a one line summary of each commit
+ *	in the chosen list of revisions. The summary includes commit date,
+ *	author, and the first line of the log message. Additionally, any
+ *	repository references, such as tags, will be shown.
+ *
+ * The log view::
+ *	Presents a more rich view of the revision log showing the whole log
+ *	message and the diffstat.
+ *
+ * The diff view::
+ *	Shows either the diff of the current working tree, that is, what
+ *	has changed since the last commit, or the commit diff complete
+ *	with log message, diffstat and diff.
+ *
+ * The pager view::
+ *	Is used for displaying both input from stdin and output from git
+ *	commands entered in the internal prompt.
+ *
+ * The help view::
+ *	Displays the information from the tig(1) man page. For the help view
+ *	to work you need to have the tig(1) man page installed.
+ **/
 
 static struct view views[] = {
-	{ "main",  MAIN_CMD,  ref_head,   sizeof(struct commit), &main_ops },
-	{ "diff",  DIFF_CMD,  ref_commit, sizeof(char),		 &pager_ops },
-	{ "log",   LOG_CMD,   ref_head,   sizeof(char),		 &pager_ops },
-	{ "help",  HELP_CMD,  ref_head,   sizeof(char),		 &pager_ops },
-	{ "pager", "cat",     ref_head,   sizeof(char),		 &pager_ops },
+	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, "static",   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[2];
-static unsigned int current_view;
-
-#define foreach_view(view, i) \
-	for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
-
 
 static void
 redraw_view_from(struct view *view, int lineno)
@@ -641,14 +781,53 @@ redraw_view(struct view *view)
 	redraw_view_from(view, 0);
 }
 
+
+/**
+ * Title windows
+ * ~~~~~~~~~~~~~
+ * Each view has a title window which shows the name of the view, current
+ * commit ID if available, and where the view is positioned:
+ *
+ *	[main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
+ *
+ * By default, the title of the current view is highlighted using bold font.
+ **/
+
 static void
-resize_display(void)
+update_view_title(struct view *view)
 {
-	int offset, i;
-	struct view *base = display[0];
-	struct view *view = display[1] ? display[1] : display[0];
-
-	/* Setup window dimensions */
+	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);
+
+	if (*view->ref)
+		wprintw(view->title, "[%s] %s", view->name, view->ref);
+	else
+		wprintw(view->title, "[%s]", view->name);
+
+	if (view->lines) {
+		wprintw(view->title, " - %s %d of %d (%d%%)",
+			view->ops->type,
+			view->lineno + 1,
+			view->lines,
+			(view->lineno + 1) * 100 / view->lines);
+	}
+
+	wrefresh(view->title);
+}
+
+static void
+resize_display(void)
+{
+	int offset, i;
+	struct view *base = display[0];
+	struct view *view = display[1] ? display[1] : display[0];
+
+	/* Setup window dimensions */
 
 	getmaxyx(stdscr, base->height, base->width);
 
@@ -671,8 +850,11 @@ resize_display(void)
 	offset = 0;
 
 	foreach_view (view, i) {
+		/* Keep the height of all view->win windows one larger than is
+		 * required so that the cursor can wrap-around on the last line
+		 * without scrolling the window. */
 		if (!view->win) {
-			view->win = newwin(view->height, 0, offset, 0);
+			view->win = newwin(view->height + 1, 0, offset, 0);
 			if (!view->win)
 				die("Failed to create %s view", view->name);
 
@@ -683,7 +865,7 @@ resize_display(void)
 				die("Failed to create title window");
 
 		} else {
-			wresize(view->win, view->height, view->width);
+			wresize(view->win, view->height + 1, view->width);
 			mvwin(view->win,   offset, 0);
 			mvwin(view->title, offset + view->height, 0);
 			wrefresh(view->win);
@@ -694,36 +876,18 @@ resize_display(void)
 }
 
 static void
-update_view_title(struct view *view)
+redraw_display(void)
 {
-	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";
+	struct view *view;
+	int i;
 
-		wprintw(view->title, " - %s %d of %d (%d%%)",
-			type,
-			view->lineno + 1,
-			view->lines,
-			(view->lineno + 1) * 100 / view->lines);
+	foreach_view (view, i) {
+		redraw_view(view);
+		update_view_title(view);
 	}
-
-	wrefresh(view->title);
 }
 
+
 /*
  * Navigation
  */
@@ -760,6 +924,12 @@ do_scroll_view(struct view *view, int lines)
 		view->ops->draw(view, 0);
 
 	} else if (view->lineno >= view->offset + view->height) {
+		if (view->lineno == view->offset + view->height) {
+			/* Clear the hidden line so it doesn't show if the view
+			 * is scrolled up. */
+			wmove(view->win, view->height, 0);
+			wclrtoeol(view->win);
+		}
 		view->lineno = view->offset + view->height - 1;
 		view->ops->draw(view, view->lineno - view->offset);
 	}
@@ -785,7 +955,7 @@ scroll_view(struct view *view, enum request request)
 			lines = view->lines - view->offset;
 
 		if (lines == 0 || view->offset + view->height >= view->lines) {
-			report("Already on last line");
+			report("Cannot scroll beyond the last line");
 			return;
 		}
 		break;
@@ -797,7 +967,7 @@ scroll_view(struct view *view, enum request request)
 			lines = view->offset;
 
 		if (lines == 0) {
-			report("Already on first line");
+			report("Cannot scroll beyond the first line");
 			return;
 		}
 
@@ -837,10 +1007,12 @@ move_view(struct view *view, enum request request)
 		break;
 
 	case REQ_MOVE_UP:
+	case REQ_MOVE_UP_ENTER:
 		steps = -1;
 		break;
 
 	case REQ_MOVE_DOWN:
+	case REQ_MOVE_DOWN_ENTER:
 		steps = 1;
 		break;
 
@@ -849,11 +1021,11 @@ move_view(struct view *view, enum request request)
 	}
 
 	if (steps <= 0 && view->lineno == 0) {
-		report("Already on first line");
+		report("Cannot move beyond the first line");
 		return;
 
 	} else if (steps >= 0 && view->lineno + 1 >= view->lines) {
-		report("Already on last line");
+		report("Cannot move beyond the last line");
 		return;
 	}
 
@@ -905,14 +1077,19 @@ move_view(struct view *view, enum request request)
 static bool
 begin_update(struct view *view)
 {
-	char *id = view->id;
+	const char *id = view->id;
 
 	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 {
-		if (snprintf(view->cmd, sizeof(view->cmd), view->defcmd,
-			     id, id, id) >= sizeof(view->cmd))
+		const 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;
 	}
 
@@ -932,6 +1109,7 @@ begin_update(struct view *view)
 	view->offset = 0;
 	view->lines  = 0;
 	view->lineno = 0;
+	string_copy(view->vid, id);
 
 	if (view->line) {
 		int i;
@@ -955,7 +1133,10 @@ end_update(struct view *view)
 	if (!view->pipe)
 		return;
 	set_nonblocking_input(FALSE);
-	pclose(view->pipe);
+	if (view->pipe == stdin)
+		fclose(view->pipe);
+	else
+		pclose(view->pipe);
 	view->pipe = NULL;
 }
 
@@ -968,7 +1149,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)
@@ -985,9 +1166,8 @@ update_view(struct view *view)
 	view->line = tmp;
 
 	while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
-		int linelen;
+		int linelen = strlen(line);
 
-		linelen = strlen(line);
 		if (linelen)
 			line[linelen - 1] = 0;
 
@@ -998,8 +1178,19 @@ update_view(struct view *view)
 			break;
 	}
 
-	/* CPU hogilicious! */
-	update_view_title(view);
+	{
+		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
@@ -1012,6 +1203,10 @@ 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", strerror(errno));
 		goto end;
@@ -1020,7 +1215,16 @@ update_view(struct view *view)
 		time_t secs = time(NULL) - view->start_time;
 
 		if (view == VIEW(REQ_VIEW_HELP)) {
-			report("%s", HELP);
+			const char *msg = TIG_HELP;
+
+			if (view->lines == 0) {
+				/* Slightly ugly, but abusing view->ref keeps
+				 * the error message. */
+				string_copy(view->ref, "No help available");
+				msg = "The tig(1) manpage is not installed";
+			}
+
+			report("%s", msg);
 			goto end;
 		}
 
@@ -1039,10 +1243,19 @@ end:
 	return FALSE;
 }
 
+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
-switch_view(struct view *prev, enum request request,
-	    bool backgrounded, bool split)
+open_view(struct view *prev, enum request request, enum open_flags flags)
 {
+	bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
+	bool split = !!(flags & OPEN_SPLIT);
+	bool reload = !!(flags & OPEN_RELOAD);
 	struct view *view = VIEW(request);
 	struct view *displayed;
 	int nviews;
@@ -1051,21 +1264,21 @@ switch_view(struct view *prev, enum request request,
 	foreach_view (displayed, nviews) {
 		if (prev != view &&
 		    view == displayed &&
-		    !strcmp(view->id, prev->id)) {
+		    !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);
+			report("");
 			return;
 		}
 	}
 
-	if (view == prev && nviews == 1) {
+	if (view == prev && nviews == 1 && !reload) {
 		report("Already in %s view", view->name);
 		return;
 	}
 
-	if (strcmp(view->vref, view->id) &&
+	if ((reload || strcmp(view->vid, view->id)) &&
 	    !begin_update(view)) {
 		report("Failed to load %s view", view->name);
 		return;
@@ -1084,9 +1297,9 @@ switch_view(struct view *prev, enum request request,
 
 	resize_display();
 
-	if (split && prev->lineno - prev->offset > prev->height) {
+	if (split && prev->lineno - prev->offset >= prev->height) {
 		/* Take the title line into account. */
-		int lines = prev->lineno - prev->height + 1;
+		int lines = prev->lineno - prev->offset - prev->height + 1;
 
 		/* Scroll the view that was split if the current line is
 		 * outside the new limited view. */
@@ -1095,7 +1308,8 @@ switch_view(struct view *prev, enum request request,
 
 	if (prev && view != prev) {
 		/* "Blur" the previous view. */
-		update_view_title(prev);
+		if (!backgrounded)
+			update_view_title(prev);
 
 		/* Continue loading split views in the background. */
 		if (!split)
@@ -1109,8 +1323,16 @@ switch_view(struct view *prev, enum request request,
 		report("Loading...");
 	} else {
 		redraw_view(view);
-		report("");
+		if (view == VIEW(REQ_VIEW_HELP))
+			report("%s", TIG_HELP);
+		else
+			report("");
 	}
+
+	/* If the view is backgrounded the above calls to report()
+	 * won't redraw the view title. */
+	if (backgrounded)
+		update_view_title(view);
 }
 
 
@@ -1145,9 +1367,14 @@ view_driver(struct view *view, enum request request)
 	case REQ_VIEW_LOG:
 	case REQ_VIEW_HELP:
 	case REQ_VIEW_PAGER:
-		switch_view(view, request, FALSE, FALSE);
+		open_view(view, request, OPEN_DEFAULT);
 		break;
 
+	case REQ_MOVE_UP_ENTER:
+	case REQ_MOVE_DOWN_ENTER:
+		move_view(view, request);
+		/* Fall-through */
+
 	case REQ_ENTER:
 		if (!view->lines) {
 			report("Nothing to enter");
@@ -1168,44 +1395,59 @@ view_driver(struct view *view, enum request request)
 		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);
+		report("");
 		break;
 	}
 	case REQ_TOGGLE_LINE_NUMBERS:
 		opt_line_number = !opt_line_number;
-		redraw_view(view);
+		redraw_display();
 		break;
 
 	case REQ_PROMPT:
-		switch_view(view, opt_request, FALSE, FALSE);
+		/* Always reload^Wrerun commands from the prompt. */
+		open_view(view, opt_request, OPEN_RELOAD);
 		break;
 
 	case REQ_STOP_LOADING:
 		foreach_view (view, i) {
 			if (view->pipe)
-				report("Stopped loaded of %s view", view->name),
+				report("Stopped loaded the %s view", view->name),
 			end_update(view);
 		}
 		break;
 
 	case REQ_SHOW_VERSION:
-		report("Version: %s", VERSION);
+		report("%s (built %s)", VERSION, __DATE__);
 		return TRUE;
 
+	case REQ_SCREEN_RESIZE:
+		resize_display();
+		/* Fall-through */
 	case REQ_SCREEN_REDRAW:
-		redraw_view(view);
+		redraw_display();
 		break;
 
 	case REQ_SCREEN_UPDATE:
 		doupdate();
 		return TRUE;
 
+	case REQ_VIEW_CLOSE:
+		if (display[1]) {
+			view = display[(current_view + 1) % ARRAY_SIZE(display)];
+			memset(display, 0, sizeof(display));
+			current_view = 0;
+			display[current_view] = view;
+			resize_display();
+			redraw_display();
+			break;
+		}
+		/* Fall-through */
 	case REQ_QUIT:
 		return FALSE;
 
 	default:
 		/* An unknown key will show most commonly used commands. */
-		report("%s", HELP);
+		report("Unknown key, press 'h' for help");
 		return TRUE;
 	}
 
@@ -1231,70 +1473,71 @@ pager_draw(struct view *view, unsigned int lineno)
 	line = view->line[view->offset + lineno];
 	type = get_line_type(line);
 
+	wmove(view->win, lineno, 0);
+
 	if (view->offset + lineno == view->lineno) {
-		switch (type) {
-		case LINE_COMMIT:
+		if (type == LINE_COMMIT) {
 			string_copy(view->ref, line + 7);
 			string_copy(ref_commit, view->ref);
-			break;
-		case LINE_PP_COMMIT:
-			string_copy(view->ref, line + 8);
-			string_copy(ref_commit, view->ref);
-		default:
-			break;
 		}
+
 		type = LINE_CURSOR;
+		wchgat(view->win, -1, 0, type, NULL);
 	}
 
 	attr = get_line_attr(type);
 	wattrset(view->win, attr);
 
 	linelen = strlen(line);
-	linelen = MIN(linelen, view->width);
 
-	if (opt_line_number) {
-		unsigned int real_lineno = view->offset + lineno + 1;
-		int col = 0;
+	if (opt_line_number || opt_tab_size < TABSIZE) {
+		static char spaces[] = "                    ";
+		int col_offset = 0, 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, "    : ");
+		if (opt_line_number) {
+			unsigned long real_lineno = view->offset + lineno + 1;
+
+			if (real_lineno == 1 ||
+			    (real_lineno % opt_num_interval) == 0) {
+				wprintw(view->win, "%.*d", view->digits, real_lineno);
+
+			} else {
+				waddnstr(view->win, spaces,
+					 MIN(view->digits, STRING_SIZE(spaces)));
+			}
+			waddstr(view->win, ": ");
+			col_offset = view->digits + 2;
+		}
+
+		while (line && col_offset + col < view->width) {
+			int cols_max = view->width - col_offset - col;
+			char *text = line;
+			int cols;
 
-		while (line) {
 			if (*line == '\t') {
-				waddnstr(view->win, "        ", 8 - (col % 8));
-				col += 8 - (col % 8);
+				assert(sizeof(spaces) > TABSIZE);
 				line++;
+				text = spaces;
+				cols = opt_tab_size - (col % opt_tab_size);
 
 			} else {
-				char *tab = strchr(line, '\t');
-
-				if (tab)
-					waddnstr(view->win, line, tab - line);
-				else
-					waddstr(view->win, line);
-				col += tab - line;
-				line = tab;
+				line = strchr(line, '\t');
+				cols = line ? line - text : strlen(text);
 			}
+
+			waddnstr(view->win, text, MIN(cols, cols_max));
+			col += cols;
 		}
-		waddstr(view->win, line);
 
 	} else {
-#if 0
-		/* NOTE: Code for only highlighting the text on the cursor line.
-		 * Kept since I've not yet decided whether to highlight the
-		 * entire line or not. --fonseca */
-		/* No empty lines makes cursor drawing and clearing implicit. */
-		if (!*line)
-			line = " ", linelen = 1;
-#endif
-		mvwaddnstr(view->win, lineno, 0, line, linelen);
-	}
+		int col = 0, pos = 0;
 
-	/* Paint the rest of the line if it's the cursor line. */
-	if (type == LINE_CURSOR)
-		wchgat(view->win, -1, 0, type, NULL);
+		for (; pos < linelen && col < view->width; pos++, col++)
+			if (line[pos] == '\t')
+				col += TABSIZE - (col % TABSIZE) - 1;
+
+		waddnstr(view->win, line, pos);
+	}
 
 	return TRUE;
 }
@@ -1302,6 +1545,13 @@ pager_draw(struct view *view, unsigned int lineno)
 static bool
 pager_read(struct view *view, char *line)
 {
+	/* Compress empty lines in the help view. */
+	if (view == VIEW(REQ_VIEW_HELP) &&
+	    !*line &&
+	    view->lines &&
+	    !*((char *) view->line[view->lines - 1]))
+		return TRUE;
+
 	view->line[view->lines] = strdup(line);
 	if (!view->line[view->lines])
 		return FALSE;
@@ -1315,28 +1565,41 @@ pager_enter(struct view *view)
 {
 	char *line = view->line[view->lineno];
 
+	if (view == VIEW(REQ_VIEW_DIFF)) {
+		scroll_view(view, REQ_SCROLL_LINE_DOWN);
+		return TRUE;
+	}
+
 	if (get_line_type(line) == LINE_COMMIT) {
-		switch_view(view, REQ_VIEW_DIFF, FALSE, FALSE);
+		if (view == VIEW(REQ_VIEW_LOG))
+			open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT | OPEN_BACKGROUNDED);
+		else
+			open_view(view, REQ_VIEW_DIFF, OPEN_DEFAULT);
 	}
 
 	return TRUE;
 }
 
-
 static struct view_ops pager_ops = {
+	"line",
 	pager_draw,
 	pager_read,
 	pager_enter,
 };
 
+
+static struct ref **get_refs(char *id);
+
 static bool
 main_draw(struct view *view, unsigned int lineno)
 {
 	char buf[DATE_COLS + 1];
 	struct commit *commit;
 	enum line_type type;
-	int cols = 0;
+	int col = 0;
 	size_t timelen;
+	size_t authorlen;
+	int trimmed;
 
 	if (view->offset + lineno >= view->lines)
 		return FALSE;
@@ -1345,38 +1608,80 @@ main_draw(struct view *view, unsigned int lineno)
 	if (!*commit->author)
 		return FALSE;
 
+	wmove(view->win, lineno, col);
+
 	if (view->offset + lineno == view->lineno) {
 		string_copy(view->ref, commit->id);
+		string_copy(ref_commit, view->ref);
 		type = LINE_CURSOR;
+		wattrset(view->win, get_line_attr(type));
+		wchgat(view->win, -1, 0, type, NULL);
+
 	} else {
 		type = LINE_MAIN_COMMIT;
+		wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
 	}
 
-	wmove(view->win, lineno, cols);
-	wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
-
 	timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
 	waddnstr(view->win, buf, timelen);
 	waddstr(view->win, " ");
 
-	cols += DATE_COLS;
-	wmove(view->win, lineno, cols);
-	wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
+	col += DATE_COLS;
+	wmove(view->win, lineno, col);
+	if (type != LINE_CURSOR)
+		wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
+
+	/* FIXME: Make this optional, and add i18n.commitEncoding support. */
+	authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
 
-	if (strlen(commit->author) > 19) {
-		waddnstr(view->win, commit->author, 18);
-		wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
+	if (trimmed) {
+		waddnstr(view->win, commit->author, authorlen);
+		if (type != LINE_CURSOR)
+			wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
 		waddch(view->win, '~');
 	} else {
 		waddstr(view->win, commit->author);
 	}
 
-	cols += 20;
-	wattrset(view->win, A_NORMAL);
-	mvwaddch(view->win, lineno, cols, ACS_LTEE);
-	wattrset(view->win, get_line_attr(type));
-	mvwaddstr(view->win, lineno, cols + 2, commit->title);
-	wattrset(view->win, A_NORMAL);
+	col += AUTHOR_COLS;
+	if (type != LINE_CURSOR)
+		wattrset(view->win, A_NORMAL);
+
+	mvwaddch(view->win, lineno, col, ACS_LTEE);
+	wmove(view->win, lineno, col + 2);
+	col += 2;
+
+	if (commit->refs) {
+		size_t i = 0;
+
+		do {
+			if (type == LINE_CURSOR)
+				;
+			else if (commit->refs[i]->tag)
+				wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
+			else
+				wattrset(view->win, get_line_attr(LINE_MAIN_REF));
+			waddstr(view->win, "[");
+			waddstr(view->win, commit->refs[i]->name);
+			waddstr(view->win, "]");
+			if (type != LINE_CURSOR)
+				wattrset(view->win, A_NORMAL);
+			waddstr(view->win, " ");
+			col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
+		} while (commit->refs[i++]->next);
+	}
+
+	if (type != LINE_CURSOR)
+		wattrset(view->win, get_line_attr(type));
+
+	{
+		int titlelen = strlen(commit->title);
+
+		if (col + titlelen > view->width)
+			titlelen = view->width - col;
+
+		waddnstr(view->win, commit->title, titlelen);
+	}
 
 	return TRUE;
 }
@@ -1398,9 +1703,10 @@ main_read(struct view *view, char *line)
 
 		view->line[view->lines++] = commit;
 		string_copy(commit->id, line);
+		commit->refs = get_refs(commit->id);
 		break;
 
-	case LINE_AUTHOR_IDENT:
+	case LINE_AUTHOR:
 	{
 		char *ident = line + STRING_SIZE("author ");
 		char *end = strchr(ident, '<');
@@ -1456,8 +1762,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);
@@ -1469,20 +1777,332 @@ main_read(struct view *view, char *line)
 static bool
 main_enter(struct view *view)
 {
-	switch_view(view, REQ_VIEW_DIFF, TRUE, TRUE);
+	open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
 	return TRUE;
 }
 
 static struct view_ops main_ops = {
+	"commit",
 	main_draw,
 	main_read,
 	main_enter,
 };
 
+
+/**
+ * KEYS
+ * ----
+ * Below the default key bindings are shown.
+ **/
+
+struct keymap {
+	int alias;
+	int request;
+};
+
+static struct keymap keymap[] = {
+	/**
+	 * View switching
+	 * ~~~~~~~~~~~~~~
+	 * m::
+	 *	Switch to main view.
+	 * d::
+	 *	Switch to diff view.
+	 * l::
+	 *	Switch to log view.
+	 * p::
+	 *	Switch to pager view.
+	 * h::
+	 *	Show man page.
+	 * q::
+	 *	Close view if multiple views are open, else quit.
+	 * Enter::
+	 *	This key is "context sensitive" depending on what view you are
+	 *	currently in. When in log view on a commit line or in the main
+	 *	view, split the view and show the commit diff. In the diff view
+	 *	pressing Enter will simply scroll the view one line down.
+	 * 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 },
+
+	{ 'q',		REQ_VIEW_CLOSE },
+	{ KEY_TAB,	REQ_VIEW_NEXT },
+	{ KEY_RETURN,	REQ_ENTER },
+
+	/**
+	 * Cursor navigation
+	 * ~~~~~~~~~~~~~~~~~
+	 * Up::
+	 *	Move cursor one line up.
+	 * Down::
+	 *	Move cursor one line down.
+	 * k::
+	 *	Move cursor one line up and enter. When used in the main view
+	 *	this will always show the diff of the current commit in the
+	 *	split diff view.
+	 * j::
+	 *	Move cursor one line down and enter.
+	 * PgUp::
+	 * b::
+	 * -::
+	 *	Move cursor one page up.
+	 * PgDown::
+	 * Space::
+	 *	Move cursor one page down.
+	 * Home::
+	 *	Jump to first line.
+	 * End::
+	 *	Jump to last line.
+	 **/
+	{ KEY_UP,	REQ_MOVE_UP },
+	{ KEY_DOWN,	REQ_MOVE_DOWN },
+	{ 'k',		REQ_MOVE_UP_ENTER },
+	{ 'j',		REQ_MOVE_DOWN_ENTER },
+	{ KEY_HOME,	REQ_MOVE_FIRST_LINE },
+	{ KEY_END,	REQ_MOVE_LAST_LINE },
+	{ KEY_NPAGE,	REQ_MOVE_PAGE_DOWN },
+	{ ' ',		REQ_MOVE_PAGE_DOWN },
+	{ KEY_PPAGE,	REQ_MOVE_PAGE_UP },
+	{ 'b',		REQ_MOVE_PAGE_UP },
+	{ '-',		REQ_MOVE_PAGE_UP },
+
+	/**
+	 * 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::
+	 *	Quit.
+	 * r::
+	 *	Redraw screen.
+	 * z::
+	 *	Stop all background loading. This can be useful if you use
+	 *	tig(1) in a repository with a long history without limiting
+	 *	the revision log.
+	 * v::
+	 *	Show version.
+	 * n::
+	 *	Toggle line numbers on/off.
+	 * ':'::
+	 *	Open prompt. This allows you to specify what git command
+	 *	to run. Example:
+	 *
+	 *	:log -p
+	 **/
+	{ '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 enum request
+get_request(int key)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(keymap); i++)
+		if (keymap[i].alias == key)
+			return keymap[i].request;
+
+	return (enum request) key;
+}
+
+
+/*
+ * Unicode / UTF-8 handling
+ *
+ * NOTE: Much of the following code for dealing with unicode is derived from
+ * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
+ * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
+ */
+
+/* I've (over)annotated a lot of code snippets because I am not entirely
+ * confident that the approach taken by this small UTF-8 interface is correct.
+ * --jonas */
+
+static inline int
+unicode_width(unsigned long c)
+{
+	if (c >= 0x1100 &&
+	   (c <= 0x115f				/* Hangul Jamo */
+	    || c == 0x2329
+	    || c == 0x232a
+	    || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
+	    					/* CJK ... Yi */
+	    || (c >= 0xac00  && c <= 0xd7a3)	/* Hangul Syllables */
+	    || (c >= 0xf900  && c <= 0xfaff)	/* CJK Compatibility Ideographs */
+	    || (c >= 0xfe30  && c <= 0xfe6f)	/* CJK Compatibility Forms */
+	    || (c >= 0xff00  && c <= 0xff60)	/* Fullwidth Forms */
+	    || (c >= 0xffe0  && c <= 0xffe6)
+	    || (c >= 0x20000 && c <= 0x2fffd)
+	    || (c >= 0x30000 && c <= 0x3fffd)))
+		return 2;
+
+	return 1;
+}
+
+/* Number of bytes used for encoding a UTF-8 character indexed by first byte.
+ * Illegal bytes are set one. */
+static const unsigned char utf8_bytes[256] = {
+	1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+	1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+	1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+	1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+	1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+	1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+	2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,
+	3,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, 4,4,4,4,4,4,4,4, 5,5,5,5,6,6,1,1,
+};
+
+/* Decode UTF-8 multi-byte representation into a unicode character. */
+static inline unsigned long
+utf8_to_unicode(const char *string, size_t length)
+{
+	unsigned long unicode;
+
+	switch (length) {
+	case 1:
+		unicode  =   string[0];
+		break;
+	case 2:
+		unicode  =  (string[0] & 0x1f) << 6;
+		unicode +=  (string[1] & 0x3f);
+		break;
+	case 3:
+		unicode  =  (string[0] & 0x0f) << 12;
+		unicode += ((string[1] & 0x3f) << 6);
+		unicode +=  (string[2] & 0x3f);
+		break;
+	case 4:
+		unicode  =  (string[0] & 0x0f) << 18;
+		unicode += ((string[1] & 0x3f) << 12);
+		unicode += ((string[2] & 0x3f) << 6);
+		unicode +=  (string[3] & 0x3f);
+		break;
+	case 5:
+		unicode  =  (string[0] & 0x0f) << 24;
+		unicode += ((string[1] & 0x3f) << 18);
+		unicode += ((string[2] & 0x3f) << 12);
+		unicode += ((string[3] & 0x3f) << 6);
+		unicode +=  (string[4] & 0x3f);
+		break;
+	case 6:	
+		unicode  =  (string[0] & 0x01) << 30;
+		unicode += ((string[1] & 0x3f) << 24);
+		unicode += ((string[2] & 0x3f) << 18);
+		unicode += ((string[3] & 0x3f) << 12);
+		unicode += ((string[4] & 0x3f) << 6);
+		unicode +=  (string[5] & 0x3f);
+		break;
+	default:
+		die("Invalid unicode length");
+	}
+
+	/* Invalid characters could return the special 0xfffd value but NUL
+	 * should be just as good. */
+	return unicode > 0xffff ? 0 : unicode;
+}
+
+/* Calculates how much of string can be shown within the given maximum width
+ * and sets trimmed parameter to non-zero value if all of string could not be
+ * shown.
+ *
+ * Additionally, adds to coloffset how many many columns to move to align with
+ * the expected position. Takes into account how multi-byte and double-width
+ * characters will effect the cursor position.
+ *
+ * Returns the number of bytes to output from string to satisfy max_width. */
+static size_t
+utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
+{
+	const char *start = string;
+	const char *end = strchr(string, '\0');
+	size_t mbwidth = 0;
+	size_t width = 0;
+
+	*trimmed = 0;
+
+	while (string < end) {
+		int c = *(unsigned char *) string;
+		unsigned char bytes = utf8_bytes[c];
+		size_t ucwidth;
+		unsigned long unicode;
+
+		if (string + bytes > end)
+			break;
+
+		/* Change representation to figure out whether
+		 * it is a single- or double-width character. */
+
+		unicode = utf8_to_unicode(string, bytes);
+		/* FIXME: Graceful handling of invalid unicode character. */
+		if (!unicode)
+			break;
+
+		ucwidth = unicode_width(unicode);
+		width  += ucwidth;
+		if (width > max_width) {
+			*trimmed = 1;
+			break;
+		}
+
+		/* The column offset collects the differences between the
+		 * number of bytes encoding a character and the number of
+		 * columns will be used for rendering said character.
+		 *
+		 * So if some character A is encoded in 2 bytes, but will be
+		 * represented on the screen using only 1 byte this will and up
+		 * adding 1 to the multi-byte column offset.
+		 *
+		 * Assumes that no double-width character can be encoding in
+		 * less than two bytes. */
+		if (bytes > ucwidth)
+			mbwidth += bytes - ucwidth;
+
+		string  += bytes;
+	}
+
+	*coloffset += mbwidth;
+
+	return string - start;
+}
+
+
 /*
  * Status management
  */
 
+/* Whether or not the curses interface has been initialized. */
+bool cursed = FALSE;
+
 /* The status window is used for polling keystrokes. */
 static WINDOW *status_win;
 
@@ -1490,37 +2110,48 @@ static WINDOW *status_win;
 static void
 report(const char *msg, ...)
 {
-	va_list args;
+	static bool empty = TRUE;
+	struct view *view = display[current_view];
+
+	if (!empty || *msg) {
+		va_list args;
 
-	va_start(args, msg);
+		va_start(args, msg);
 
-	/* Update the title window first, so the cursor ends up in the status
-	 * window. */
-	update_view_title(display[current_view]);
+		werase(status_win);
+		wmove(status_win, 0, 0);
+		if (*msg) {
+			vwprintw(status_win, msg, args);
+			empty = FALSE;
+		} else {
+			empty = TRUE;
+		}
+		wrefresh(status_win);
 
-	werase(status_win);
-	wmove(status_win, 0, 0);
-	vwprintw(status_win, msg, args);
-	wrefresh(status_win);
+		va_end(args);
+	}
 
-	va_end(args);
+	update_view_title(view);
+
+	/* Move the cursor to the right-most column of the cursor line.
+	 *
+	 * XXX: This could turn out to be a bit expensive, but it ensures that
+	 * the cursor does not jump around. */
+	if (view->lines) {
+		wmove(view->win, view->lineno - view->offset, view->width - 1);
+		wrefresh(view->win);
+	}
 }
 
 /* Controls when nodelay should be in effect when polling user input. */
 static void
-set_nonblocking_input(int loading)
+set_nonblocking_input(bool loading)
 {
-	/* The number of loading views. */
-	static unsigned int nloading;
-
-	if (loading == TRUE) {
-		if (nloading++ == 0)
-			nodelay(status_win, TRUE);
-		return;
-	}
+	static unsigned int loading_views;
 
-	if (nloading-- == 1)
-		nodelay(status_win, FALSE);
+	if ((loading == FALSE && loading_views-- == 1) ||
+	    (loading == TRUE  && loading_views++ == 0))
+		nodelay(status_win, loading);
 }
 
 static void
@@ -1530,14 +2161,17 @@ init_display(void)
 
 	/* Initialize the curses library */
 	if (isatty(STDIN_FILENO)) {
-		initscr();
+		cursed = !!initscr();
 	} else {
 		/* Leave stdin and stdout alone when acting as a pager. */
 		FILE *io = fopen("/dev/tty", "r+");
 
-		newterm(NULL, io, io);
+		cursed = !!newterm(NULL, io, io);
 	}
 
+	if (!cursed)
+		die("Failed to initialize curses");
+
 	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 */
@@ -1556,23 +2190,141 @@ init_display(void)
 	wbkgdset(status_win, get_line_attr(LINE_STATUS));
 }
 
+
 /*
- * Main
+ * Repository references
  */
 
-static void
-quit(int sig)
+static struct ref *refs;
+static size_t refs_size;
+
+static struct ref **
+get_refs(char *id)
 {
-	if (status_win)
-		delwin(status_win);
-	endwin();
+	struct ref **id_refs = NULL;
+	size_t id_refs_size = 0;
+	size_t i;
+
+	for (i = 0; i < refs_size; i++) {
+		struct ref **tmp;
+
+		if (strcmp(id, refs[i].id))
+			continue;
+
+		tmp = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
+		if (!tmp) {
+			if (id_refs)
+				free(id_refs);
+			return NULL;
+		}
+
+		id_refs = tmp;
+		if (id_refs_size > 0)
+			id_refs[id_refs_size - 1]->next = 1;
+		id_refs[id_refs_size] = &refs[i];
+
+		/* XXX: The properties of the commit chains ensures that we can
+		 * safely modify the shared ref. The repo references will
+		 * always be similar for the same id. */
+		id_refs[id_refs_size]->next = 0;
+		id_refs_size++;
+	}
+
+	return id_refs;
+}
+
+static int
+load_refs(void)
+{
+	const char *cmd_env = getenv("TIG_LS_REMOTE");
+	const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
+	FILE *pipe = popen(cmd, "r");
+	char buffer[BUFSIZ];
+	char *line;
 
-	/* FIXME: Shutdown gracefully. */
+	if (!pipe)
+		return ERR;
+
+	while ((line = fgets(buffer, sizeof(buffer), pipe))) {
+		char *name = strchr(line, '\t');
+		struct ref *ref;
+		int namelen;
+		bool tag = FALSE;
+		bool tag_commit = FALSE;
+
+		if (!name)
+			continue;
+
+		*name++ = 0;
+		namelen = strlen(name) - 1;
+
+		/* Commits referenced by tags has "^{}" appended. */
+		if (name[namelen - 1] == '}') {
+			while (namelen > 0 && name[namelen] != '^')
+				namelen--;
+			if (namelen > 0)
+				tag_commit = TRUE;
+		}
+		name[namelen] = 0;
+
+		if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
+			if (!tag_commit)
+				continue;
+			name += STRING_SIZE("refs/tags/");
+			tag = TRUE;
+
+		} else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
+			name += STRING_SIZE("refs/heads/");
+
+		} else if (!strcmp(name, "HEAD")) {
+			continue;
+		}
+
+		refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
+		if (!refs)
+			return ERR;
+
+		ref = &refs[refs_size++];
+		ref->tag = tag;
+		ref->name = strdup(name);
+		if (!ref->name)
+			return ERR;
+
+		string_copy(ref->id, line);
+	}
+
+	if (ferror(pipe))
+		return ERR;
+
+	pclose(pipe);
+
+	if (refs_size == 0)
+		die("Not a git repository");
+
+	return OK;
+}
+
+/*
+ * Main
+ */
 
+#if __GNUC__ >= 3
+#define __NORETURN __attribute__((__noreturn__))
+#else
+#define __NORETURN
+#endif
+
+static void __NORETURN
+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, ...)
+static void __NORETURN
+die(const char *err, ...)
 {
 	va_list args;
 
@@ -1590,21 +2342,26 @@ static void die(const char *err, ...)
 int
 main(int argc, char *argv[])
 {
+	struct view *view;
 	enum request request;
-	int git_arg;
+	size_t i;
 
 	signal(SIGINT, quit);
 
-	git_arg = parse_options(argc, argv);
-	if (git_arg < 0)
+	if (!parse_options(argc, argv))
 		return 0;
 
+	if (load_refs() == ERR)
+		die("Failed to load refs.");
+
+	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;
 
@@ -1615,16 +2372,42 @@ main(int argc, char *argv[])
 		key = wgetch(status_win);
 		request = get_request(key);
 
-		if (request == REQ_PROMPT) {
+		/* Some low-level request handling. This keeps access to
+		 * 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, sizeof(opt_cmd)) == OK)
-				die("%s", opt_cmd);
+
+			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;
+
+		case REQ_SCREEN_RESIZE:
+		{
+			int height, width;
+
+			getmaxyx(stdscr, height, width);
+
+			/* 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;
 		}
 	}
 
@@ -1634,19 +2417,115 @@ main(int argc, char *argv[])
 }
 
 /**
- * TODO
+ * [[refspec]]
+ * Revision specification
+ * ----------------------
+ * This section describes various ways to specify what revisions to display
+ * or otherwise limit the view to. tig(1) does not itself parse the described
+ * revision options so refer to the relevant git man pages for futher
+ * information. Relevant man pages besides git-log(1) are git-diff(1) and
+ * git-rev-list(1).
+ *
+ * You can tune the interaction with git by making use of the options
+ * explained in this section. For example, by configuring the environment
+ * variables described in the  <<view-commands, "View commands">> section.
+ *
+ * Limit by path name
+ * ~~~~~~~~~~~~~~~~~~
+ * If you are interested only in those revisions that made changes to a
+ * specific file (or even several files) list the files like this:
+ *
+ *	$ tig log Makefile README
+ *
+ * To avoid ambiguity with repository references such as tag name, be sure
+ * to separate file names from other git options using "\--". So if you
+ * have a file named 'master' it will clash with the reference named
+ * 'master', and thus you will have to use:
+ *
+ *	$ tig log -- master
+ *
+ * NOTE: For the main view, avoiding ambiguity will in some cases require
+ * you to specify two "\--" options. The first will make tig(1) stop
+ * option processing and the latter will be passed to git log.
+ *
+ * Limit by date or number
+ * ~~~~~~~~~~~~~~~~~~~~~~~
+ * To speed up interaction with git, you can limit the amount of commits
+ * to show both for the log and main view. Either limit by date using
+ * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
+ *
+ * If you are only interested in changed that happened between two dates
+ * you can use:
+ *
+ *	$ tig -- --after="May 5th" --before="2006-05-16 15:44"
+ *
+ * NOTE: If you want to avoid having to quote dates containing spaces you
+ * can use "." instead, e.g. `--after=May.5th`.
+ *
+ * Limiting by commit ranges
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~
+ * Alternatively, commits can be limited to a specific range, such as
+ * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
+ *
+ *	$ tig log tag-1.0..tag-2.0
+ *
+ * This way of commit limiting makes it trivial to only browse the commits
+ * which haven't been pushed to a remote branch. Assuming 'origin' is your
+ * upstream remote branch, using:
+ *
+ *	$ tig log origin..HEAD
+ *
+ * will list what will be pushed to the remote branch. Optionally, the ending
+ * 'HEAD' can be left out since it is implied.
+ *
+ * Limiting by reachability
+ * ~~~~~~~~~~~~~~~~~~~~~~~~
+ * Git interprets the range specifier "tag-1.0..tag-2.0" as
+ * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
+ * Where reachability refers to what commits are ancestors (or part of the
+ * history) of the branch or tagged revision in question.
+ *
+ * If you prefer to specify which commit to preview in this way use the
+ * following:
+ *
+ *	$ tig log tag-2.0 ^tag-1.0
+ *
+ * You can think of '^' as a negation operator. Using this alternate syntax,
+ * it is possible to further prune commits by specifying multiple branch
+ * cut offs.
+ *
+ * Combining revisions specification
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * Revisions options can to some degree be combined, which makes it possible
+ * to say "show at most 20 commits from within the last month that changed
+ * files under the Documentation/ directory."
+ *
+ *	$ tig -- --since=1.month -n20 -- Documentation/
+ *
+ * Examining all repository references
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * In some cases, it can be useful to query changes across all references
+ * in a repository. An example is to ask "did any line of development in
+ * this repository change a particular file within the last week". This
+ * can be accomplished using:
+ *
+ *	$ tig -- --all --since=1.week -- Makefile
+ *
+ * BUGS
  * ----
- * Features that should be explored.
+ * Known bugs and problems:
  *
- * - Dynamic scaling of line number indentation.
+ * - In it's current state tig is pretty much UTF-8 only.
  *
- * - Internal command line (exmode-inspired) which allows to specify what git
- *   log or git diff command to run. Example:
+ * - If the screen width is very small the main view can draw
+ *   outside the current view causing bad wrapping. Same goes
+ *   for title and status windows.
  *
- *	:log -p
+ * TODO
+ * ----
+ * Features that should be explored.
  *
- * - Terminal resizing support. I am yet to figure out whether catching
- *   SIGWINCH is preferred over using ncurses' built-in support for resizing.
+ * - Searching.
  *
  * - Locale support.
  *
@@ -1665,5 +2544,6 @@ main(int argc, char *argv[])
  * link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
  * link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
  * gitk(1): git repository browser written using tcl/tk,
+ * qgit(1): git repository browser written using c++/Qt,
  * gitview(1): git repository browser written using python/gtk.
  **/