1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2 * See license info at the bottom. */
9 * tig - text-mode interface for git
15 * tig [options] [--] [git log options]
16 * tig [options] log [git log options]
17 * tig [options] diff [git diff options]
18 * tig [options] show [git show options]
19 * tig [options] < [git command output]
23 * Browse changes in a git repository. Additionally, tig(1) can also act
24 * as a pager for output of various git commands.
26 * When browsing repositories, tig(1) uses the underlying git commands
27 * to present the user with various views, such as summarized commit log
28 * and showing the commit with the log message, diffstat, and the diff.
30 * Using tig(1) as a pager, it will display input from stdin and try
35 #define VERSION "tig-0.3"
55 static void die(const char *err
, ...);
56 static void report(const char *msg
, ...);
57 static void set_nonblocking_input(bool loading
);
58 static size_t utf8_length(const char *string
, size_t max_width
, int *coloffset
, int *trimmed
);
60 #define ABS(x) ((x) >= 0 ? (x) : -(x))
61 #define MIN(x, y) ((x) < (y) ? (x) : (y))
63 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
64 #define STRING_SIZE(x) (sizeof(x) - 1)
66 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
67 #define SIZEOF_CMD 1024 /* Size of command buffer. */
69 /* This color name can be used to refer to the default term colors. */
70 #define COLOR_DEFAULT (-1)
72 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
74 /* The format and size of the date column in the main view. */
75 #define DATE_FORMAT "%Y-%m-%d %H:%M"
76 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
78 #define AUTHOR_COLS 20
80 /* The default interval between line numbers. */
81 #define NUMBER_INTERVAL 1
85 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
87 /* Some ascii-shorthands fitted into the ncurses namespace. */
89 #define KEY_RETURN '\r'
93 /* User action requests. */
95 /* Offset all requests to avoid conflicts with ncurses getch values. */
96 REQ_OFFSET
= KEY_MAX
+ 1,
98 /* XXX: Keep the view request first and in sync with views[]. */
113 REQ_TOGGLE_LINE_NUMBERS
,
127 REQ_SCROLL_LINE_DOWN
,
129 REQ_SCROLL_PAGE_DOWN
,
133 char *name
; /* Ref name; tag or head names are shortened. */
134 char id
[41]; /* Commit SHA1 ID */
135 unsigned int tag
:1; /* Is it a tag? */
136 unsigned int next
:1; /* For ref lists: are there more refs? */
139 static struct ref
**get_refs(char *id
);
147 string_ncopy(char *dst
, const char *src
, int dstlen
)
149 strncpy(dst
, src
, dstlen
- 1);
154 /* Shorthand for safely copying into a fixed buffer. */
155 #define string_copy(dst, src) \
156 string_ncopy(dst, src, sizeof(dst))
161 * NOTE: The following is a slightly modified copy of the git project's shell
162 * quoting routines found in the quote.c file.
164 * Help to copy the thing properly quoted for the shell safety. any single
165 * quote is replaced with '\'', any exclamation point is replaced with '\!',
166 * and the whole thing is enclosed in a
169 * original sq_quote result
170 * name ==> name ==> 'name'
171 * a b ==> a b ==> 'a b'
172 * a'b ==> a'\''b ==> 'a'\''b'
173 * a!b ==> a'\!'b ==> 'a'\!'b'
177 sq_quote(char buf
[SIZEOF_CMD
], size_t bufsize
, const char *src
)
181 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
184 while ((c
= *src
++)) {
185 if (c
== '\'' || c
== '!') {
205 static const char usage
[] =
206 VERSION
" (" __DATE__
")\n"
208 "Usage: tig [options]\n"
209 " or: tig [options] [--] [git log options]\n"
210 " or: tig [options] log [git log options]\n"
211 " or: tig [options] diff [git diff options]\n"
212 " or: tig [options] show [git show options]\n"
213 " or: tig [options] < [git command output]\n"
216 " -l Start up in log view\n"
217 " -d Start up in diff view\n"
218 " -n[I], --line-number[=I] Show line numbers with given interval\n"
219 " -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
220 " -- Mark end of tig options\n"
221 " -v, --version Show version and exit\n"
222 " -h, --help Show help message and exit\n";
224 /* Option and state variables. */
225 static bool opt_line_number
= FALSE
;
226 static int opt_num_interval
= NUMBER_INTERVAL
;
227 static int opt_tab_size
= TABSIZE
;
228 static enum request opt_request
= REQ_VIEW_MAIN
;
229 static char opt_cmd
[SIZEOF_CMD
] = "";
230 static FILE *opt_pipe
= NULL
;
232 /* Returns the index of log or diff command or -1 to exit. */
234 parse_options(int argc
, char *argv
[])
238 for (i
= 1; i
< argc
; i
++) {
243 * Start up in log view using the internal log command.
245 if (!strcmp(opt
, "-l")) {
246 opt_request
= REQ_VIEW_LOG
;
252 * Start up in diff view using the internal diff command.
254 if (!strcmp(opt
, "-d")) {
255 opt_request
= REQ_VIEW_DIFF
;
260 * -n[INTERVAL], --line-number[=INTERVAL]::
261 * Prefix line numbers in log and diff view.
262 * Optionally, with interval different than each line.
264 if (!strncmp(opt
, "-n", 2) ||
265 !strncmp(opt
, "--line-number", 13)) {
271 } else if (opt
[STRING_SIZE("--line-number")] == '=') {
272 num
= opt
+ STRING_SIZE("--line-number=");
276 opt_num_interval
= atoi(num
);
278 opt_line_number
= TRUE
;
283 * -t[NSPACES], --tab-size[=NSPACES]::
284 * Set the number of spaces tabs should be expanded to.
286 if (!strncmp(opt
, "-t", 2) ||
287 !strncmp(opt
, "--tab-size", 10)) {
293 } else if (opt
[STRING_SIZE("--tab-size")] == '=') {
294 num
= opt
+ STRING_SIZE("--tab-size=");
298 opt_tab_size
= MIN(atoi(num
), TABSIZE
);
304 * Show version and exit.
306 if (!strcmp(opt
, "-v") ||
307 !strcmp(opt
, "--version")) {
308 printf("tig version %s\n", VERSION
);
314 * Show help message and exit.
316 if (!strcmp(opt
, "-h") ||
317 !strcmp(opt
, "--help")) {
324 * End of tig(1) options. Useful when specifying command
325 * options for the main view. Example:
327 * $ tig -- --since=1.month
329 if (!strcmp(opt
, "--")) {
335 * log [git log options]::
336 * Open log view using the given git log options.
338 * diff [git diff options]::
339 * Open diff view using the given git diff options.
341 * show [git show options]::
342 * Open diff view using the given git show options.
344 if (!strcmp(opt
, "log") ||
345 !strcmp(opt
, "diff") ||
346 !strcmp(opt
, "show")) {
347 opt_request
= opt
[0] == 'l'
348 ? REQ_VIEW_LOG
: REQ_VIEW_DIFF
;
353 * [git log options]::
354 * tig(1) will stop the option parsing when the first
355 * command line parameter not starting with "-" is
356 * encountered. All options including this one will be
357 * passed to git log when loading the main view.
358 * This makes it possible to say:
360 * $ tig tag-1.0..HEAD
362 if (opt
[0] && opt
[0] != '-')
365 die("unknown command '%s'", opt
);
368 if (!isatty(STDIN_FILENO
)) {
372 * If stdin is a pipe, any log or diff options will be ignored and the
373 * pager view will be opened loading data from stdin. The pager mode
374 * can be used for colorizing output from various git commands.
376 * Example on how to colorize the output of git-show(1):
380 opt_request
= REQ_VIEW_PAGER
;
383 } else if (i
< argc
) {
387 * Git command options
388 * ~~~~~~~~~~~~~~~~~~~
389 * All git command options specified on the command line will
390 * be passed to the given command and all will be shell quoted
391 * before they are passed to the shell.
393 * NOTE: If you specify options for the main view, you should
394 * not use the `--pretty` option as this option will be set
395 * automatically to the format expected by the main view.
397 * Example on how to open the log view and show both author and
398 * committer information:
400 * $ tig log --pretty=fuller
402 * See the <<refspec, "Specifying revisions">> section below
403 * for an introduction to revision options supported by the git
404 * commands. For details on specific git command options, refer
405 * to the man page of the command in question.
408 if (opt_request
== REQ_VIEW_MAIN
)
409 /* XXX: This is vulnerable to the user overriding
410 * options required for the main view parser. */
411 string_copy(opt_cmd
, "git log --stat --pretty=raw");
413 string_copy(opt_cmd
, "git");
414 buf_size
= strlen(opt_cmd
);
416 while (buf_size
< sizeof(opt_cmd
) && i
< argc
) {
417 opt_cmd
[buf_size
++] = ' ';
418 buf_size
= sq_quote(opt_cmd
, buf_size
, argv
[i
++]);
421 if (buf_size
>= sizeof(opt_cmd
))
422 die("command too long");
424 opt_cmd
[buf_size
] = 0;
433 * Line-oriented content detection.
437 /* Line type String to match Foreground Background Attributes
438 * --------- --------------- ---------- ---------- ---------- */ \
440 LINE(DIFF, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
441 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
442 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
443 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
444 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
445 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
446 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
447 LINE(DIFF_COPY, "copy ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
448 LINE(DIFF_RENAME, "rename ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
449 LINE(DIFF_SIM, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
450 LINE(DIFF_DISSIM, "dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
451 /* Pretty print commit header */ \
452 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
453 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
454 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
455 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
456 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
457 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
458 /* Raw commit header */ \
459 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
460 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
461 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
462 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
463 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
465 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
466 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
468 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
469 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
470 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
471 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
472 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
473 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
474 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
475 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
476 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
477 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
478 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD),
481 #define LINE(type, line, fg, bg, attr) \
488 const char *line
; /* The start of line to match. */
489 int linelen
; /* Size of string to match. */
490 int fg
, bg
, attr
; /* Color and text attributes for the lines. */
493 static struct line_info line_info
[] = {
494 #define LINE(type, line, fg, bg, attr) \
495 { (line), STRING_SIZE(line), (fg), (bg), (attr) }
500 static enum line_type
501 get_line_type(char *line
)
503 int linelen
= strlen(line
);
506 for (type
= 0; type
< ARRAY_SIZE(line_info
); type
++)
507 /* Case insensitive search matches Signed-off-by lines better. */
508 if (linelen
>= line_info
[type
].linelen
&&
509 !strncasecmp(line_info
[type
].line
, line
, line_info
[type
].linelen
))
516 get_line_attr(enum line_type type
)
518 assert(type
< ARRAY_SIZE(line_info
));
519 return COLOR_PAIR(type
) | line_info
[type
].attr
;
525 int default_bg
= COLOR_BLACK
;
526 int default_fg
= COLOR_WHITE
;
531 if (use_default_colors() != ERR
) {
536 for (type
= 0; type
< ARRAY_SIZE(line_info
); type
++) {
537 struct line_info
*info
= &line_info
[type
];
538 int bg
= info
->bg
== COLOR_DEFAULT ? default_bg
: info
->bg
;
539 int fg
= info
->fg
== COLOR_DEFAULT ? default_fg
: info
->fg
;
541 init_pair(type
, fg
, bg
);
547 void *data
; /* User data */
552 * ENVIRONMENT VARIABLES
553 * ---------------------
554 * Several options related to the interface with git can be configured
555 * via environment options.
557 * Repository references
558 * ~~~~~~~~~~~~~~~~~~~~~
559 * Commits that are referenced by tags and branch heads will be marked
560 * by the reference name surrounded by '[' and ']':
562 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
564 * If you want to filter out certain directories under `.git/refs/`, say
565 * `tmp` you can do it by setting the following variable:
567 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
569 * Or set the variable permanently in your environment.
572 * Set command for retrieving all repository references. The command
573 * should output data in the same format as git-ls-remote(1).
576 #define TIG_LS_REMOTE \
577 "git ls-remote . 2>/dev/null"
583 * It is possible to alter which commands are used for the different views.
584 * If for example you prefer commits in the main view to be sorted by date
585 * and only show 500 commits, use:
587 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
589 * Or set the variable permanently in your environment.
591 * Notice, how `%s` is used to specify the commit reference. There can
592 * be a maximum of 5 `%s` ref specifications.
595 * The command used for the diff view. By default, git show is used
599 * The command used for the log view. If you prefer to have both
600 * author and committer shown in the log view be sure to pass
601 * `--pretty=fuller` to git log.
604 * The command used for the main view. Note, you must always specify
605 * the option: `--pretty=raw` since the main view parser expects to
609 #define TIG_DIFF_CMD \
610 "git show --patch-with-stat --find-copies-harder -B -C %s"
612 #define TIG_LOG_CMD \
613 "git log --cc --stat -n100 %s"
615 #define TIG_MAIN_CMD \
616 "git log --topo-order --stat --pretty=raw %s"
618 /* ... silently ignore that the following are also exported. */
620 #define TIG_HELP_CMD \
621 "man tig 2>/dev/null"
623 #define TIG_PAGER_CMD \
630 * The display consists of a status window on the last line of the screen and
631 * one or more views. The default is to only show one view at the time but it
632 * is possible to split both the main and log view to also show the commit
635 * If you are in the log view and press 'Enter' when the current line is a
636 * commit line, such as:
638 * commit 4d55caff4cc89335192f3e566004b4ceef572521
640 * You will split the view so that the log view is displayed in the top window
641 * and the diff view in the bottom window. You can switch between the two
642 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
648 /* The display array of active views and the index of the current view. */
649 static struct view
*display
[2];
650 static unsigned int current_view
;
652 #define foreach_view(view, i) \
653 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
655 #define displayed_views() (display[1] != NULL ? 2 : 1)
658 * Current head and commit ID
659 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
660 * The viewer keeps track of both what head and commit ID you are currently
661 * viewing. The commit ID will follow the cursor line and change everytime time
662 * you highlight a different commit. Whenever you reopen the diff view it
663 * will be reloaded, if the commit ID changed.
665 * The head ID is used when opening the main and log view to indicate from
666 * what revision to show history.
669 static char ref_commit
[SIZEOF_REF
] = "HEAD";
670 static char ref_head
[SIZEOF_REF
] = "HEAD";
673 const char *name
; /* View name */
674 const char *cmd_fmt
; /* Default command line format */
675 const char *cmd_env
; /* Command line set via environment */
676 const char *id
; /* Points to either of ref_{head,commit} */
678 struct view_ops
*ops
; /* View operations */
680 char cmd
[SIZEOF_CMD
]; /* Command buffer */
681 char ref
[SIZEOF_REF
]; /* Hovered commit reference */
682 char vid
[SIZEOF_REF
]; /* View ID. Set to id member when updating. */
684 int height
, width
; /* The width and height of the main window */
685 WINDOW
*win
; /* The main window */
686 WINDOW
*title
; /* The title window living below the main window */
689 unsigned long offset
; /* Offset of the window top */
690 unsigned long lineno
; /* Current line number */
692 /* If non-NULL, points to the view that opened this view. If this view
693 * is closed tig will switch back to the parent view. */
697 unsigned long lines
; /* Total number of lines */
698 struct line
*line
; /* Line index */
699 unsigned int digits
; /* Number of digits in the lines member. */
707 /* What type of content being displayed. Used in the title bar. */
709 /* Draw one line; @lineno must be < view->height. */
710 bool (*draw
)(struct view
*view
, struct line
*line
, unsigned int lineno
);
711 /* Read one line; updates view->line. */
712 bool (*read
)(struct view
*view
, struct line
*prev
, char *data
);
713 /* Depending on view, change display based on current line. */
714 bool (*enter
)(struct view
*view
, struct line
*line
);
717 static struct view_ops pager_ops
;
718 static struct view_ops main_ops
;
720 #define VIEW_STR(name, cmd, env, ref, ops) \
721 { name, cmd, #env, ref, ops }
723 #define VIEW_(id, name, ops, ref) \
724 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
729 * tig(1) presents various 'views' of a repository. Each view is based on output
730 * from an external command, most often 'git log', 'git diff', or 'git show'.
733 * Is the default view, and it shows a one line summary of each commit
734 * in the chosen list of revisions. The summary includes commit date,
735 * author, and the first line of the log message. Additionally, any
736 * repository references, such as tags, will be shown.
739 * Presents a more rich view of the revision log showing the whole log
740 * message and the diffstat.
743 * Shows either the diff of the current working tree, that is, what
744 * has changed since the last commit, or the commit diff complete
745 * with log message, diffstat and diff.
748 * Is used for displaying both input from stdin and output from git
749 * commands entered in the internal prompt.
752 * Displays the information from the tig(1) man page. For the help view
753 * to work you need to have the tig(1) man page installed.
756 static struct view views
[] = {
757 VIEW_(MAIN
, "main", &main_ops
, ref_head
),
758 VIEW_(DIFF
, "diff", &pager_ops
, ref_commit
),
759 VIEW_(LOG
, "log", &pager_ops
, ref_head
),
760 VIEW_(HELP
, "help", &pager_ops
, "static"),
761 VIEW_(PAGER
, "pager", &pager_ops
, "static"),
764 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
768 draw_view_line(struct view
*view
, unsigned int lineno
)
770 if (view
->offset
+ lineno
>= view
->lines
)
773 return view
->ops
->draw(view
, &view
->line
[view
->offset
+ lineno
], lineno
);
777 redraw_view_from(struct view
*view
, int lineno
)
779 assert(0 <= lineno
&& lineno
< view
->height
);
781 for (; lineno
< view
->height
; lineno
++) {
782 if (!draw_view_line(view
, lineno
))
786 redrawwin(view
->win
);
791 redraw_view(struct view
*view
)
794 redraw_view_from(view
, 0);
801 * Each view has a title window which shows the name of the view, current
802 * commit ID if available, and where the view is positioned:
804 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
806 * By default, the title of the current view is highlighted using bold font.
810 update_view_title(struct view
*view
)
812 if (view
== display
[current_view
])
813 wbkgdset(view
->title
, get_line_attr(LINE_TITLE_FOCUS
));
815 wbkgdset(view
->title
, get_line_attr(LINE_TITLE_BLUR
));
818 wmove(view
->title
, 0, 0);
821 wprintw(view
->title
, "[%s] %s", view
->name
, view
->ref
);
823 wprintw(view
->title
, "[%s]", view
->name
);
825 if (view
->lines
|| view
->pipe
) {
826 unsigned int lines
= view
->lines
827 ?
(view
->lineno
+ 1) * 100 / view
->lines
830 wprintw(view
->title
, " - %s %d of %d (%d%%)",
838 time_t secs
= time(NULL
) - view
->start_time
;
840 /* Three git seconds are a long time ... */
842 wprintw(view
->title
, " %lds", secs
);
846 wrefresh(view
->title
);
853 struct view
*base
= display
[0];
854 struct view
*view
= display
[1] ? display
[1] : display
[0];
856 /* Setup window dimensions */
858 getmaxyx(stdscr
, base
->height
, base
->width
);
860 /* Make room for the status window. */
864 /* Horizontal split. */
865 view
->width
= base
->width
;
866 view
->height
= SCALE_SPLIT_VIEW(base
->height
);
867 base
->height
-= view
->height
;
869 /* Make room for the title bar. */
873 /* Make room for the title bar. */
878 foreach_view (view
, i
) {
880 view
->win
= newwin(view
->height
, 0, offset
, 0);
882 die("Failed to create %s view", view
->name
);
884 scrollok(view
->win
, TRUE
);
886 view
->title
= newwin(1, 0, offset
+ view
->height
, 0);
888 die("Failed to create title window");
891 wresize(view
->win
, view
->height
, view
->width
);
892 mvwin(view
->win
, offset
, 0);
893 mvwin(view
->title
, offset
+ view
->height
, 0);
897 offset
+= view
->height
+ 1;
907 foreach_view (view
, i
) {
909 update_view_title(view
);
918 /* Scrolling backend */
920 do_scroll_view(struct view
*view
, int lines
, bool redraw
)
922 /* The rendering expects the new offset. */
923 view
->offset
+= lines
;
925 assert(0 <= view
->offset
&& view
->offset
< view
->lines
);
928 /* Redraw the whole screen if scrolling is pointless. */
929 if (view
->height
< ABS(lines
)) {
933 int line
= lines
> 0 ? view
->height
- lines
: 0;
934 int end
= line
+ ABS(lines
);
936 wscrl(view
->win
, lines
);
938 for (; line
< end
; line
++) {
939 if (!draw_view_line(view
, line
))
944 /* Move current line into the view. */
945 if (view
->lineno
< view
->offset
) {
946 view
->lineno
= view
->offset
;
947 draw_view_line(view
, 0);
949 } else if (view
->lineno
>= view
->offset
+ view
->height
) {
950 if (view
->lineno
== view
->offset
+ view
->height
) {
951 /* Clear the hidden line so it doesn't show if the view
953 wmove(view
->win
, view
->height
, 0);
954 wclrtoeol(view
->win
);
956 view
->lineno
= view
->offset
+ view
->height
- 1;
957 draw_view_line(view
, view
->lineno
- view
->offset
);
960 assert(view
->offset
<= view
->lineno
&& view
->lineno
< view
->lines
);
965 redrawwin(view
->win
);
970 /* Scroll frontend */
972 scroll_view(struct view
*view
, enum request request
)
977 case REQ_SCROLL_PAGE_DOWN
:
978 lines
= view
->height
;
979 case REQ_SCROLL_LINE_DOWN
:
980 if (view
->offset
+ lines
> view
->lines
)
981 lines
= view
->lines
- view
->offset
;
983 if (lines
== 0 || view
->offset
+ view
->height
>= view
->lines
) {
984 report("Cannot scroll beyond the last line");
989 case REQ_SCROLL_PAGE_UP
:
990 lines
= view
->height
;
991 case REQ_SCROLL_LINE_UP
:
992 if (lines
> view
->offset
)
993 lines
= view
->offset
;
996 report("Cannot scroll beyond the first line");
1004 die("request %d not handled in switch", request
);
1007 do_scroll_view(view
, lines
, TRUE
);
1012 move_view(struct view
*view
, enum request request
, bool redraw
)
1017 case REQ_MOVE_FIRST_LINE
:
1018 steps
= -view
->lineno
;
1021 case REQ_MOVE_LAST_LINE
:
1022 steps
= view
->lines
- view
->lineno
- 1;
1025 case REQ_MOVE_PAGE_UP
:
1026 steps
= view
->height
> view
->lineno
1027 ?
-view
->lineno
: -view
->height
;
1030 case REQ_MOVE_PAGE_DOWN
:
1031 steps
= view
->lineno
+ view
->height
>= view
->lines
1032 ? view
->lines
- view
->lineno
- 1 : view
->height
;
1044 die("request %d not handled in switch", request
);
1047 if (steps
<= 0 && view
->lineno
== 0) {
1048 report("Cannot move beyond the first line");
1051 } else if (steps
>= 0 && view
->lineno
+ 1 >= view
->lines
) {
1052 report("Cannot move beyond the last line");
1056 /* Move the current line */
1057 view
->lineno
+= steps
;
1058 assert(0 <= view
->lineno
&& view
->lineno
< view
->lines
);
1060 /* Repaint the old "current" line if we be scrolling */
1061 if (ABS(steps
) < view
->height
) {
1062 int prev_lineno
= view
->lineno
- steps
- view
->offset
;
1064 wmove(view
->win
, prev_lineno
, 0);
1065 wclrtoeol(view
->win
);
1066 draw_view_line(view
, prev_lineno
);
1069 /* Check whether the view needs to be scrolled */
1070 if (view
->lineno
< view
->offset
||
1071 view
->lineno
>= view
->offset
+ view
->height
) {
1072 if (steps
< 0 && -steps
> view
->offset
) {
1073 steps
= -view
->offset
;
1075 } else if (steps
> 0) {
1076 if (view
->lineno
== view
->lines
- 1 &&
1077 view
->lines
> view
->height
) {
1078 steps
= view
->lines
- view
->offset
- 1;
1079 if (steps
>= view
->height
)
1080 steps
-= view
->height
- 1;
1084 do_scroll_view(view
, steps
, redraw
);
1088 /* Draw the current line */
1089 draw_view_line(view
, view
->lineno
- view
->offset
);
1094 redrawwin(view
->win
);
1095 wrefresh(view
->win
);
1101 * Incremental updating
1105 end_update(struct view
*view
)
1109 set_nonblocking_input(FALSE
);
1110 if (view
->pipe
== stdin
)
1118 begin_update(struct view
*view
)
1120 const char *id
= view
->id
;
1126 string_copy(view
->cmd
, opt_cmd
);
1128 /* When running random commands, the view ref could have become
1129 * invalid so clear it. */
1132 const char *format
= view
->cmd_env ? view
->cmd_env
: view
->cmd_fmt
;
1134 if (snprintf(view
->cmd
, sizeof(view
->cmd
), format
,
1135 id
, id
, id
, id
, id
) >= sizeof(view
->cmd
))
1139 /* Special case for the pager view. */
1141 view
->pipe
= opt_pipe
;
1144 view
->pipe
= popen(view
->cmd
, "r");
1150 set_nonblocking_input(TRUE
);
1155 string_copy(view
->vid
, id
);
1160 for (i
= 0; i
< view
->lines
; i
++)
1161 if (view
->line
[i
].data
)
1162 free(view
->line
[i
].data
);
1168 view
->start_time
= time(NULL
);
1174 update_view(struct view
*view
)
1176 char buffer
[BUFSIZ
];
1179 /* The number of lines to read. If too low it will cause too much
1180 * redrawing (and possible flickering), if too high responsiveness
1182 unsigned long lines
= view
->height
;
1183 int redraw_from
= -1;
1188 /* Only redraw if lines are visible. */
1189 if (view
->offset
+ view
->height
>= view
->lines
)
1190 redraw_from
= view
->lines
- view
->offset
;
1192 tmp
= realloc(view
->line
, sizeof(*view
->line
) * (view
->lines
+ lines
));
1198 while ((line
= fgets(buffer
, sizeof(buffer
), view
->pipe
))) {
1199 int linelen
= strlen(line
);
1201 struct line
*prev
= view
->lines
1202 ?
&view
->line
[view
->lines
- 1]
1206 line
[linelen
- 1] = 0;
1208 if (!view
->ops
->read(view
, prev
, line
))
1218 lines
= view
->lines
;
1219 for (digits
= 0; lines
; digits
++)
1222 /* Keep the displayed view in sync with line number scaling. */
1223 if (digits
!= view
->digits
) {
1224 view
->digits
= digits
;
1229 if (redraw_from
>= 0) {
1230 /* If this is an incremental update, redraw the previous line
1231 * since for commits some members could have changed when
1232 * loading the main view. */
1233 if (redraw_from
> 0)
1236 /* Incrementally draw avoids flickering. */
1237 redraw_view_from(view
, redraw_from
);
1240 /* Update the title _after_ the redraw so that if the redraw picks up a
1241 * commit reference in view->ref it'll be available here. */
1242 update_view_title(view
);
1244 if (ferror(view
->pipe
)) {
1245 report("Failed to read: %s", strerror(errno
));
1248 } else if (feof(view
->pipe
)) {
1249 if (view
== VIEW(REQ_VIEW_HELP
)) {
1250 const char *msg
= TIG_HELP
;
1252 if (view
->lines
== 0) {
1253 /* Slightly ugly, but abusing view->ref keeps
1254 * the error message. */
1255 string_copy(view
->ref
, "No help available");
1256 msg
= "The tig(1) manpage is not installed";
1270 report("Allocation failure");
1278 OPEN_DEFAULT
= 0, /* Use default view switching. */
1279 OPEN_SPLIT
= 1, /* Split current view. */
1280 OPEN_BACKGROUNDED
= 2, /* Backgrounded. */
1281 OPEN_RELOAD
= 4, /* Reload view even if it is the current. */
1285 open_view(struct view
*prev
, enum request request
, enum open_flags flags
)
1287 bool backgrounded
= !!(flags
& OPEN_BACKGROUNDED
);
1288 bool split
= !!(flags
& OPEN_SPLIT
);
1289 bool reload
= !!(flags
& OPEN_RELOAD
);
1290 struct view
*view
= VIEW(request
);
1291 int nviews
= displayed_views();
1292 struct view
*base_view
= display
[0];
1294 if (view
== prev
&& nviews
== 1 && !reload
) {
1295 report("Already in %s view", view
->name
);
1299 if ((reload
|| strcmp(view
->vid
, view
->id
)) &&
1300 !begin_update(view
)) {
1301 report("Failed to load %s view", view
->name
);
1306 display
[current_view
+ 1] = view
;
1310 /* Maximize the current view. */
1311 memset(display
, 0, sizeof(display
));
1313 display
[current_view
] = view
;
1316 /* Resize the view when switching between split- and full-screen,
1317 * or when switching between two different full-screen views. */
1318 if (nviews
!= displayed_views() ||
1319 (nviews
== 1 && base_view
!= display
[0]))
1322 if (split
&& prev
->lineno
- prev
->offset
>= prev
->height
) {
1323 /* Take the title line into account. */
1324 int lines
= prev
->lineno
- prev
->offset
- prev
->height
+ 1;
1326 /* Scroll the view that was split if the current line is
1327 * outside the new limited view. */
1328 do_scroll_view(prev
, lines
, TRUE
);
1331 if (prev
&& view
!= prev
) {
1332 /* Continue loading split views in the background. */
1335 else if (!backgrounded
)
1336 /* "Blur" the previous view. */
1337 update_view_title(prev
);
1339 view
->parent
= prev
;
1343 /* Clear the old view and let the incremental updating refill
1349 if (view
== VIEW(REQ_VIEW_HELP
))
1350 report("%s", TIG_HELP
);
1355 /* If the view is backgrounded the above calls to report()
1356 * won't redraw the view title. */
1358 update_view_title(view
);
1363 * User request switch noodle
1367 view_driver(struct view
*view
, enum request request
)
1374 case REQ_MOVE_PAGE_UP
:
1375 case REQ_MOVE_PAGE_DOWN
:
1376 case REQ_MOVE_FIRST_LINE
:
1377 case REQ_MOVE_LAST_LINE
:
1378 move_view(view
, request
, TRUE
);
1381 case REQ_SCROLL_LINE_DOWN
:
1382 case REQ_SCROLL_LINE_UP
:
1383 case REQ_SCROLL_PAGE_DOWN
:
1384 case REQ_SCROLL_PAGE_UP
:
1385 scroll_view(view
, request
);
1392 case REQ_VIEW_PAGER
:
1393 open_view(view
, request
, OPEN_DEFAULT
);
1398 request
= request
== REQ_NEXT ? REQ_MOVE_DOWN
: REQ_MOVE_UP
;
1400 if (view
== VIEW(REQ_VIEW_DIFF
) &&
1401 view
->parent
== VIEW(REQ_VIEW_MAIN
)) {
1402 bool redraw
= display
[1] == view
;
1404 view
= view
->parent
;
1405 move_view(view
, request
, redraw
);
1407 update_view_title(view
);
1409 move_view(view
, request
, TRUE
);
1416 report("Nothing to enter");
1419 return view
->ops
->enter(view
, &view
->line
[view
->lineno
]);
1423 int nviews
= displayed_views();
1424 int next_view
= (current_view
+ 1) % nviews
;
1426 if (next_view
== current_view
) {
1427 report("Only one view is displayed");
1431 current_view
= next_view
;
1432 /* Blur out the title of the previous view. */
1433 update_view_title(view
);
1437 case REQ_TOGGLE_LINE_NUMBERS
:
1438 opt_line_number
= !opt_line_number
;
1443 /* Always reload^Wrerun commands from the prompt. */
1444 open_view(view
, opt_request
, OPEN_RELOAD
);
1447 case REQ_STOP_LOADING
:
1448 foreach_view (view
, i
) {
1450 report("Stopped loaded the %s view", view
->name
),
1455 case REQ_SHOW_VERSION
:
1456 report("%s (built %s)", VERSION
, __DATE__
);
1459 case REQ_SCREEN_RESIZE
:
1462 case REQ_SCREEN_REDRAW
:
1466 case REQ_SCREEN_UPDATE
:
1470 case REQ_VIEW_CLOSE
:
1472 memset(display
, 0, sizeof(display
));
1474 display
[current_view
] = view
->parent
;
1475 view
->parent
= NULL
;
1485 /* An unknown key will show most commonly used commands. */
1486 report("Unknown key, press 'h' for help");
1499 pager_draw(struct view
*view
, struct line
*line
, unsigned int lineno
)
1501 char *text
= line
->data
;
1502 enum line_type type
= line
->type
;
1503 int textlen
= strlen(text
);
1506 wmove(view
->win
, lineno
, 0);
1508 if (view
->offset
+ lineno
== view
->lineno
) {
1509 if (type
== LINE_COMMIT
) {
1510 string_copy(view
->ref
, text
+ 7);
1511 string_copy(ref_commit
, view
->ref
);
1515 wchgat(view
->win
, -1, 0, type
, NULL
);
1518 attr
= get_line_attr(type
);
1519 wattrset(view
->win
, attr
);
1521 if (opt_line_number
|| opt_tab_size
< TABSIZE
) {
1522 static char spaces
[] = " ";
1523 int col_offset
= 0, col
= 0;
1525 if (opt_line_number
) {
1526 unsigned long real_lineno
= view
->offset
+ lineno
+ 1;
1528 if (real_lineno
== 1 ||
1529 (real_lineno
% opt_num_interval
) == 0) {
1530 wprintw(view
->win
, "%.*d", view
->digits
, real_lineno
);
1533 waddnstr(view
->win
, spaces
,
1534 MIN(view
->digits
, STRING_SIZE(spaces
)));
1536 waddstr(view
->win
, ": ");
1537 col_offset
= view
->digits
+ 2;
1540 while (text
&& col_offset
+ col
< view
->width
) {
1541 int cols_max
= view
->width
- col_offset
- col
;
1545 if (*text
== '\t') {
1547 assert(sizeof(spaces
) > TABSIZE
);
1549 cols
= opt_tab_size
- (col
% opt_tab_size
);
1552 text
= strchr(text
, '\t');
1553 cols
= line ? text
- pos
: strlen(pos
);
1556 waddnstr(view
->win
, pos
, MIN(cols
, cols_max
));
1561 int col
= 0, pos
= 0;
1563 for (; pos
< textlen
&& col
< view
->width
; pos
++, col
++)
1564 if (text
[pos
] == '\t')
1565 col
+= TABSIZE
- (col
% TABSIZE
) - 1;
1567 waddnstr(view
->win
, text
, pos
);
1574 pager_read(struct view
*view
, struct line
*prev
, char *line
)
1576 /* Compress empty lines in the help view. */
1577 if (view
== VIEW(REQ_VIEW_HELP
) &&
1578 !*line
&& prev
&& !*((char *) prev
->data
))
1581 view
->line
[view
->lines
].data
= strdup(line
);
1582 if (!view
->line
[view
->lines
].data
)
1585 view
->line
[view
->lines
].type
= get_line_type(line
);
1592 pager_enter(struct view
*view
, struct line
*line
)
1596 if ((view
== VIEW(REQ_VIEW_LOG
) ||
1597 view
== VIEW(REQ_VIEW_PAGER
)) &&
1598 line
->type
== LINE_COMMIT
) {
1599 open_view(view
, REQ_VIEW_DIFF
, OPEN_SPLIT
);
1603 /* Always scroll the view even if it was split. That way
1604 * you can use Enter to scroll through the log view and
1605 * split open each commit diff. */
1606 scroll_view(view
, REQ_SCROLL_LINE_DOWN
);
1608 /* FIXME: A minor workaround. Scrolling the view will call report("")
1609 * but if we are scolling a non-current view this won't properly update
1610 * the view title. */
1612 update_view_title(view
);
1617 static struct view_ops pager_ops
= {
1630 char id
[41]; /* SHA1 ID. */
1631 char title
[75]; /* The first line of the commit message. */
1632 char author
[75]; /* The author of the commit. */
1633 struct tm time
; /* Date from the author ident. */
1634 struct ref
**refs
; /* Repository references; tags & branch heads. */
1638 main_draw(struct view
*view
, struct line
*line
, unsigned int lineno
)
1640 char buf
[DATE_COLS
+ 1];
1641 struct commit
*commit
= line
->data
;
1642 enum line_type type
;
1648 if (!*commit
->author
)
1651 wmove(view
->win
, lineno
, col
);
1653 if (view
->offset
+ lineno
== view
->lineno
) {
1654 string_copy(view
->ref
, commit
->id
);
1655 string_copy(ref_commit
, view
->ref
);
1657 wattrset(view
->win
, get_line_attr(type
));
1658 wchgat(view
->win
, -1, 0, type
, NULL
);
1661 type
= LINE_MAIN_COMMIT
;
1662 wattrset(view
->win
, get_line_attr(LINE_MAIN_DATE
));
1665 timelen
= strftime(buf
, sizeof(buf
), DATE_FORMAT
, &commit
->time
);
1666 waddnstr(view
->win
, buf
, timelen
);
1667 waddstr(view
->win
, " ");
1670 wmove(view
->win
, lineno
, col
);
1671 if (type
!= LINE_CURSOR
)
1672 wattrset(view
->win
, get_line_attr(LINE_MAIN_AUTHOR
));
1674 /* FIXME: Make this optional, and add i18n.commitEncoding support. */
1675 authorlen
= utf8_length(commit
->author
, AUTHOR_COLS
- 2, &col
, &trimmed
);
1678 waddnstr(view
->win
, commit
->author
, authorlen
);
1679 if (type
!= LINE_CURSOR
)
1680 wattrset(view
->win
, get_line_attr(LINE_MAIN_DELIM
));
1681 waddch(view
->win
, '~');
1683 waddstr(view
->win
, commit
->author
);
1687 if (type
!= LINE_CURSOR
)
1688 wattrset(view
->win
, A_NORMAL
);
1690 mvwaddch(view
->win
, lineno
, col
, ACS_LTEE
);
1691 wmove(view
->win
, lineno
, col
+ 2);
1698 if (type
== LINE_CURSOR
)
1700 else if (commit
->refs
[i
]->tag
)
1701 wattrset(view
->win
, get_line_attr(LINE_MAIN_TAG
));
1703 wattrset(view
->win
, get_line_attr(LINE_MAIN_REF
));
1704 waddstr(view
->win
, "[");
1705 waddstr(view
->win
, commit
->refs
[i
]->name
);
1706 waddstr(view
->win
, "]");
1707 if (type
!= LINE_CURSOR
)
1708 wattrset(view
->win
, A_NORMAL
);
1709 waddstr(view
->win
, " ");
1710 col
+= strlen(commit
->refs
[i
]->name
) + STRING_SIZE("[] ");
1711 } while (commit
->refs
[i
++]->next
);
1714 if (type
!= LINE_CURSOR
)
1715 wattrset(view
->win
, get_line_attr(type
));
1718 int titlelen
= strlen(commit
->title
);
1720 if (col
+ titlelen
> view
->width
)
1721 titlelen
= view
->width
- col
;
1723 waddnstr(view
->win
, commit
->title
, titlelen
);
1729 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1731 main_read(struct view
*view
, struct line
*prev
, char *line
)
1733 enum line_type type
= get_line_type(line
);
1734 struct commit
*commit
;
1738 commit
= calloc(1, sizeof(struct commit
));
1742 line
+= STRING_SIZE("commit ");
1744 view
->line
[view
->lines
++].data
= commit
;
1745 string_copy(commit
->id
, line
);
1746 commit
->refs
= get_refs(commit
->id
);
1751 char *ident
= line
+ STRING_SIZE("author ");
1752 char *end
= strchr(ident
, '<');
1757 commit
= prev
->data
;
1760 for (; end
> ident
&& isspace(end
[-1]); end
--) ;
1764 string_copy(commit
->author
, ident
);
1766 /* Parse epoch and timezone */
1768 char *secs
= strchr(end
+ 1, '>');
1772 if (!secs
|| secs
[1] != ' ')
1776 time
= (time_t) atol(secs
);
1777 zone
= strchr(secs
, ' ');
1778 if (zone
&& strlen(zone
) == STRING_SIZE(" +0700")) {
1782 tz
= ('0' - zone
[1]) * 60 * 60 * 10;
1783 tz
+= ('0' - zone
[2]) * 60 * 60;
1784 tz
+= ('0' - zone
[3]) * 60;
1785 tz
+= ('0' - zone
[4]) * 60;
1792 gmtime_r(&time
, &commit
->time
);
1800 commit
= prev
->data
;
1802 /* Fill in the commit title if it has not already been set. */
1803 if (commit
->title
[0])
1806 /* Require titles to start with a non-space character at the
1807 * offset used by git log. */
1808 /* FIXME: More gracefull handling of titles; append "..." to
1809 * shortened titles, etc. */
1810 if (strncmp(line
, " ", 4) ||
1814 string_copy(commit
->title
, line
+ 4);
1821 main_enter(struct view
*view
, struct line
*line
)
1823 enum open_flags flags
= display
[0] == view ? OPEN_SPLIT
: OPEN_DEFAULT
;
1825 open_view(view
, REQ_VIEW_DIFF
, flags
);
1829 static struct view_ops main_ops
= {
1840 * Below the default key bindings are shown.
1848 static struct keymap keymap
[] = {
1853 * Switch to main view.
1855 * Switch to diff view.
1857 * Switch to log view.
1859 * Switch to pager view.
1863 { 'm', REQ_VIEW_MAIN
},
1864 { 'd', REQ_VIEW_DIFF
},
1865 { 'l', REQ_VIEW_LOG
},
1866 { 'p', REQ_VIEW_PAGER
},
1867 { 'h', REQ_VIEW_HELP
},
1873 * Close view, if multiple views are open it will jump back to the
1874 * previous view in the view stack. If it is the last open view it
1875 * will quit. Use 'Q' to quit all views at once.
1877 * This key is "context sensitive" depending on what view you are
1878 * currently in. When in log view on a commit line or in the main
1879 * view, split the view and show the commit diff. In the diff view
1880 * pressing Enter will simply scroll the view one line down.
1882 * Switch to next view.
1884 * This key is "context sensitive" and will move the cursor one
1885 * line up. However, uf you opened a diff view from the main view
1886 * (split- or full-screen) it will change the cursor to point to
1887 * the previous commit in the main view and update the diff view
1890 * Similar to 'Up' but will move down.
1892 { 'q', REQ_VIEW_CLOSE
},
1893 { KEY_TAB
, REQ_VIEW_NEXT
},
1894 { KEY_RETURN
, REQ_ENTER
},
1895 { KEY_UP
, REQ_PREVIOUS
},
1896 { KEY_DOWN
, REQ_NEXT
},
1902 * Move cursor one line up.
1904 * Move cursor one line down.
1908 * Move cursor one page up.
1911 * Move cursor one page down.
1913 * Jump to first line.
1915 * Jump to last line.
1917 { 'k', REQ_MOVE_UP
},
1918 { 'j', REQ_MOVE_DOWN
},
1919 { KEY_HOME
, REQ_MOVE_FIRST_LINE
},
1920 { KEY_END
, REQ_MOVE_LAST_LINE
},
1921 { KEY_NPAGE
, REQ_MOVE_PAGE_DOWN
},
1922 { ' ', REQ_MOVE_PAGE_DOWN
},
1923 { KEY_PPAGE
, REQ_MOVE_PAGE_UP
},
1924 { 'b', REQ_MOVE_PAGE_UP
},
1925 { '-', REQ_MOVE_PAGE_UP
},
1931 * Scroll view one line up.
1933 * Scroll view one line down.
1935 * Scroll view one page up.
1937 * Scroll view one page down.
1939 { KEY_IC
, REQ_SCROLL_LINE_UP
},
1940 { KEY_DC
, REQ_SCROLL_LINE_DOWN
},
1941 { 'w', REQ_SCROLL_PAGE_UP
},
1942 { 's', REQ_SCROLL_PAGE_DOWN
},
1952 * Stop all background loading. This can be useful if you use
1953 * tig(1) in a repository with a long history without limiting
1958 * Toggle line numbers on/off.
1960 * Open prompt. This allows you to specify what git command
1966 { 'z', REQ_STOP_LOADING
},
1967 { 'v', REQ_SHOW_VERSION
},
1968 { 'r', REQ_SCREEN_REDRAW
},
1969 { 'n', REQ_TOGGLE_LINE_NUMBERS
},
1970 { ':', REQ_PROMPT
},
1972 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1973 { ERR
, REQ_SCREEN_UPDATE
},
1975 /* Use the ncurses SIGWINCH handler. */
1976 { KEY_RESIZE
, REQ_SCREEN_RESIZE
},
1980 get_request(int key
)
1984 for (i
= 0; i
< ARRAY_SIZE(keymap
); i
++)
1985 if (keymap
[i
].alias
== key
)
1986 return keymap
[i
].request
;
1988 return (enum request
) key
;
1993 * Unicode / UTF-8 handling
1995 * NOTE: Much of the following code for dealing with unicode is derived from
1996 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
1997 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2000 /* I've (over)annotated a lot of code snippets because I am not entirely
2001 * confident that the approach taken by this small UTF-8 interface is correct.
2005 unicode_width(unsigned long c
)
2008 (c
<= 0x115f /* Hangul Jamo */
2011 || (c
>= 0x2e80 && c
<= 0xa4cf && c
!= 0x303f)
2013 || (c
>= 0xac00 && c
<= 0xd7a3) /* Hangul Syllables */
2014 || (c
>= 0xf900 && c
<= 0xfaff) /* CJK Compatibility Ideographs */
2015 || (c
>= 0xfe30 && c
<= 0xfe6f) /* CJK Compatibility Forms */
2016 || (c
>= 0xff00 && c
<= 0xff60) /* Fullwidth Forms */
2017 || (c
>= 0xffe0 && c
<= 0xffe6)
2018 || (c
>= 0x20000 && c
<= 0x2fffd)
2019 || (c
>= 0x30000 && c
<= 0x3fffd)))
2025 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2026 * Illegal bytes are set one. */
2027 static const unsigned char utf8_bytes
[256] = {
2028 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2029 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2030 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2031 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2032 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2033 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2034 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,
2035 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,
2038 /* Decode UTF-8 multi-byte representation into a unicode character. */
2039 static inline unsigned long
2040 utf8_to_unicode(const char *string
, size_t length
)
2042 unsigned long unicode
;
2046 unicode
= string
[0];
2049 unicode
= (string
[0] & 0x1f) << 6;
2050 unicode
+= (string
[1] & 0x3f);
2053 unicode
= (string
[0] & 0x0f) << 12;
2054 unicode
+= ((string
[1] & 0x3f) << 6);
2055 unicode
+= (string
[2] & 0x3f);
2058 unicode
= (string
[0] & 0x0f) << 18;
2059 unicode
+= ((string
[1] & 0x3f) << 12);
2060 unicode
+= ((string
[2] & 0x3f) << 6);
2061 unicode
+= (string
[3] & 0x3f);
2064 unicode
= (string
[0] & 0x0f) << 24;
2065 unicode
+= ((string
[1] & 0x3f) << 18);
2066 unicode
+= ((string
[2] & 0x3f) << 12);
2067 unicode
+= ((string
[3] & 0x3f) << 6);
2068 unicode
+= (string
[4] & 0x3f);
2071 unicode
= (string
[0] & 0x01) << 30;
2072 unicode
+= ((string
[1] & 0x3f) << 24);
2073 unicode
+= ((string
[2] & 0x3f) << 18);
2074 unicode
+= ((string
[3] & 0x3f) << 12);
2075 unicode
+= ((string
[4] & 0x3f) << 6);
2076 unicode
+= (string
[5] & 0x3f);
2079 die("Invalid unicode length");
2082 /* Invalid characters could return the special 0xfffd value but NUL
2083 * should be just as good. */
2084 return unicode
> 0xffff ?
0 : unicode
;
2087 /* Calculates how much of string can be shown within the given maximum width
2088 * and sets trimmed parameter to non-zero value if all of string could not be
2091 * Additionally, adds to coloffset how many many columns to move to align with
2092 * the expected position. Takes into account how multi-byte and double-width
2093 * characters will effect the cursor position.
2095 * Returns the number of bytes to output from string to satisfy max_width. */
2097 utf8_length(const char *string
, size_t max_width
, int *coloffset
, int *trimmed
)
2099 const char *start
= string
;
2100 const char *end
= strchr(string
, '\0');
2106 while (string
< end
) {
2107 int c
= *(unsigned char *) string
;
2108 unsigned char bytes
= utf8_bytes
[c
];
2110 unsigned long unicode
;
2112 if (string
+ bytes
> end
)
2115 /* Change representation to figure out whether
2116 * it is a single- or double-width character. */
2118 unicode
= utf8_to_unicode(string
, bytes
);
2119 /* FIXME: Graceful handling of invalid unicode character. */
2123 ucwidth
= unicode_width(unicode
);
2125 if (width
> max_width
) {
2130 /* The column offset collects the differences between the
2131 * number of bytes encoding a character and the number of
2132 * columns will be used for rendering said character.
2134 * So if some character A is encoded in 2 bytes, but will be
2135 * represented on the screen using only 1 byte this will and up
2136 * adding 1 to the multi-byte column offset.
2138 * Assumes that no double-width character can be encoding in
2139 * less than two bytes. */
2140 if (bytes
> ucwidth
)
2141 mbwidth
+= bytes
- ucwidth
;
2146 *coloffset
+= mbwidth
;
2148 return string
- start
;
2156 /* Whether or not the curses interface has been initialized. */
2157 static bool cursed
= FALSE
;
2159 /* The status window is used for polling keystrokes. */
2160 static WINDOW
*status_win
;
2162 /* Update status and title window. */
2164 report(const char *msg
, ...)
2166 static bool empty
= TRUE
;
2167 struct view
*view
= display
[current_view
];
2169 if (!empty
|| *msg
) {
2172 va_start(args
, msg
);
2175 wmove(status_win
, 0, 0);
2177 vwprintw(status_win
, msg
, args
);
2182 wrefresh(status_win
);
2187 update_view_title(view
);
2189 /* Move the cursor to the right-most column of the cursor line.
2191 * XXX: This could turn out to be a bit expensive, but it ensures that
2192 * the cursor does not jump around. */
2194 wmove(view
->win
, view
->lineno
- view
->offset
, view
->width
- 1);
2195 wrefresh(view
->win
);
2199 /* Controls when nodelay should be in effect when polling user input. */
2201 set_nonblocking_input(bool loading
)
2203 static unsigned int loading_views
;
2205 if ((loading
== FALSE
&& loading_views
-- == 1) ||
2206 (loading
== TRUE
&& loading_views
++ == 0))
2207 nodelay(status_win
, loading
);
2215 /* Initialize the curses library */
2216 if (isatty(STDIN_FILENO
)) {
2217 cursed
= !!initscr();
2219 /* Leave stdin and stdout alone when acting as a pager. */
2220 FILE *io
= fopen("/dev/tty", "r+");
2222 cursed
= !!newterm(NULL
, io
, io
);
2226 die("Failed to initialize curses");
2228 nonl(); /* Tell curses not to do NL->CR/NL on output */
2229 cbreak(); /* Take input chars one at a time, no wait for \n */
2230 noecho(); /* Don't echo input */
2231 leaveok(stdscr
, TRUE
);
2236 getmaxyx(stdscr
, y
, x
);
2237 status_win
= newwin(1, 0, y
- 1, 0);
2239 die("Failed to create status window");
2241 /* Enable keyboard mapping */
2242 keypad(status_win
, TRUE
);
2243 wbkgdset(status_win
, get_line_attr(LINE_STATUS
));
2248 * Repository references
2251 static struct ref
*refs
;
2252 static size_t refs_size
;
2254 /* Id <-> ref store */
2255 static struct ref
***id_refs
;
2256 static size_t id_refs_size
;
2258 static struct ref
**
2261 struct ref
***tmp_id_refs
;
2262 struct ref
**ref_list
= NULL
;
2263 size_t ref_list_size
= 0;
2266 for (i
= 0; i
< id_refs_size
; i
++)
2267 if (!strcmp(id
, id_refs
[i
][0]->id
))
2270 tmp_id_refs
= realloc(id_refs
, (id_refs_size
+ 1) * sizeof(*id_refs
));
2274 id_refs
= tmp_id_refs
;
2276 for (i
= 0; i
< refs_size
; i
++) {
2279 if (strcmp(id
, refs
[i
].id
))
2282 tmp
= realloc(ref_list
, (ref_list_size
+ 1) * sizeof(*ref_list
));
2290 if (ref_list_size
> 0)
2291 ref_list
[ref_list_size
- 1]->next
= 1;
2292 ref_list
[ref_list_size
] = &refs
[i
];
2294 /* XXX: The properties of the commit chains ensures that we can
2295 * safely modify the shared ref. The repo references will
2296 * always be similar for the same id. */
2297 ref_list
[ref_list_size
]->next
= 0;
2302 id_refs
[id_refs_size
++] = ref_list
;
2310 const char *cmd_env
= getenv("TIG_LS_REMOTE");
2311 const char *cmd
= cmd_env
&& *cmd_env ? cmd_env
: TIG_LS_REMOTE
;
2312 FILE *pipe
= popen(cmd
, "r");
2313 char buffer
[BUFSIZ
];
2319 while ((line
= fgets(buffer
, sizeof(buffer
), pipe
))) {
2320 char *name
= strchr(line
, '\t');
2324 bool tag_commit
= FALSE
;
2330 namelen
= strlen(name
) - 1;
2332 /* Commits referenced by tags has "^{}" appended. */
2333 if (name
[namelen
- 1] == '}') {
2334 while (namelen
> 0 && name
[namelen
] != '^')
2341 if (!strncmp(name
, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2344 name
+= STRING_SIZE("refs/tags/");
2347 } else if (!strncmp(name
, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2348 name
+= STRING_SIZE("refs/heads/");
2350 } else if (!strcmp(name
, "HEAD")) {
2354 refs
= realloc(refs
, sizeof(*refs
) * (refs_size
+ 1));
2358 ref
= &refs
[refs_size
++];
2360 ref
->name
= strdup(name
);
2364 string_copy(ref
->id
, line
);
2380 #define __NORETURN __attribute__((__noreturn__))
2385 static void __NORETURN
2388 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2394 static void __NORETURN
2395 die(const char *err
, ...)
2401 va_start(args
, err
);
2402 fputs("tig: ", stderr
);
2403 vfprintf(stderr
, err
, args
);
2404 fputs("\n", stderr
);
2411 main(int argc
, char *argv
[])
2414 enum request request
;
2417 signal(SIGINT
, quit
);
2419 if (!parse_options(argc
, argv
))
2422 if (load_refs() == ERR
)
2423 die("Failed to load refs.");
2425 /* Require a git repository unless when running in pager mode. */
2426 if (refs_size
== 0 && opt_request
!= REQ_VIEW_PAGER
)
2427 die("Not a git repository");
2429 for (i
= 0; i
< ARRAY_SIZE(views
) && (view
= &views
[i
]); i
++)
2430 view
->cmd_env
= getenv(view
->cmd_env
);
2432 request
= opt_request
;
2436 while (view_driver(display
[current_view
], request
)) {
2440 foreach_view (view
, i
)
2443 /* Refresh, accept single keystroke of input */
2444 key
= wgetch(status_win
);
2445 request
= get_request(key
);
2447 /* Some low-level request handling. This keeps access to
2448 * status_win restricted. */
2452 /* Temporarily switch to line-oriented and echoed
2457 if (wgetnstr(status_win
, opt_cmd
+ 4, sizeof(opt_cmd
) - 4) == OK
) {
2458 memcpy(opt_cmd
, "git ", 4);
2459 opt_request
= REQ_VIEW_PAGER
;
2468 case REQ_SCREEN_RESIZE
:
2472 getmaxyx(stdscr
, height
, width
);
2474 /* Resize the status view and let the view driver take
2475 * care of resizing the displayed views. */
2476 wresize(status_win
, 1, width
);
2477 mvwin(status_win
, height
- 1, 0);
2478 wrefresh(status_win
);
2493 * Revision specification
2494 * ----------------------
2495 * This section describes various ways to specify what revisions to display
2496 * or otherwise limit the view to. tig(1) does not itself parse the described
2497 * revision options so refer to the relevant git man pages for futher
2498 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2501 * You can tune the interaction with git by making use of the options
2502 * explained in this section. For example, by configuring the environment
2503 * variables described in the <<view-commands, "View commands">> section.
2505 * Limit by path name
2506 * ~~~~~~~~~~~~~~~~~~
2507 * If you are interested only in those revisions that made changes to a
2508 * specific file (or even several files) list the files like this:
2510 * $ tig log Makefile README
2512 * To avoid ambiguity with repository references such as tag name, be sure
2513 * to separate file names from other git options using "\--". So if you
2514 * have a file named 'master' it will clash with the reference named
2515 * 'master', and thus you will have to use:
2517 * $ tig log -- master
2519 * NOTE: For the main view, avoiding ambiguity will in some cases require
2520 * you to specify two "\--" options. The first will make tig(1) stop
2521 * option processing and the latter will be passed to git log.
2523 * Limit by date or number
2524 * ~~~~~~~~~~~~~~~~~~~~~~~
2525 * To speed up interaction with git, you can limit the amount of commits
2526 * to show both for the log and main view. Either limit by date using
2527 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2529 * If you are only interested in changed that happened between two dates
2532 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2534 * NOTE: If you want to avoid having to quote dates containing spaces you
2535 * can use "." instead, e.g. `--after=May.5th`.
2537 * Limiting by commit ranges
2538 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2539 * Alternatively, commits can be limited to a specific range, such as
2540 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2542 * $ tig log tag-1.0..tag-2.0
2544 * This way of commit limiting makes it trivial to only browse the commits
2545 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2546 * upstream remote branch, using:
2548 * $ tig log origin..HEAD
2550 * will list what will be pushed to the remote branch. Optionally, the ending
2551 * 'HEAD' can be left out since it is implied.
2553 * Limiting by reachability
2554 * ~~~~~~~~~~~~~~~~~~~~~~~~
2555 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2556 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2557 * Where reachability refers to what commits are ancestors (or part of the
2558 * history) of the branch or tagged revision in question.
2560 * If you prefer to specify which commit to preview in this way use the
2563 * $ tig log tag-2.0 ^tag-1.0
2565 * You can think of '^' as a negation operator. Using this alternate syntax,
2566 * it is possible to further prune commits by specifying multiple branch
2569 * Combining revisions specification
2570 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2571 * Revisions options can to some degree be combined, which makes it possible
2572 * to say "show at most 20 commits from within the last month that changed
2573 * files under the Documentation/ directory."
2575 * $ tig -- --since=1.month -n20 -- Documentation/
2577 * Examining all repository references
2578 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2579 * In some cases, it can be useful to query changes across all references
2580 * in a repository. An example is to ask "did any line of development in
2581 * this repository change a particular file within the last week". This
2582 * can be accomplished using:
2584 * $ tig -- --all --since=1.week -- Makefile
2588 * Known bugs and problems:
2590 * - In it's current state tig is pretty much UTF-8 only.
2592 * - If the screen width is very small the main view can draw
2593 * outside the current view causing bad wrapping. Same goes
2594 * for title and status windows.
2596 * - The cursor can wrap-around on the last line and cause the
2601 * Features that should be explored.
2609 * Copyright (c) Jonas Fonseca <fonseca@diku.dk>, 2006
2611 * This program is free software; you can redistribute it and/or modify
2612 * it under the terms of the GNU General Public License as published by
2613 * the Free Software Foundation; either version 2 of the License, or
2614 * (at your option) any later version.
2619 * link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2620 * link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2621 * gitk(1): git repository browser written using tcl/tk,
2622 * qgit(1): git repository browser written using c++/Qt,
2623 * gitview(1): git repository browser written using python/gtk.