X-Git-Url: https://git.distorted.org.uk/~mdw/tig/blobdiff_plain/67e48ac5f5b8a2333710625cb782f840dba27079..c19f8017cc2dd8753f92f9952e65cfad28acbbe0:/tig.c

diff --git a/tig.c b/tig.c
index da2af8f..52abe0f 100644
--- a/tig.c
+++ b/tig.c
@@ -55,6 +55,7 @@
 static void die(const char *err, ...);
 static void report(const char *msg, ...);
 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))
@@ -74,6 +75,8 @@ static void set_nonblocking_input(bool loading);
 #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
 
@@ -109,11 +112,12 @@ enum request {
 	REQ_STOP_LOADING,
 	REQ_TOGGLE_LINE_NUMBERS,
 	REQ_VIEW_NEXT,
+	REQ_VIEW_CLOSE,
+	REQ_NEXT,
+	REQ_PREVIOUS,
 
 	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,
@@ -132,13 +136,7 @@ struct ref {
 	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. */
-};
+static struct ref **get_refs(char *id);
 
 
 /*
@@ -204,6 +202,25 @@ sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
  * -------
  **/
 
+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;
@@ -293,6 +310,16 @@ parse_options(int argc, char *argv[])
 		}
 
 		/**
+		 * -h, --help::
+		 *	Show help message and exit.
+		 **/
+		if (!strcmp(opt, "-h") ||
+		    !strcmp(opt, "--help")) {
+			printf(usage);
+			return FALSE;
+		}
+
+		/**
 		 * \--::
 		 *	End of tig(1) options. Useful when specifying command
 		 *	options for the main view. Example:
@@ -619,6 +646,7 @@ static unsigned int current_view;
 #define foreach_view(view, i) \
 	for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
 
+#define displayed_views()	(display[1] != NULL ? 2 : 1)
 
 /**
  * Current head and commit ID
@@ -641,7 +669,6 @@ struct view {
 	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
@@ -667,6 +694,10 @@ struct view {
 	unsigned long offset;	/* Offset of the window top */
 	unsigned long lineno;	/* Current line number */
 
+	/* If non-NULL, points to the view that opened this view. If this view
+	 * is closed tig will switch back to the parent view. */
+	struct view *parent;
+
 	/* Buffering */
 	unsigned long lines;	/* Total number of lines */
 	void **line;		/* Line index; each line contains user data */
@@ -680,11 +711,11 @@ struct view {
 static struct view_ops pager_ops;
 static struct view_ops main_ops;
 
-#define VIEW_STR(name, cmd, env, ref, objsize, ops) \
-	{ name, cmd, #env, ref, objsize, ops }
+#define VIEW_STR(name, cmd, env, ref, ops) \
+	{ name, cmd, #env, ref, ops }
 
-#define VIEW_(id, name, ops, ref, objsize) \
-	VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, objsize, ops)
+#define VIEW_(id, name, ops, ref) \
+	VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, ops)
 
 /**
  * Views
@@ -717,11 +748,11 @@ static struct view_ops main_ops;
  **/
 
 static struct view views[] = {
-	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)),
+	VIEW_(MAIN,  "main",  &main_ops,  ref_head),
+	VIEW_(DIFF,  "diff",  &pager_ops, ref_commit),
+	VIEW_(LOG,   "log",   &pager_ops, ref_head),
+	VIEW_(HELP,  "help",  &pager_ops, "static"),
+	VIEW_(PAGER, "pager", &pager_ops, "static"),
 };
 
 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
@@ -776,14 +807,27 @@ update_view_title(struct view *view)
 	else
 		wprintw(view->title, "[%s]", view->name);
 
-	if (view->lines) {
+	if (view->lines || view->pipe) {
+		unsigned int lines = view->lines
+				   ? (view->lineno + 1) * 100 / view->lines
+				   : 0;
+
 		wprintw(view->title, " - %s %d of %d (%d%%)",
 			view->ops->type,
 			view->lineno + 1,
 			view->lines,
-			(view->lineno + 1) * 100 / view->lines);
+			lines);
+	}
+
+	if (view->pipe) {
+		time_t secs = time(NULL) - view->start_time;
+
+		/* Three git seconds are a long time ... */
+		if (secs > 2)
+			wprintw(view->title, " %lds", secs);
 	}
 
+
 	wrefresh(view->title);
 }
 
@@ -817,11 +861,8 @@ 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 + 1, 0, offset, 0);
+			view->win = newwin(view->height, 0, offset, 0);
 			if (!view->win)
 				die("Failed to create %s view", view->name);
 
@@ -832,7 +873,7 @@ resize_display(void)
 				die("Failed to create title window");
 
 		} else {
-			wresize(view->win, view->height + 1, view->width);
+			wresize(view->win, view->height, view->width);
 			mvwin(view->win,   offset, 0);
 			mvwin(view->title, offset + view->height, 0);
 			wrefresh(view->win);
@@ -861,7 +902,7 @@ redraw_display(void)
 
 /* Scrolling backend */
 static void
-do_scroll_view(struct view *view, int lines)
+do_scroll_view(struct view *view, int lines, bool redraw)
 {
 	/* The rendering expects the new offset. */
 	view->offset += lines;
@@ -903,6 +944,9 @@ do_scroll_view(struct view *view, int lines)
 
 	assert(view->offset <= view->lineno && view->lineno < view->lines);
 
+	if (!redraw)
+		return;
+
 	redrawwin(view->win);
 	wrefresh(view->win);
 	report("");
@@ -945,12 +989,12 @@ scroll_view(struct view *view, enum request request)
 		die("request %d not handled in switch", request);
 	}
 
-	do_scroll_view(view, lines);
+	do_scroll_view(view, lines, TRUE);
 }
 
 /* Cursor moving */
 static void
-move_view(struct view *view, enum request request)
+move_view(struct view *view, enum request request, bool redraw)
 {
 	int steps;
 
@@ -974,12 +1018,10 @@ 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;
 
@@ -1024,13 +1066,16 @@ move_view(struct view *view, enum request request)
 			}
 		}
 
-		do_scroll_view(view, steps);
+		do_scroll_view(view, steps, redraw);
 		return;
 	}
 
 	/* Draw the current line */
 	view->ops->draw(view, view->lineno - view->offset);
 
+	if (!redraw)
+		return;
+
 	redrawwin(view->win);
 	wrefresh(view->win);
 	report("");
@@ -1041,11 +1086,27 @@ move_view(struct view *view, enum request request)
  * Incremental updating
  */
 
+static void
+end_update(struct view *view)
+{
+	if (!view->pipe)
+		return;
+	set_nonblocking_input(FALSE);
+	if (view->pipe == stdin)
+		fclose(view->pipe);
+	else
+		pclose(view->pipe);
+	view->pipe = NULL;
+}
+
 static bool
 begin_update(struct view *view)
 {
 	const char *id = view->id;
 
+	if (view->pipe)
+		end_update(view);
+
 	if (opt_cmd[0]) {
 		string_copy(view->cmd, opt_cmd);
 		opt_cmd[0] = 0;
@@ -1094,19 +1155,6 @@ begin_update(struct view *view)
 	return TRUE;
 }
 
-static void
-end_update(struct view *view)
-{
-	if (!view->pipe)
-		return;
-	set_nonblocking_input(FALSE);
-	if (view->pipe == stdin)
-		fclose(view->pipe);
-	else
-		pclose(view->pipe);
-	view->pipe = NULL;
-}
-
 static bool
 update_view(struct view *view)
 {
@@ -1179,8 +1227,6 @@ update_view(struct view *view)
 		goto end;
 
 	} else if (feof(view->pipe)) {
-		time_t secs = time(NULL) - view->start_time;
-
 		if (view == VIEW(REQ_VIEW_HELP)) {
 			const char *msg = TIG_HELP;
 
@@ -1195,8 +1241,7 @@ update_view(struct view *view)
 			goto end;
 		}
 
-		report("Loaded %d lines in %ld second%s", view->lines, secs,
-		       secs == 1 ? "" : "s");
+		report("");
 		goto end;
 	}
 
@@ -1224,21 +1269,8 @@ open_view(struct view *prev, enum request request, enum open_flags flags)
 	bool split = !!(flags & OPEN_SPLIT);
 	bool reload = !!(flags & OPEN_RELOAD);
 	struct view *view = VIEW(request);
-	struct view *displayed;
-	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("");
-			return;
-		}
-	}
+	int nviews = displayed_views();
+	struct view *base_view = display[0];
 
 	if (view == prev && nviews == 1 && !reload) {
 		report("Already in %s view", view->name);
@@ -1262,7 +1294,11 @@ open_view(struct view *prev, enum request request, enum open_flags flags)
 		display[current_view] = view;
 	}
 
-	resize_display();
+	/* Resize the view when switching between split- and full-screen,
+	 * or when switching between two different full-screen views. */
+	if (nviews != displayed_views() ||
+	    (nviews == 1 && base_view != display[0]))
+		resize_display();
 
 	if (split && prev->lineno - prev->offset >= prev->height) {
 		/* Take the title line into account. */
@@ -1270,24 +1306,25 @@ open_view(struct view *prev, enum request request, enum open_flags flags)
 
 		/* Scroll the view that was split if the current line is
 		 * outside the new limited view. */
-		do_scroll_view(prev, lines);
+		do_scroll_view(prev, lines, TRUE);
 	}
 
 	if (prev && view != prev) {
-		/* "Blur" the previous view. */
-		if (!backgrounded)
-			update_view_title(prev);
-
 		/* Continue loading split views in the background. */
 		if (!split)
 			end_update(prev);
+		else if (!backgrounded)
+			/* "Blur" the previous view. */
+			update_view_title(prev);
+
+		view->parent = prev;
 	}
 
 	if (view->pipe) {
 		/* Clear the old view and let the incremental updating refill
 		 * the screen. */
 		wclear(view->win);
-		report("Loading...");
+		report("");
 	} else {
 		redraw_view(view);
 		if (view == VIEW(REQ_VIEW_HELP))
@@ -1319,7 +1356,7 @@ view_driver(struct view *view, enum request request)
 	case REQ_MOVE_PAGE_DOWN:
 	case REQ_MOVE_FIRST_LINE:
 	case REQ_MOVE_LAST_LINE:
-		move_view(view, request);
+		move_view(view, request, TRUE);
 		break;
 
 	case REQ_SCROLL_LINE_DOWN:
@@ -1337,9 +1374,22 @@ view_driver(struct view *view, enum request request)
 		open_view(view, request, OPEN_DEFAULT);
 		break;
 
-	case REQ_MOVE_UP_ENTER:
-	case REQ_MOVE_DOWN_ENTER:
-		move_view(view, request);
+	case REQ_NEXT:
+	case REQ_PREVIOUS:
+		request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
+
+		if (view == VIEW(REQ_VIEW_DIFF) &&
+		    view->parent == VIEW(REQ_VIEW_MAIN)) {
+			bool redraw = display[1] == view;
+
+			view = view->parent;
+			move_view(view, request, redraw);
+			if (redraw)
+				update_view_title(view);
+		} else {
+			move_view(view, request, TRUE);
+			break;
+		}
 		/* Fall-through */
 
 	case REQ_ENTER:
@@ -1351,7 +1401,7 @@ view_driver(struct view *view, enum request request)
 
 	case REQ_VIEW_NEXT:
 	{
-		int nviews = display[1] ? 2 : 1;
+		int nviews = displayed_views();
 		int next_view = (current_view + 1) % nviews;
 
 		if (next_view == current_view) {
@@ -1384,7 +1434,7 @@ view_driver(struct view *view, enum request request)
 		break;
 
 	case REQ_SHOW_VERSION:
-		report("Version: %s", VERSION);
+		report("%s (built %s)", VERSION, __DATE__);
 		return TRUE;
 
 	case REQ_SCREEN_RESIZE:
@@ -1398,6 +1448,17 @@ view_driver(struct view *view, enum request request)
 		doupdate();
 		return TRUE;
 
+	case REQ_VIEW_CLOSE:
+		if (view->parent) {
+			memset(display, 0, sizeof(display));
+			current_view = 0;
+			display[current_view] = view->parent;
+			view->parent = NULL;
+			resize_display();
+			redraw_display();
+			break;
+		}
+		/* Fall-through */
 	case REQ_QUIT:
 		return FALSE;
 
@@ -1412,7 +1473,7 @@ view_driver(struct view *view, enum request request)
 
 
 /*
- * View backend handlers
+ * Pager backend
  */
 
 static bool
@@ -1520,18 +1581,25 @@ static bool
 pager_enter(struct view *view)
 {
 	char *line = view->line[view->lineno];
+	int split = 0;
 
-	if (view == VIEW(REQ_VIEW_DIFF)) {
-		scroll_view(view, REQ_SCROLL_LINE_DOWN);
-		return TRUE;
+	if ((view == VIEW(REQ_VIEW_LOG) ||
+	     view == VIEW(REQ_VIEW_PAGER)) &&
+	    get_line_type(line) == LINE_COMMIT) {
+		open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
+		split = 1;
 	}
 
-	if (get_line_type(line) == LINE_COMMIT) {
-		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);
-	}
+	/* Always scroll the view even if it was split. That way
+	 * you can use Enter to scroll through the log view and
+	 * split open each commit diff. */
+	scroll_view(view, REQ_SCROLL_LINE_DOWN);
+
+	/* FIXME: A minor workaround. Scrolling the view will call report("")
+	 * but if we are scolling a non-current view this won't properly update
+	 * the view title. */
+	if (split)
+		update_view_title(view);
 
 	return TRUE;
 }
@@ -1544,7 +1612,17 @@ static struct view_ops pager_ops = {
 };
 
 
-static struct ref **get_refs(char *id);
+/*
+ * Main view backend
+ */
+
+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. */
+};
 
 static bool
 main_draw(struct view *view, unsigned int lineno)
@@ -1554,6 +1632,8 @@ main_draw(struct view *view, unsigned int lineno)
 	enum line_type type;
 	int col = 0;
 	size_t timelen;
+	size_t authorlen;
+	int trimmed;
 
 	if (view->offset + lineno >= view->lines)
 		return FALSE;
@@ -1585,8 +1665,11 @@ main_draw(struct view *view, unsigned int lineno)
 	if (type != LINE_CURSOR)
 		wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
 
-	if (strlen(commit->author) > 19) {
-		waddnstr(view->win, commit->author, 18);
+	/* FIXME: Make this optional, and add i18n.commitEncoding support. */
+	authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
+
+	if (trimmed) {
+		waddnstr(view->win, commit->author, authorlen);
 		if (type != LINE_CURSOR)
 			wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
 		waddch(view->win, '~');
@@ -1594,7 +1677,7 @@ main_draw(struct view *view, unsigned int lineno)
 		waddstr(view->win, commit->author);
 	}
 
-	col += 20;
+	col += AUTHOR_COLS;
 	if (type != LINE_CURSOR)
 		wattrset(view->win, A_NORMAL);
 
@@ -1728,7 +1811,9 @@ main_read(struct view *view, char *line)
 static bool
 main_enter(struct view *view)
 {
-	open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT | OPEN_BACKGROUNDED);
+	enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
+
+	open_view(view, REQ_VIEW_DIFF, flags);
 	return TRUE;
 }
 
@@ -1765,6 +1850,20 @@ static struct keymap keymap[] = {
 	 *	Switch to pager view.
 	 * h::
 	 *	Show man page.
+	 **/
+	{ 'm',		REQ_VIEW_MAIN },
+	{ 'd',		REQ_VIEW_DIFF },
+	{ 'l',		REQ_VIEW_LOG },
+	{ 'p',		REQ_VIEW_PAGER },
+	{ 'h',		REQ_VIEW_HELP },
+
+	/**
+	 * View manipulation
+	 * ~~~~~~~~~~~~~~~~~
+	 * q::
+	 *	Close view, if multiple views are open it will jump back to the
+	 *	previous view in the view stack. If it is the last open view it
+	 *	will quit. Use 'Q' to quit all views at once.
 	 * 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
@@ -1772,31 +1871,31 @@ static struct keymap keymap[] = {
 	 *	pressing Enter will simply scroll the view one line down.
 	 * Tab::
 	 *	Switch to next view.
+	 * Up::
+	 *	This key is "context sensitive" and will move the cursor one
+	 *	line up. However, uf you opened a diff view from the main view
+	 *	(split- or full-screen) it will change the cursor to point to
+	 *	the previous commit in the main view and update the diff view
+	 *	to display it.
+	 * Down::
+	 *	Similar to 'Up' but will move down.
 	 **/
-	{ '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 },
+	{ KEY_UP,	REQ_PREVIOUS },
+	{ KEY_DOWN,	REQ_NEXT },
 
 	/**
 	 * Cursor navigation
 	 * ~~~~~~~~~~~~~~~~~
-	 * Up::
+	 * j::
 	 *	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.
+	 *	Move cursor one line down.
 	 * PgUp::
 	 * b::
+	 * -::
 	 *	Move cursor one page up.
 	 * PgDown::
 	 * Space::
@@ -1806,16 +1905,15 @@ static struct keymap keymap[] = {
 	 * 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 },
+	{ 'k',		REQ_MOVE_UP },
+	{ 'j',		REQ_MOVE_DOWN },
 	{ 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
@@ -1837,8 +1935,8 @@ static struct keymap keymap[] = {
 	/**
 	 * Misc
 	 * ~~~~
-	 * q::
-	 *	Quit
+	 * Q::
+	 *	Quit.
 	 * r::
 	 *	Redraw screen.
 	 * z::
@@ -1855,7 +1953,7 @@ static struct keymap keymap[] = {
 	 *
 	 *	:log -p
 	 **/
-	{ 'q',		REQ_QUIT },
+	{ 'Q',		REQ_QUIT },
 	{ 'z',		REQ_STOP_LOADING },
 	{ 'v',		REQ_SHOW_VERSION },
 	{ 'r',		REQ_SCREEN_REDRAW },
@@ -1883,11 +1981,171 @@ get_request(int 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;
+static bool cursed = FALSE;
 
 /* The status window is used for polling keystrokes. */
 static WINDOW *status_win;
@@ -1984,39 +2242,57 @@ init_display(void)
 static struct ref *refs;
 static size_t refs_size;
 
+/* Id <-> ref store */
+static struct ref ***id_refs;
+static size_t id_refs_size;
+
 static struct ref **
 get_refs(char *id)
 {
-	struct ref **id_refs = NULL;
-	size_t id_refs_size = 0;
+	struct ref ***tmp_id_refs;
+	struct ref **ref_list = NULL;
+	size_t ref_list_size = 0;
 	size_t i;
 
+	for (i = 0; i < id_refs_size; i++)
+		if (!strcmp(id, id_refs[i][0]->id))
+			return id_refs[i];
+
+	tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
+	if (!tmp_id_refs)
+		return NULL;
+
+	id_refs = tmp_id_refs;
+
 	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));
+		tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
 		if (!tmp) {
-			if (id_refs)
-				free(id_refs);
+			if (ref_list)
+				free(ref_list);
 			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];
+		ref_list = tmp;
+		if (ref_list_size > 0)
+			ref_list[ref_list_size - 1]->next = 1;
+		ref_list[ref_list_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++;
+		ref_list[ref_list_size]->next = 0;
+		ref_list_size++;
 	}
 
-	return id_refs;
+	if (ref_list)
+		id_refs[id_refs_size++] = ref_list;
+
+	return ref_list;
 }
 
 static int
@@ -2084,9 +2360,6 @@ load_refs(void)
 
 	pclose(pipe);
 
-	if (refs_size == 0)
-		die("Not a git repository");
-
 	return OK;
 }
 
@@ -2140,6 +2413,10 @@ main(int argc, char *argv[])
 	if (load_refs() == ERR)
 		die("Failed to load refs.");
 
+	/* Require a git repository unless when running in pager mode. */
+	if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
+		die("Not a git repository");
+
 	for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
 		view->cmd_env = getenv(view->cmd_env);
 
@@ -2301,10 +2578,15 @@ main(int argc, char *argv[])
  * ----
  * Known bugs and problems:
  *
+ * - In it's current state tig is pretty much UTF-8 only.
+ *
  * - 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.
  *
+ * - The cursor can wrap-around on the last line and cause the
+ *   window to scroll.
+ *
  * TODO
  * ----
  * Features that should be explored.