1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
18 * tig - text-mode interface for git
24 * tig [options] [--] [git log options]
25 * tig [options] log [git log options]
26 * tig [options] diff [git diff options]
27 * tig [options] show [git show options]
28 * tig [options] < [git command output]
32 * Browse changes in a git repository. Additionally, tig(1) can also act
33 * as a pager for output of various git commands.
35 * When browsing repositories, tig(1) uses the underlying git commands
36 * to present the user with various views, such as summarized commit log
37 * and showing the commit with the log message, diffstat, and the diff.
39 * Using tig(1) as a pager, it will display input from stdin and try
44 #define VERSION "tig-0.3"
64 static void die(const char *err, ...);
65 static void report(const char *msg, ...);
66 static void set_nonblocking_input(bool loading);
67 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
69 #define ABS(x) ((x) >= 0 ? (x) : -(x))
70 #define MIN(x, y) ((x) < (y) ? (x) : (y))
72 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
73 #define STRING_SIZE(x) (sizeof(x) - 1)
75 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
76 #define SIZEOF_CMD 1024 /* Size of command buffer. */
78 /* This color name can be used to refer to the default term colors. */
79 #define COLOR_DEFAULT (-1)
81 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
83 /* The format and size of the date column in the main view. */
84 #define DATE_FORMAT "%Y-%m-%d %H:%M"
85 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
87 #define AUTHOR_COLS 20
89 /* The default interval between line numbers. */
90 #define NUMBER_INTERVAL 1
94 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
96 /* Some ascii-shorthands fitted into the ncurses namespace. */
98 #define KEY_RETURN '\r'
102 /* User action requests. */
104 /* Offset all requests to avoid conflicts with ncurses getch values. */
105 REQ_OFFSET = KEY_MAX + 1,
107 /* XXX: Keep the view request first and in sync with views[]. */
122 REQ_TOGGLE_LINE_NUMBERS,
136 REQ_SCROLL_LINE_DOWN,
138 REQ_SCROLL_PAGE_DOWN,
142 char *name; /* Ref name; tag or head names are shortened. */
143 char id[41]; /* Commit SHA1 ID */
144 unsigned int tag:1; /* Is it a tag? */
145 unsigned int next:1; /* For ref lists: are there more refs? */
148 static struct ref **get_refs(char *id);
156 string_ncopy(char *dst, const char *src, int dstlen)
158 strncpy(dst, src, dstlen - 1);
163 /* Shorthand for safely copying into a fixed buffer. */
164 #define string_copy(dst, src) \
165 string_ncopy(dst, src, sizeof(dst))
170 * NOTE: The following is a slightly modified copy of the git project's shell
171 * quoting routines found in the quote.c file.
173 * Help to copy the thing properly quoted for the shell safety. any single
174 * quote is replaced with '\'', any exclamation point is replaced with '\!',
175 * and the whole thing is enclosed in a
178 * original sq_quote result
179 * name ==> name ==> 'name'
180 * a b ==> a b ==> 'a b'
181 * a'b ==> a'\''b ==> 'a'\''b'
182 * a!b ==> a'\!'b ==> 'a'\!'b'
186 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
190 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
193 while ((c = *src++)) {
194 if (c == '\'' || c == '!') {
214 static const char usage[] =
215 VERSION " (" __DATE__ ")\n"
217 "Usage: tig [options]\n"
218 " or: tig [options] [--] [git log options]\n"
219 " or: tig [options] log [git log options]\n"
220 " or: tig [options] diff [git diff options]\n"
221 " or: tig [options] show [git show options]\n"
222 " or: tig [options] < [git command output]\n"
225 " -l Start up in log view\n"
226 " -d Start up in diff view\n"
227 " -n[I], --line-number[=I] Show line numbers with given interval\n"
228 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
229 " -- Mark end of tig options\n"
230 " -v, --version Show version and exit\n"
231 " -h, --help Show help message and exit\n";
233 /* Option and state variables. */
234 static bool opt_line_number = FALSE;
235 static int opt_num_interval = NUMBER_INTERVAL;
236 static int opt_tab_size = TABSIZE;
237 static enum request opt_request = REQ_VIEW_MAIN;
238 static char opt_cmd[SIZEOF_CMD] = "";
239 static FILE *opt_pipe = NULL;
241 /* Returns the index of log or diff command or -1 to exit. */
243 parse_options(int argc, char *argv[])
247 for (i = 1; i < argc; i++) {
252 * Start up in log view using the internal log command.
254 if (!strcmp(opt, "-l")) {
255 opt_request = REQ_VIEW_LOG;
261 * Start up in diff view using the internal diff command.
263 if (!strcmp(opt, "-d")) {
264 opt_request = REQ_VIEW_DIFF;
269 * -n[INTERVAL], --line-number[=INTERVAL]::
270 * Prefix line numbers in log and diff view.
271 * Optionally, with interval different than each line.
273 if (!strncmp(opt, "-n", 2) ||
274 !strncmp(opt, "--line-number", 13)) {
280 } else if (opt[STRING_SIZE("--line-number")] == '=') {
281 num = opt + STRING_SIZE("--line-number=");
285 opt_num_interval = atoi(num);
287 opt_line_number = TRUE;
292 * -t[NSPACES], --tab-size[=NSPACES]::
293 * Set the number of spaces tabs should be expanded to.
295 if (!strncmp(opt, "-t", 2) ||
296 !strncmp(opt, "--tab-size", 10)) {
302 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
303 num = opt + STRING_SIZE("--tab-size=");
307 opt_tab_size = MIN(atoi(num), TABSIZE);
313 * Show version and exit.
315 if (!strcmp(opt, "-v") ||
316 !strcmp(opt, "--version")) {
317 printf("tig version %s\n", VERSION);
323 * Show help message and exit.
325 if (!strcmp(opt, "-h") ||
326 !strcmp(opt, "--help")) {
333 * End of tig(1) options. Useful when specifying command
334 * options for the main view. Example:
336 * $ tig -- --since=1.month
338 if (!strcmp(opt, "--")) {
344 * log [git log options]::
345 * Open log view using the given git log options.
347 * diff [git diff options]::
348 * Open diff view using the given git diff options.
350 * show [git show options]::
351 * Open diff view using the given git show options.
353 if (!strcmp(opt, "log") ||
354 !strcmp(opt, "diff") ||
355 !strcmp(opt, "show")) {
356 opt_request = opt[0] == 'l'
357 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
362 * [git log options]::
363 * tig(1) will stop the option parsing when the first
364 * command line parameter not starting with "-" is
365 * encountered. All options including this one will be
366 * passed to git log when loading the main view.
367 * This makes it possible to say:
369 * $ tig tag-1.0..HEAD
371 if (opt[0] && opt[0] != '-')
374 die("unknown command '%s'", opt);
377 if (!isatty(STDIN_FILENO)) {
381 * If stdin is a pipe, any log or diff options will be ignored and the
382 * pager view will be opened loading data from stdin. The pager mode
383 * can be used for colorizing output from various git commands.
385 * Example on how to colorize the output of git-show(1):
389 opt_request = REQ_VIEW_PAGER;
392 } else if (i < argc) {
396 * Git command options
397 * ~~~~~~~~~~~~~~~~~~~
398 * All git command options specified on the command line will
399 * be passed to the given command and all will be shell quoted
400 * before they are passed to the shell.
402 * NOTE: If you specify options for the main view, you should
403 * not use the `--pretty` option as this option will be set
404 * automatically to the format expected by the main view.
406 * Example on how to open the log view and show both author and
407 * committer information:
409 * $ tig log --pretty=fuller
411 * See the <<refspec, "Specifying revisions">> section below
412 * for an introduction to revision options supported by the git
413 * commands. For details on specific git command options, refer
414 * to the man page of the command in question.
417 if (opt_request == REQ_VIEW_MAIN)
418 /* XXX: This is vulnerable to the user overriding
419 * options required for the main view parser. */
420 string_copy(opt_cmd, "git log --stat --pretty=raw");
422 string_copy(opt_cmd, "git");
423 buf_size = strlen(opt_cmd);
425 while (buf_size < sizeof(opt_cmd) && i < argc) {
426 opt_cmd[buf_size++] = ' ';
427 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
430 if (buf_size >= sizeof(opt_cmd))
431 die("command too long");
433 opt_cmd[buf_size] = 0;
442 * ENVIRONMENT VARIABLES
443 * ---------------------
444 * Several options related to the interface with git can be configured
445 * via environment options.
447 * Repository references
448 * ~~~~~~~~~~~~~~~~~~~~~
449 * Commits that are referenced by tags and branch heads will be marked
450 * by the reference name surrounded by '[' and ']':
452 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
454 * If you want to filter out certain directories under `.git/refs/`, say
455 * `tmp` you can do it by setting the following variable:
457 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
459 * Or set the variable permanently in your environment.
462 * Set command for retrieving all repository references. The command
463 * should output data in the same format as git-ls-remote(1).
466 #define TIG_LS_REMOTE \
467 "git ls-remote . 2>/dev/null"
473 * It is possible to alter which commands are used for the different views.
474 * If for example you prefer commits in the main view to be sorted by date
475 * and only show 500 commits, use:
477 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
479 * Or set the variable permanently in your environment.
481 * Notice, how `%s` is used to specify the commit reference. There can
482 * be a maximum of 5 `%s` ref specifications.
485 * The command used for the diff view. By default, git show is used
489 * The command used for the log view. If you prefer to have both
490 * author and committer shown in the log view be sure to pass
491 * `--pretty=fuller` to git log.
494 * The command used for the main view. Note, you must always specify
495 * the option: `--pretty=raw` since the main view parser expects to
499 #define TIG_DIFF_CMD \
500 "git show --patch-with-stat --find-copies-harder -B -C %s"
502 #define TIG_LOG_CMD \
503 "git log --cc --stat -n100 %s"
505 #define TIG_MAIN_CMD \
506 "git log --topo-order --stat --pretty=raw %s"
508 /* ... silently ignore that the following are also exported. */
510 #define TIG_HELP_CMD \
511 "man tig 2>/dev/null"
513 #define TIG_PAGER_CMD \
518 * Line-oriented content detection.
522 /* Line type String to match Foreground Background Attributes
523 * --------- --------------- ---------- ---------- ---------- */ \
525 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
526 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
527 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
528 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
529 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
530 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
531 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
532 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
533 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
534 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
535 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
536 /* Pretty print commit header */ \
537 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
538 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
539 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
540 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
541 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
542 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
543 /* Raw commit header */ \
544 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
545 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
546 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
547 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
548 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
550 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
551 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
553 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
554 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
555 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
556 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
557 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
558 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
559 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
560 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
561 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
562 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
563 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
566 #define LINE(type, line, fg, bg, attr) \
573 const char *line; /* The start of line to match. */
574 int linelen; /* Size of string to match. */
575 int fg, bg, attr; /* Color and text attributes for the lines. */
578 static struct line_info line_info[] = {
579 #define LINE(type, line, fg, bg, attr) \
580 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
585 static enum line_type
586 get_line_type(char *line)
588 int linelen = strlen(line);
591 for (type = 0; type < ARRAY_SIZE(line_info); type++)
592 /* Case insensitive search matches Signed-off-by lines better. */
593 if (linelen >= line_info[type].linelen &&
594 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
601 get_line_attr(enum line_type type)
603 assert(type < ARRAY_SIZE(line_info));
604 return COLOR_PAIR(type) | line_info[type].attr;
610 int default_bg = COLOR_BLACK;
611 int default_fg = COLOR_WHITE;
616 if (use_default_colors() != ERR) {
621 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
622 struct line_info *info = &line_info[type];
623 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
624 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
626 init_pair(type, fg, bg);
632 void *data; /* User data */
639 * The display consists of a status window on the last line of the screen and
640 * one or more views. The default is to only show one view at the time but it
641 * is possible to split both the main and log view to also show the commit
644 * If you are in the log view and press 'Enter' when the current line is a
645 * commit line, such as:
647 * commit 4d55caff4cc89335192f3e566004b4ceef572521
649 * You will split the view so that the log view is displayed in the top window
650 * and the diff view in the bottom window. You can switch between the two
651 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
657 /* The display array of active views and the index of the current view. */
658 static struct view *display[2];
659 static unsigned int current_view;
661 #define foreach_view(view, i) \
662 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
664 #define displayed_views() (display[1] != NULL ? 2 : 1)
667 * Current head and commit ID
668 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
669 * The viewer keeps track of both what head and commit ID you are currently
670 * viewing. The commit ID will follow the cursor line and change everytime time
671 * you highlight a different commit. Whenever you reopen the diff view it
672 * will be reloaded, if the commit ID changed.
674 * The head ID is used when opening the main and log view to indicate from
675 * what revision to show history.
678 static char ref_commit[SIZEOF_REF] = "HEAD";
679 static char ref_head[SIZEOF_REF] = "HEAD";
682 const char *name; /* View name */
683 const char *cmd_fmt; /* Default command line format */
684 const char *cmd_env; /* Command line set via environment */
685 const char *id; /* Points to either of ref_{head,commit} */
687 struct view_ops *ops; /* View operations */
689 char cmd[SIZEOF_CMD]; /* Command buffer */
690 char ref[SIZEOF_REF]; /* Hovered commit reference */
691 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
693 int height, width; /* The width and height of the main window */
694 WINDOW *win; /* The main window */
695 WINDOW *title; /* The title window living below the main window */
698 unsigned long offset; /* Offset of the window top */
699 unsigned long lineno; /* Current line number */
701 /* If non-NULL, points to the view that opened this view. If this view
702 * is closed tig will switch back to the parent view. */
706 unsigned long lines; /* Total number of lines */
707 struct line *line; /* Line index */
708 unsigned int digits; /* Number of digits in the lines member. */
716 /* What type of content being displayed. Used in the title bar. */
718 /* Draw one line; @lineno must be < view->height. */
719 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
720 /* Read one line; updates view->line. */
721 bool (*read)(struct view *view, struct line *prev, char *data);
722 /* Depending on view, change display based on current line. */
723 bool (*enter)(struct view *view, struct line *line);
726 static struct view_ops pager_ops;
727 static struct view_ops main_ops;
729 #define VIEW_STR(name, cmd, env, ref, ops) \
730 { name, cmd, #env, ref, ops }
732 #define VIEW_(id, name, ops, ref) \
733 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
738 * tig(1) presents various 'views' of a repository. Each view is based on output
739 * from an external command, most often 'git log', 'git diff', or 'git show'.
742 * Is the default view, and it shows a one line summary of each commit
743 * in the chosen list of revisions. The summary includes commit date,
744 * author, and the first line of the log message. Additionally, any
745 * repository references, such as tags, will be shown.
748 * Presents a more rich view of the revision log showing the whole log
749 * message and the diffstat.
752 * Shows either the diff of the current working tree, that is, what
753 * has changed since the last commit, or the commit diff complete
754 * with log message, diffstat and diff.
757 * Is used for displaying both input from stdin and output from git
758 * commands entered in the internal prompt.
761 * Displays the information from the tig(1) man page. For the help view
762 * to work you need to have the tig(1) man page installed.
765 static struct view views[] = {
766 VIEW_(MAIN, "main", &main_ops, ref_head),
767 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
768 VIEW_(LOG, "log", &pager_ops, ref_head),
769 VIEW_(HELP, "help", &pager_ops, "static"),
770 VIEW_(PAGER, "pager", &pager_ops, "static"),
773 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
777 draw_view_line(struct view *view, unsigned int lineno)
779 if (view->offset + lineno >= view->lines)
782 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
786 redraw_view_from(struct view *view, int lineno)
788 assert(0 <= lineno && lineno < view->height);
790 for (; lineno < view->height; lineno++) {
791 if (!draw_view_line(view, lineno))
795 redrawwin(view->win);
800 redraw_view(struct view *view)
803 redraw_view_from(view, 0);
810 * Each view has a title window which shows the name of the view, current
811 * commit ID if available, and where the view is positioned:
813 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
815 * By default, the title of the current view is highlighted using bold font.
819 update_view_title(struct view *view)
821 if (view == display[current_view])
822 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
824 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
827 wmove(view->title, 0, 0);
830 wprintw(view->title, "[%s] %s", view->name, view->ref);
832 wprintw(view->title, "[%s]", view->name);
834 if (view->lines || view->pipe) {
835 unsigned int lines = view->lines
836 ? (view->lineno + 1) * 100 / view->lines
839 wprintw(view->title, " - %s %d of %d (%d%%)",
847 time_t secs = time(NULL) - view->start_time;
849 /* Three git seconds are a long time ... */
851 wprintw(view->title, " %lds", secs);
855 wrefresh(view->title);
862 struct view *base = display[0];
863 struct view *view = display[1] ? display[1] : display[0];
865 /* Setup window dimensions */
867 getmaxyx(stdscr, base->height, base->width);
869 /* Make room for the status window. */
873 /* Horizontal split. */
874 view->width = base->width;
875 view->height = SCALE_SPLIT_VIEW(base->height);
876 base->height -= view->height;
878 /* Make room for the title bar. */
882 /* Make room for the title bar. */
887 foreach_view (view, i) {
889 view->win = newwin(view->height, 0, offset, 0);
891 die("Failed to create %s view", view->name);
893 scrollok(view->win, TRUE);
895 view->title = newwin(1, 0, offset + view->height, 0);
897 die("Failed to create title window");
900 wresize(view->win, view->height, view->width);
901 mvwin(view->win, offset, 0);
902 mvwin(view->title, offset + view->height, 0);
906 offset += view->height + 1;
916 foreach_view (view, i) {
918 update_view_title(view);
927 /* Scrolling backend */
929 do_scroll_view(struct view *view, int lines, bool redraw)
931 /* The rendering expects the new offset. */
932 view->offset += lines;
934 assert(0 <= view->offset && view->offset < view->lines);
937 /* Redraw the whole screen if scrolling is pointless. */
938 if (view->height < ABS(lines)) {
942 int line = lines > 0 ? view->height - lines : 0;
943 int end = line + ABS(lines);
945 wscrl(view->win, lines);
947 for (; line < end; line++) {
948 if (!draw_view_line(view, line))
953 /* Move current line into the view. */
954 if (view->lineno < view->offset) {
955 view->lineno = view->offset;
956 draw_view_line(view, 0);
958 } else if (view->lineno >= view->offset + view->height) {
959 if (view->lineno == view->offset + view->height) {
960 /* Clear the hidden line so it doesn't show if the view
962 wmove(view->win, view->height, 0);
963 wclrtoeol(view->win);
965 view->lineno = view->offset + view->height - 1;
966 draw_view_line(view, view->lineno - view->offset);
969 assert(view->offset <= view->lineno && view->lineno < view->lines);
974 redrawwin(view->win);
979 /* Scroll frontend */
981 scroll_view(struct view *view, enum request request)
986 case REQ_SCROLL_PAGE_DOWN:
987 lines = view->height;
988 case REQ_SCROLL_LINE_DOWN:
989 if (view->offset + lines > view->lines)
990 lines = view->lines - view->offset;
992 if (lines == 0 || view->offset + view->height >= view->lines) {
993 report("Cannot scroll beyond the last line");
998 case REQ_SCROLL_PAGE_UP:
999 lines = view->height;
1000 case REQ_SCROLL_LINE_UP:
1001 if (lines > view->offset)
1002 lines = view->offset;
1005 report("Cannot scroll beyond the first line");
1013 die("request %d not handled in switch", request);
1016 do_scroll_view(view, lines, TRUE);
1021 move_view(struct view *view, enum request request, bool redraw)
1026 case REQ_MOVE_FIRST_LINE:
1027 steps = -view->lineno;
1030 case REQ_MOVE_LAST_LINE:
1031 steps = view->lines - view->lineno - 1;
1034 case REQ_MOVE_PAGE_UP:
1035 steps = view->height > view->lineno
1036 ? -view->lineno : -view->height;
1039 case REQ_MOVE_PAGE_DOWN:
1040 steps = view->lineno + view->height >= view->lines
1041 ? view->lines - view->lineno - 1 : view->height;
1053 die("request %d not handled in switch", request);
1056 if (steps <= 0 && view->lineno == 0) {
1057 report("Cannot move beyond the first line");
1060 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1061 report("Cannot move beyond the last line");
1065 /* Move the current line */
1066 view->lineno += steps;
1067 assert(0 <= view->lineno && view->lineno < view->lines);
1069 /* Repaint the old "current" line if we be scrolling */
1070 if (ABS(steps) < view->height) {
1071 int prev_lineno = view->lineno - steps - view->offset;
1073 wmove(view->win, prev_lineno, 0);
1074 wclrtoeol(view->win);
1075 draw_view_line(view, prev_lineno);
1078 /* Check whether the view needs to be scrolled */
1079 if (view->lineno < view->offset ||
1080 view->lineno >= view->offset + view->height) {
1081 if (steps < 0 && -steps > view->offset) {
1082 steps = -view->offset;
1084 } else if (steps > 0) {
1085 if (view->lineno == view->lines - 1 &&
1086 view->lines > view->height) {
1087 steps = view->lines - view->offset - 1;
1088 if (steps >= view->height)
1089 steps -= view->height - 1;
1093 do_scroll_view(view, steps, redraw);
1097 /* Draw the current line */
1098 draw_view_line(view, view->lineno - view->offset);
1103 redrawwin(view->win);
1104 wrefresh(view->win);
1110 * Incremental updating
1114 end_update(struct view *view)
1118 set_nonblocking_input(FALSE);
1119 if (view->pipe == stdin)
1127 begin_update(struct view *view)
1129 const char *id = view->id;
1135 string_copy(view->cmd, opt_cmd);
1137 /* When running random commands, the view ref could have become
1138 * invalid so clear it. */
1141 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1143 if (snprintf(view->cmd, sizeof(view->cmd), format,
1144 id, id, id, id, id) >= sizeof(view->cmd))
1148 /* Special case for the pager view. */
1150 view->pipe = opt_pipe;
1153 view->pipe = popen(view->cmd, "r");
1159 set_nonblocking_input(TRUE);
1164 string_copy(view->vid, id);
1169 for (i = 0; i < view->lines; i++)
1170 if (view->line[i].data)
1171 free(view->line[i].data);
1177 view->start_time = time(NULL);
1183 update_view(struct view *view)
1185 char buffer[BUFSIZ];
1188 /* The number of lines to read. If too low it will cause too much
1189 * redrawing (and possible flickering), if too high responsiveness
1191 unsigned long lines = view->height;
1192 int redraw_from = -1;
1197 /* Only redraw if lines are visible. */
1198 if (view->offset + view->height >= view->lines)
1199 redraw_from = view->lines - view->offset;
1201 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1207 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1208 int linelen = strlen(line);
1210 struct line *prev = view->lines
1211 ? &view->line[view->lines - 1]
1215 line[linelen - 1] = 0;
1217 if (!view->ops->read(view, prev, line))
1227 lines = view->lines;
1228 for (digits = 0; lines; digits++)
1231 /* Keep the displayed view in sync with line number scaling. */
1232 if (digits != view->digits) {
1233 view->digits = digits;
1238 if (redraw_from >= 0) {
1239 /* If this is an incremental update, redraw the previous line
1240 * since for commits some members could have changed when
1241 * loading the main view. */
1242 if (redraw_from > 0)
1245 /* Incrementally draw avoids flickering. */
1246 redraw_view_from(view, redraw_from);
1249 /* Update the title _after_ the redraw so that if the redraw picks up a
1250 * commit reference in view->ref it'll be available here. */
1251 update_view_title(view);
1253 if (ferror(view->pipe)) {
1254 report("Failed to read: %s", strerror(errno));
1257 } else if (feof(view->pipe)) {
1258 if (view == VIEW(REQ_VIEW_HELP)) {
1259 const char *msg = TIG_HELP;
1261 if (view->lines == 0) {
1262 /* Slightly ugly, but abusing view->ref keeps
1263 * the error message. */
1264 string_copy(view->ref, "No help available");
1265 msg = "The tig(1) manpage is not installed";
1279 report("Allocation failure");
1287 OPEN_DEFAULT = 0, /* Use default view switching. */
1288 OPEN_SPLIT = 1, /* Split current view. */
1289 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1290 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1294 open_view(struct view *prev, enum request request, enum open_flags flags)
1296 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1297 bool split = !!(flags & OPEN_SPLIT);
1298 bool reload = !!(flags & OPEN_RELOAD);
1299 struct view *view = VIEW(request);
1300 int nviews = displayed_views();
1301 struct view *base_view = display[0];
1303 if (view == prev && nviews == 1 && !reload) {
1304 report("Already in %s view", view->name);
1308 if ((reload || strcmp(view->vid, view->id)) &&
1309 !begin_update(view)) {
1310 report("Failed to load %s view", view->name);
1315 display[current_view + 1] = view;
1319 /* Maximize the current view. */
1320 memset(display, 0, sizeof(display));
1322 display[current_view] = view;
1325 /* Resize the view when switching between split- and full-screen,
1326 * or when switching between two different full-screen views. */
1327 if (nviews != displayed_views() ||
1328 (nviews == 1 && base_view != display[0]))
1331 if (split && prev->lineno - prev->offset >= prev->height) {
1332 /* Take the title line into account. */
1333 int lines = prev->lineno - prev->offset - prev->height + 1;
1335 /* Scroll the view that was split if the current line is
1336 * outside the new limited view. */
1337 do_scroll_view(prev, lines, TRUE);
1340 if (prev && view != prev) {
1341 /* Continue loading split views in the background. */
1344 else if (!backgrounded)
1345 /* "Blur" the previous view. */
1346 update_view_title(prev);
1348 view->parent = prev;
1352 /* Clear the old view and let the incremental updating refill
1358 if (view == VIEW(REQ_VIEW_HELP))
1359 report("%s", TIG_HELP);
1364 /* If the view is backgrounded the above calls to report()
1365 * won't redraw the view title. */
1367 update_view_title(view);
1372 * User request switch noodle
1376 view_driver(struct view *view, enum request request)
1383 case REQ_MOVE_PAGE_UP:
1384 case REQ_MOVE_PAGE_DOWN:
1385 case REQ_MOVE_FIRST_LINE:
1386 case REQ_MOVE_LAST_LINE:
1387 move_view(view, request, TRUE);
1390 case REQ_SCROLL_LINE_DOWN:
1391 case REQ_SCROLL_LINE_UP:
1392 case REQ_SCROLL_PAGE_DOWN:
1393 case REQ_SCROLL_PAGE_UP:
1394 scroll_view(view, request);
1401 case REQ_VIEW_PAGER:
1402 open_view(view, request, OPEN_DEFAULT);
1407 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1409 if (view == VIEW(REQ_VIEW_DIFF) &&
1410 view->parent == VIEW(REQ_VIEW_MAIN)) {
1411 bool redraw = display[1] == view;
1413 view = view->parent;
1414 move_view(view, request, redraw);
1416 update_view_title(view);
1418 move_view(view, request, TRUE);
1425 report("Nothing to enter");
1428 return view->ops->enter(view, &view->line[view->lineno]);
1432 int nviews = displayed_views();
1433 int next_view = (current_view + 1) % nviews;
1435 if (next_view == current_view) {
1436 report("Only one view is displayed");
1440 current_view = next_view;
1441 /* Blur out the title of the previous view. */
1442 update_view_title(view);
1446 case REQ_TOGGLE_LINE_NUMBERS:
1447 opt_line_number = !opt_line_number;
1452 /* Always reload^Wrerun commands from the prompt. */
1453 open_view(view, opt_request, OPEN_RELOAD);
1456 case REQ_STOP_LOADING:
1457 foreach_view (view, i) {
1459 report("Stopped loaded the %s view", view->name),
1464 case REQ_SHOW_VERSION:
1465 report("%s (built %s)", VERSION, __DATE__);
1468 case REQ_SCREEN_RESIZE:
1471 case REQ_SCREEN_REDRAW:
1475 case REQ_SCREEN_UPDATE:
1479 case REQ_VIEW_CLOSE:
1481 memset(display, 0, sizeof(display));
1483 display[current_view] = view->parent;
1484 view->parent = NULL;
1494 /* An unknown key will show most commonly used commands. */
1495 report("Unknown key, press 'h' for help");
1508 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1510 char *text = line->data;
1511 enum line_type type = line->type;
1512 int textlen = strlen(text);
1515 wmove(view->win, lineno, 0);
1517 if (view->offset + lineno == view->lineno) {
1518 if (type == LINE_COMMIT) {
1519 string_copy(view->ref, text + 7);
1520 string_copy(ref_commit, view->ref);
1524 wchgat(view->win, -1, 0, type, NULL);
1527 attr = get_line_attr(type);
1528 wattrset(view->win, attr);
1530 if (opt_line_number || opt_tab_size < TABSIZE) {
1531 static char spaces[] = " ";
1532 int col_offset = 0, col = 0;
1534 if (opt_line_number) {
1535 unsigned long real_lineno = view->offset + lineno + 1;
1537 if (real_lineno == 1 ||
1538 (real_lineno % opt_num_interval) == 0) {
1539 wprintw(view->win, "%.*d", view->digits, real_lineno);
1542 waddnstr(view->win, spaces,
1543 MIN(view->digits, STRING_SIZE(spaces)));
1545 waddstr(view->win, ": ");
1546 col_offset = view->digits + 2;
1549 while (text && col_offset + col < view->width) {
1550 int cols_max = view->width - col_offset - col;
1554 if (*text == '\t') {
1556 assert(sizeof(spaces) > TABSIZE);
1558 cols = opt_tab_size - (col % opt_tab_size);
1561 text = strchr(text, '\t');
1562 cols = line ? text - pos : strlen(pos);
1565 waddnstr(view->win, pos, MIN(cols, cols_max));
1570 int col = 0, pos = 0;
1572 for (; pos < textlen && col < view->width; pos++, col++)
1573 if (text[pos] == '\t')
1574 col += TABSIZE - (col % TABSIZE) - 1;
1576 waddnstr(view->win, text, pos);
1583 pager_read(struct view *view, struct line *prev, char *line)
1585 /* Compress empty lines in the help view. */
1586 if (view == VIEW(REQ_VIEW_HELP) &&
1587 !*line && prev && !*((char *) prev->data))
1590 view->line[view->lines].data = strdup(line);
1591 if (!view->line[view->lines].data)
1594 view->line[view->lines].type = get_line_type(line);
1601 pager_enter(struct view *view, struct line *line)
1605 if (line->type == LINE_COMMIT &&
1606 (view == VIEW(REQ_VIEW_LOG) ||
1607 view == VIEW(REQ_VIEW_PAGER))) {
1608 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1612 /* Always scroll the view even if it was split. That way
1613 * you can use Enter to scroll through the log view and
1614 * split open each commit diff. */
1615 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1617 /* FIXME: A minor workaround. Scrolling the view will call report("")
1618 * but if we are scolling a non-current view this won't properly update
1619 * the view title. */
1621 update_view_title(view);
1626 static struct view_ops pager_ops = {
1639 char id[41]; /* SHA1 ID. */
1640 char title[75]; /* The first line of the commit message. */
1641 char author[75]; /* The author of the commit. */
1642 struct tm time; /* Date from the author ident. */
1643 struct ref **refs; /* Repository references; tags & branch heads. */
1647 main_draw(struct view *view, struct line *line, unsigned int lineno)
1649 char buf[DATE_COLS + 1];
1650 struct commit *commit = line->data;
1651 enum line_type type;
1657 if (!*commit->author)
1660 wmove(view->win, lineno, col);
1662 if (view->offset + lineno == view->lineno) {
1663 string_copy(view->ref, commit->id);
1664 string_copy(ref_commit, view->ref);
1666 wattrset(view->win, get_line_attr(type));
1667 wchgat(view->win, -1, 0, type, NULL);
1670 type = LINE_MAIN_COMMIT;
1671 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1674 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1675 waddnstr(view->win, buf, timelen);
1676 waddstr(view->win, " ");
1679 wmove(view->win, lineno, col);
1680 if (type != LINE_CURSOR)
1681 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1683 /* FIXME: Make this optional, and add i18n.commitEncoding support. */
1684 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1687 waddnstr(view->win, commit->author, authorlen);
1688 if (type != LINE_CURSOR)
1689 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1690 waddch(view->win, '~');
1692 waddstr(view->win, commit->author);
1696 if (type != LINE_CURSOR)
1697 wattrset(view->win, A_NORMAL);
1699 mvwaddch(view->win, lineno, col, ACS_LTEE);
1700 wmove(view->win, lineno, col + 2);
1707 if (type == LINE_CURSOR)
1709 else if (commit->refs[i]->tag)
1710 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1712 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1713 waddstr(view->win, "[");
1714 waddstr(view->win, commit->refs[i]->name);
1715 waddstr(view->win, "]");
1716 if (type != LINE_CURSOR)
1717 wattrset(view->win, A_NORMAL);
1718 waddstr(view->win, " ");
1719 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1720 } while (commit->refs[i++]->next);
1723 if (type != LINE_CURSOR)
1724 wattrset(view->win, get_line_attr(type));
1727 int titlelen = strlen(commit->title);
1729 if (col + titlelen > view->width)
1730 titlelen = view->width - col;
1732 waddnstr(view->win, commit->title, titlelen);
1738 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1740 main_read(struct view *view, struct line *prev, char *line)
1742 enum line_type type = get_line_type(line);
1743 struct commit *commit;
1747 commit = calloc(1, sizeof(struct commit));
1751 line += STRING_SIZE("commit ");
1753 view->line[view->lines++].data = commit;
1754 string_copy(commit->id, line);
1755 commit->refs = get_refs(commit->id);
1760 char *ident = line + STRING_SIZE("author ");
1761 char *end = strchr(ident, '<');
1766 commit = prev->data;
1769 for (; end > ident && isspace(end[-1]); end--) ;
1773 string_copy(commit->author, ident);
1775 /* Parse epoch and timezone */
1777 char *secs = strchr(end + 1, '>');
1781 if (!secs || secs[1] != ' ')
1785 time = (time_t) atol(secs);
1786 zone = strchr(secs, ' ');
1787 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1791 tz = ('0' - zone[1]) * 60 * 60 * 10;
1792 tz += ('0' - zone[2]) * 60 * 60;
1793 tz += ('0' - zone[3]) * 60;
1794 tz += ('0' - zone[4]) * 60;
1801 gmtime_r(&time, &commit->time);
1809 commit = prev->data;
1811 /* Fill in the commit title if it has not already been set. */
1812 if (commit->title[0])
1815 /* Require titles to start with a non-space character at the
1816 * offset used by git log. */
1817 /* FIXME: More gracefull handling of titles; append "..." to
1818 * shortened titles, etc. */
1819 if (strncmp(line, " ", 4) ||
1823 string_copy(commit->title, line + 4);
1830 main_enter(struct view *view, struct line *line)
1832 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
1834 open_view(view, REQ_VIEW_DIFF, flags);
1838 static struct view_ops main_ops = {
1849 * Below the default key bindings are shown.
1857 static struct keymap keymap[] = {
1862 * Switch to main view.
1864 * Switch to diff view.
1866 * Switch to log view.
1868 * Switch to pager view.
1872 { 'm', REQ_VIEW_MAIN },
1873 { 'd', REQ_VIEW_DIFF },
1874 { 'l', REQ_VIEW_LOG },
1875 { 'p', REQ_VIEW_PAGER },
1876 { 'h', REQ_VIEW_HELP },
1882 * Close view, if multiple views are open it will jump back to the
1883 * previous view in the view stack. If it is the last open view it
1884 * will quit. Use 'Q' to quit all views at once.
1886 * This key is "context sensitive" depending on what view you are
1887 * currently in. When in log view on a commit line or in the main
1888 * view, split the view and show the commit diff. In the diff view
1889 * pressing Enter will simply scroll the view one line down.
1891 * Switch to next view.
1893 * This key is "context sensitive" and will move the cursor one
1894 * line up. However, uf you opened a diff view from the main view
1895 * (split- or full-screen) it will change the cursor to point to
1896 * the previous commit in the main view and update the diff view
1899 * Similar to 'Up' but will move down.
1901 { 'q', REQ_VIEW_CLOSE },
1902 { KEY_TAB, REQ_VIEW_NEXT },
1903 { KEY_RETURN, REQ_ENTER },
1904 { KEY_UP, REQ_PREVIOUS },
1905 { KEY_DOWN, REQ_NEXT },
1911 * Move cursor one line up.
1913 * Move cursor one line down.
1917 * Move cursor one page up.
1920 * Move cursor one page down.
1922 * Jump to first line.
1924 * Jump to last line.
1926 { 'k', REQ_MOVE_UP },
1927 { 'j', REQ_MOVE_DOWN },
1928 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1929 { KEY_END, REQ_MOVE_LAST_LINE },
1930 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1931 { ' ', REQ_MOVE_PAGE_DOWN },
1932 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1933 { 'b', REQ_MOVE_PAGE_UP },
1934 { '-', REQ_MOVE_PAGE_UP },
1940 * Scroll view one line up.
1942 * Scroll view one line down.
1944 * Scroll view one page up.
1946 * Scroll view one page down.
1948 { KEY_IC, REQ_SCROLL_LINE_UP },
1949 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1950 { 'w', REQ_SCROLL_PAGE_UP },
1951 { 's', REQ_SCROLL_PAGE_DOWN },
1961 * Stop all background loading. This can be useful if you use
1962 * tig(1) in a repository with a long history without limiting
1967 * Toggle line numbers on/off.
1969 * Open prompt. This allows you to specify what git command
1975 { 'z', REQ_STOP_LOADING },
1976 { 'v', REQ_SHOW_VERSION },
1977 { 'r', REQ_SCREEN_REDRAW },
1978 { 'n', REQ_TOGGLE_LINE_NUMBERS },
1979 { ':', REQ_PROMPT },
1981 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1982 { ERR, REQ_SCREEN_UPDATE },
1984 /* Use the ncurses SIGWINCH handler. */
1985 { KEY_RESIZE, REQ_SCREEN_RESIZE },
1989 get_request(int key)
1993 for (i = 0; i < ARRAY_SIZE(keymap); i++)
1994 if (keymap[i].alias == key)
1995 return keymap[i].request;
1997 return (enum request) key;
2002 * Unicode / UTF-8 handling
2004 * NOTE: Much of the following code for dealing with unicode is derived from
2005 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2006 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2009 /* I've (over)annotated a lot of code snippets because I am not entirely
2010 * confident that the approach taken by this small UTF-8 interface is correct.
2014 unicode_width(unsigned long c)
2017 (c <= 0x115f /* Hangul Jamo */
2020 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2022 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2023 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2024 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2025 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2026 || (c >= 0xffe0 && c <= 0xffe6)
2027 || (c >= 0x20000 && c <= 0x2fffd)
2028 || (c >= 0x30000 && c <= 0x3fffd)))
2034 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2035 * Illegal bytes are set one. */
2036 static const unsigned char utf8_bytes[256] = {
2037 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2038 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2039 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2040 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2041 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2042 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2043 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,
2044 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,
2047 /* Decode UTF-8 multi-byte representation into a unicode character. */
2048 static inline unsigned long
2049 utf8_to_unicode(const char *string, size_t length)
2051 unsigned long unicode;
2055 unicode = string[0];
2058 unicode = (string[0] & 0x1f) << 6;
2059 unicode += (string[1] & 0x3f);
2062 unicode = (string[0] & 0x0f) << 12;
2063 unicode += ((string[1] & 0x3f) << 6);
2064 unicode += (string[2] & 0x3f);
2067 unicode = (string[0] & 0x0f) << 18;
2068 unicode += ((string[1] & 0x3f) << 12);
2069 unicode += ((string[2] & 0x3f) << 6);
2070 unicode += (string[3] & 0x3f);
2073 unicode = (string[0] & 0x0f) << 24;
2074 unicode += ((string[1] & 0x3f) << 18);
2075 unicode += ((string[2] & 0x3f) << 12);
2076 unicode += ((string[3] & 0x3f) << 6);
2077 unicode += (string[4] & 0x3f);
2080 unicode = (string[0] & 0x01) << 30;
2081 unicode += ((string[1] & 0x3f) << 24);
2082 unicode += ((string[2] & 0x3f) << 18);
2083 unicode += ((string[3] & 0x3f) << 12);
2084 unicode += ((string[4] & 0x3f) << 6);
2085 unicode += (string[5] & 0x3f);
2088 die("Invalid unicode length");
2091 /* Invalid characters could return the special 0xfffd value but NUL
2092 * should be just as good. */
2093 return unicode > 0xffff ? 0 : unicode;
2096 /* Calculates how much of string can be shown within the given maximum width
2097 * and sets trimmed parameter to non-zero value if all of string could not be
2100 * Additionally, adds to coloffset how many many columns to move to align with
2101 * the expected position. Takes into account how multi-byte and double-width
2102 * characters will effect the cursor position.
2104 * Returns the number of bytes to output from string to satisfy max_width. */
2106 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2108 const char *start = string;
2109 const char *end = strchr(string, '\0');
2115 while (string < end) {
2116 int c = *(unsigned char *) string;
2117 unsigned char bytes = utf8_bytes[c];
2119 unsigned long unicode;
2121 if (string + bytes > end)
2124 /* Change representation to figure out whether
2125 * it is a single- or double-width character. */
2127 unicode = utf8_to_unicode(string, bytes);
2128 /* FIXME: Graceful handling of invalid unicode character. */
2132 ucwidth = unicode_width(unicode);
2134 if (width > max_width) {
2139 /* The column offset collects the differences between the
2140 * number of bytes encoding a character and the number of
2141 * columns will be used for rendering said character.
2143 * So if some character A is encoded in 2 bytes, but will be
2144 * represented on the screen using only 1 byte this will and up
2145 * adding 1 to the multi-byte column offset.
2147 * Assumes that no double-width character can be encoding in
2148 * less than two bytes. */
2149 if (bytes > ucwidth)
2150 mbwidth += bytes - ucwidth;
2155 *coloffset += mbwidth;
2157 return string - start;
2165 /* Whether or not the curses interface has been initialized. */
2166 static bool cursed = FALSE;
2168 /* The status window is used for polling keystrokes. */
2169 static WINDOW *status_win;
2171 /* Update status and title window. */
2173 report(const char *msg, ...)
2175 static bool empty = TRUE;
2176 struct view *view = display[current_view];
2178 if (!empty || *msg) {
2181 va_start(args, msg);
2184 wmove(status_win, 0, 0);
2186 vwprintw(status_win, msg, args);
2191 wrefresh(status_win);
2196 update_view_title(view);
2198 /* Move the cursor to the right-most column of the cursor line.
2200 * XXX: This could turn out to be a bit expensive, but it ensures that
2201 * the cursor does not jump around. */
2203 wmove(view->win, view->lineno - view->offset, view->width - 1);
2204 wrefresh(view->win);
2208 /* Controls when nodelay should be in effect when polling user input. */
2210 set_nonblocking_input(bool loading)
2212 static unsigned int loading_views;
2214 if ((loading == FALSE && loading_views-- == 1) ||
2215 (loading == TRUE && loading_views++ == 0))
2216 nodelay(status_win, loading);
2224 /* Initialize the curses library */
2225 if (isatty(STDIN_FILENO)) {
2226 cursed = !!initscr();
2228 /* Leave stdin and stdout alone when acting as a pager. */
2229 FILE *io = fopen("/dev/tty", "r+");
2231 cursed = !!newterm(NULL, io, io);
2235 die("Failed to initialize curses");
2237 nonl(); /* Tell curses not to do NL->CR/NL on output */
2238 cbreak(); /* Take input chars one at a time, no wait for \n */
2239 noecho(); /* Don't echo input */
2240 leaveok(stdscr, TRUE);
2245 getmaxyx(stdscr, y, x);
2246 status_win = newwin(1, 0, y - 1, 0);
2248 die("Failed to create status window");
2250 /* Enable keyboard mapping */
2251 keypad(status_win, TRUE);
2252 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2257 * Repository references
2260 static struct ref *refs;
2261 static size_t refs_size;
2263 /* Id <-> ref store */
2264 static struct ref ***id_refs;
2265 static size_t id_refs_size;
2267 static struct ref **
2270 struct ref ***tmp_id_refs;
2271 struct ref **ref_list = NULL;
2272 size_t ref_list_size = 0;
2275 for (i = 0; i < id_refs_size; i++)
2276 if (!strcmp(id, id_refs[i][0]->id))
2279 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2283 id_refs = tmp_id_refs;
2285 for (i = 0; i < refs_size; i++) {
2288 if (strcmp(id, refs[i].id))
2291 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2299 if (ref_list_size > 0)
2300 ref_list[ref_list_size - 1]->next = 1;
2301 ref_list[ref_list_size] = &refs[i];
2303 /* XXX: The properties of the commit chains ensures that we can
2304 * safely modify the shared ref. The repo references will
2305 * always be similar for the same id. */
2306 ref_list[ref_list_size]->next = 0;
2311 id_refs[id_refs_size++] = ref_list;
2319 const char *cmd_env = getenv("TIG_LS_REMOTE");
2320 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2321 FILE *pipe = popen(cmd, "r");
2322 char buffer[BUFSIZ];
2328 while ((line = fgets(buffer, sizeof(buffer), pipe))) {
2329 char *name = strchr(line, '\t');
2333 bool tag_commit = FALSE;
2339 namelen = strlen(name) - 1;
2341 /* Commits referenced by tags has "^{}" appended. */
2342 if (name[namelen - 1] == '}') {
2343 while (namelen > 0 && name[namelen] != '^')
2350 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2353 name += STRING_SIZE("refs/tags/");
2356 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2357 name += STRING_SIZE("refs/heads/");
2359 } else if (!strcmp(name, "HEAD")) {
2363 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2367 ref = &refs[refs_size++];
2369 ref->name = strdup(name);
2373 string_copy(ref->id, line);
2389 #define __NORETURN __attribute__((__noreturn__))
2394 static void __NORETURN
2397 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2403 static void __NORETURN
2404 die(const char *err, ...)
2410 va_start(args, err);
2411 fputs("tig: ", stderr);
2412 vfprintf(stderr, err, args);
2413 fputs("\n", stderr);
2420 main(int argc, char *argv[])
2423 enum request request;
2426 signal(SIGINT, quit);
2428 if (!parse_options(argc, argv))
2431 if (load_refs() == ERR)
2432 die("Failed to load refs.");
2434 /* Require a git repository unless when running in pager mode. */
2435 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2436 die("Not a git repository");
2438 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2439 view->cmd_env = getenv(view->cmd_env);
2441 request = opt_request;
2445 while (view_driver(display[current_view], request)) {
2449 foreach_view (view, i)
2452 /* Refresh, accept single keystroke of input */
2453 key = wgetch(status_win);
2454 request = get_request(key);
2456 /* Some low-level request handling. This keeps access to
2457 * status_win restricted. */
2461 /* Temporarily switch to line-oriented and echoed
2466 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2467 memcpy(opt_cmd, "git ", 4);
2468 opt_request = REQ_VIEW_PAGER;
2477 case REQ_SCREEN_RESIZE:
2481 getmaxyx(stdscr, height, width);
2483 /* Resize the status view and let the view driver take
2484 * care of resizing the displayed views. */
2485 wresize(status_win, 1, width);
2486 mvwin(status_win, height - 1, 0);
2487 wrefresh(status_win);
2502 * Revision specification
2503 * ----------------------
2504 * This section describes various ways to specify what revisions to display
2505 * or otherwise limit the view to. tig(1) does not itself parse the described
2506 * revision options so refer to the relevant git man pages for futher
2507 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2510 * You can tune the interaction with git by making use of the options
2511 * explained in this section. For example, by configuring the environment
2512 * variables described in the <<view-commands, "View commands">> section.
2514 * Limit by path name
2515 * ~~~~~~~~~~~~~~~~~~
2516 * If you are interested only in those revisions that made changes to a
2517 * specific file (or even several files) list the files like this:
2519 * $ tig log Makefile README
2521 * To avoid ambiguity with repository references such as tag name, be sure
2522 * to separate file names from other git options using "\--". So if you
2523 * have a file named 'master' it will clash with the reference named
2524 * 'master', and thus you will have to use:
2526 * $ tig log -- master
2528 * NOTE: For the main view, avoiding ambiguity will in some cases require
2529 * you to specify two "\--" options. The first will make tig(1) stop
2530 * option processing and the latter will be passed to git log.
2532 * Limit by date or number
2533 * ~~~~~~~~~~~~~~~~~~~~~~~
2534 * To speed up interaction with git, you can limit the amount of commits
2535 * to show both for the log and main view. Either limit by date using
2536 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2538 * If you are only interested in changed that happened between two dates
2541 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2543 * NOTE: If you want to avoid having to quote dates containing spaces you
2544 * can use "." instead, e.g. `--after=May.5th`.
2546 * Limiting by commit ranges
2547 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2548 * Alternatively, commits can be limited to a specific range, such as
2549 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2551 * $ tig log tag-1.0..tag-2.0
2553 * This way of commit limiting makes it trivial to only browse the commits
2554 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2555 * upstream remote branch, using:
2557 * $ tig log origin..HEAD
2559 * will list what will be pushed to the remote branch. Optionally, the ending
2560 * 'HEAD' can be left out since it is implied.
2562 * Limiting by reachability
2563 * ~~~~~~~~~~~~~~~~~~~~~~~~
2564 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2565 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2566 * Where reachability refers to what commits are ancestors (or part of the
2567 * history) of the branch or tagged revision in question.
2569 * If you prefer to specify which commit to preview in this way use the
2572 * $ tig log tag-2.0 ^tag-1.0
2574 * You can think of '^' as a negation operator. Using this alternate syntax,
2575 * it is possible to further prune commits by specifying multiple branch
2578 * Combining revisions specification
2579 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2580 * Revisions options can to some degree be combined, which makes it possible
2581 * to say "show at most 20 commits from within the last month that changed
2582 * files under the Documentation/ directory."
2584 * $ tig -- --since=1.month -n20 -- Documentation/
2586 * Examining all repository references
2587 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2588 * In some cases, it can be useful to query changes across all references
2589 * in a repository. An example is to ask "did any line of development in
2590 * this repository change a particular file within the last week". This
2591 * can be accomplished using:
2593 * $ tig -- --all --since=1.week -- Makefile
2597 * Known bugs and problems:
2599 * - In it's current state tig is pretty much UTF-8 only.
2601 * - If the screen width is very small the main view can draw
2602 * outside the current view causing bad wrapping. Same goes
2603 * for title and status windows.
2605 * - The cursor can wrap-around on the last line and cause the
2610 * Features that should be explored.
2618 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2620 * This program is free software; you can redistribute it and/or modify
2621 * it under the terms of the GNU General Public License as published by
2622 * the Free Software Foundation; either version 2 of the License, or
2623 * (at your option) any later version.
2628 * link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2629 * link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2630 * gitk(1): git repository browser written using tcl/tk,
2631 * qgit(1): git repository browser written using c++/Qt,
2632 * gitview(1): git repository browser written using python/gtk.