~mdw / tig / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add support for keybindings
[tig] / tig.c
1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License as
5 * published by the Free Software Foundation; either version 2 of
6 * the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13
14 #ifndef VERSION
15 #define VERSION "tig-0.3"
16 #endif
17
18 #ifndef DEBUG
19 #define NDEBUG
20 #endif
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <ctype.h>
25 #include <signal.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <time.h>
32
33 #include <curses.h>
34
35 #if __GNUC__ >= 3
36 #define __NORETURN __attribute__((__noreturn__))
37 #else
38 #define __NORETURN
39 #endif
40
41 static void __NORETURN die(const char *err, ...);
42 static void report(const char *msg, ...);
43 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
44 static void set_nonblocking_input(bool loading);
45 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
46
47 #define ABS(x) ((x) >= 0 ? (x) : -(x))
48 #define MIN(x, y) ((x) < (y) ? (x) : (y))
49
50 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
51 #define STRING_SIZE(x) (sizeof(x) - 1)
52
53 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
54 #define SIZEOF_CMD 1024 /* Size of command buffer. */
55 #define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */
56
57 /* This color name can be used to refer to the default term colors. */
58 #define COLOR_DEFAULT (-1)
59
60 /* The format and size of the date column in the main view. */
61 #define DATE_FORMAT "%Y-%m-%d %H:%M"
62 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
63
64 #define AUTHOR_COLS 20
65
66 /* The default interval between line numbers. */
67 #define NUMBER_INTERVAL 1
68
69 #define TABSIZE 8
70
71 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
72
73 #define TIG_LS_REMOTE \
74 "git ls-remote . 2>/dev/null"
75
76 #define TIG_DIFF_CMD \
77 "git show --patch-with-stat --find-copies-harder -B -C %s"
78
79 #define TIG_LOG_CMD \
80 "git log --cc --stat -n100 %s"
81
82 #define TIG_MAIN_CMD \
83 "git log --topo-order --stat --pretty=raw %s"
84
85 /* XXX: Needs to be defined to the empty string. */
86 #define TIG_HELP_CMD ""
87 #define TIG_PAGER_CMD ""
88
89 /* Some ascii-shorthands fitted into the ncurses namespace. */
90 #define KEY_TAB '\t'
91 #define KEY_RETURN '\r'
92 #define KEY_ESC 27
93
94
95 struct ref {
96 char *name; /* Ref name; tag or head names are shortened. */
97 char id[41]; /* Commit SHA1 ID */
98 unsigned int tag:1; /* Is it a tag? */
99 unsigned int next:1; /* For ref lists: are there more refs? */
100 };
101
102 static struct ref **get_refs(char *id);
103
104 struct int_map {
105 const char *name;
106 int namelen;
107 int value;
108 };
109
110 static int
111 set_from_int_map(struct int_map *map, size_t map_size,
112 int *value, const char *name, int namelen)
113 {
114
115 int i;
116
117 for (i = 0; i < map_size; i++)
118 if (namelen == map[i].namelen &&
119 !strncasecmp(name, map[i].name, namelen)) {
120 *value = map[i].value;
121 return OK;
122 }
123
124 return ERR;
125 }
126
127
128 /*
129 * String helpers
130 */
131
132 static inline void
133 string_ncopy(char *dst, const char *src, int dstlen)
134 {
135 strncpy(dst, src, dstlen - 1);
136 dst[dstlen - 1] = 0;
137
138 }
139
140 /* Shorthand for safely copying into a fixed buffer. */
141 #define string_copy(dst, src) \
142 string_ncopy(dst, src, sizeof(dst))
143
144 static char *
145 chomp_string(char *name)
146 {
147 int namelen;
148
149 while (isspace(*name))
150 name++;
151
152 namelen = strlen(name) - 1;
153 while (namelen > 0 && isspace(name[namelen]))
154 name[namelen--] = 0;
155
156 return name;
157 }
158
159 static bool
160 string_nformat(char *buf, size_t bufsize, int *bufpos, const char *fmt, ...)
161 {
162 va_list args;
163 int pos = bufpos ? *bufpos : 0;
164
165 va_start(args, fmt);
166 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
167 va_end(args);
168
169 if (bufpos)
170 *bufpos = pos;
171
172 return pos >= bufsize ? FALSE : TRUE;
173 }
174
175 #define string_format(buf, fmt, args...) \
176 string_nformat(buf, sizeof(buf), NULL, fmt, args)
177
178 #define string_format_from(buf, from, fmt, args...) \
179 string_nformat(buf, sizeof(buf), from, fmt, args)
180
181 static int
182 string_enum_compare(const char *str1, const char *str2, int len)
183 {
184 size_t i;
185
186 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
187
188 /* Diff-Header == DIFF_HEADER */
189 for (i = 0; i < len; i++) {
190 if (toupper(str1[i]) == toupper(str2[i]))
191 continue;
192
193 if (string_enum_sep(str1[i]) &&
194 string_enum_sep(str2[i]))
195 continue;
196
197 return str1[i] - str2[i];
198 }
199
200 return 0;
201 }
202
203 /* Shell quoting
204 *
205 * NOTE: The following is a slightly modified copy of the git project's shell
206 * quoting routines found in the quote.c file.
207 *
208 * Help to copy the thing properly quoted for the shell safety. any single
209 * quote is replaced with '\'', any exclamation point is replaced with '\!',
210 * and the whole thing is enclosed in a
211 *
212 * E.g.
213 * original sq_quote result
214 * name ==> name ==> 'name'
215 * a b ==> a b ==> 'a b'
216 * a'b ==> a'\''b ==> 'a'\''b'
217 * a!b ==> a'\!'b ==> 'a'\!'b'
218 */
219
220 static size_t
221 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
222 {
223 char c;
224
225 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
226
227 BUFPUT('\'');
228 while ((c = *src++)) {
229 if (c == '\'' || c == '!') {
230 BUFPUT('\'');
231 BUFPUT('\\');
232 BUFPUT(c);
233 BUFPUT('\'');
234 } else {
235 BUFPUT(c);
236 }
237 }
238 BUFPUT('\'');
239
240 return bufsize;
241 }
242
243
244 /*
245 * User requests
246 */
247
248 #define REQ_INFO \
249 /* XXX: Keep the view request first and in sync with views[]. */ \
250 REQ_GROUP("View switching") \
251 REQ_(VIEW_MAIN, "Show main view"), \
252 REQ_(VIEW_DIFF, "Show diff view"), \
253 REQ_(VIEW_LOG, "Show log view"), \
254 REQ_(VIEW_HELP, "Show help page"), \
255 REQ_(VIEW_PAGER, "Show pager view"), \
256 \
257 REQ_GROUP("View manipulation") \
258 REQ_(ENTER, "Enter current line and scroll"), \
259 REQ_(NEXT, "Move to next"), \
260 REQ_(PREVIOUS, "Move to previous"), \
261 REQ_(VIEW_NEXT, "Move focus to next view"), \
262 REQ_(VIEW_CLOSE, "Close the current view"), \
263 REQ_(QUIT, "Close all views and quit"), \
264 \
265 REQ_GROUP("Cursor navigation") \
266 REQ_(MOVE_UP, "Move cursor one line up"), \
267 REQ_(MOVE_DOWN, "Move cursor one line down"), \
268 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
269 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
270 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
271 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
272 \
273 REQ_GROUP("Scrolling") \
274 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
275 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
276 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
277 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
278 \
279 REQ_GROUP("Misc") \
280 REQ_(PROMPT, "Bring up the prompt"), \
281 REQ_(SCREEN_UPDATE, "Update the screen"), \
282 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
283 REQ_(SCREEN_RESIZE, "Resize the screen"), \
284 REQ_(SHOW_VERSION, "Show version information"), \
285 REQ_(STOP_LOADING, "Stop all loading views"), \
286 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
287 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization")
288
289
290 /* User action requests. */
291 enum request {
292 #define REQ_GROUP(help)
293 #define REQ_(req, help) REQ_##req
294
295 /* Offset all requests to avoid conflicts with ncurses getch values. */
296 REQ_OFFSET = KEY_MAX + 1,
297 REQ_INFO,
298 REQ_UNKNOWN,
299
300 #undef REQ_GROUP
301 #undef REQ_
302 };
303
304 struct request_info {
305 enum request request;
306 char *name;
307 int namelen;
308 char *help;
309 };
310
311 static struct request_info req_info[] = {
312 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
313 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
314 REQ_INFO
315 #undef REQ_GROUP
316 #undef REQ_
317 };
318
319 static enum request
320 get_request(const char *name)
321 {
322 int namelen = strlen(name);
323 int i;
324
325 for (i = 0; i < ARRAY_SIZE(req_info); i++)
326 if (req_info[i].namelen == namelen &&
327 !string_enum_compare(req_info[i].name, name, namelen))
328 return req_info[i].request;
329
330 return REQ_UNKNOWN;
331 }
332
333
334 /*
335 * Options
336 */
337
338 static const char usage[] =
339 VERSION " (" __DATE__ ")\n"
340 "\n"
341 "Usage: tig [options]\n"
342 " or: tig [options] [--] [git log options]\n"
343 " or: tig [options] log [git log options]\n"
344 " or: tig [options] diff [git diff options]\n"
345 " or: tig [options] show [git show options]\n"
346 " or: tig [options] < [git command output]\n"
347 "\n"
348 "Options:\n"
349 " -l Start up in log view\n"
350 " -d Start up in diff view\n"
351 " -n[I], --line-number[=I] Show line numbers with given interval\n"
352 " -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
353 " -- Mark end of tig options\n"
354 " -v, --version Show version and exit\n"
355 " -h, --help Show help message and exit\n";
356
357 /* Option and state variables. */
358 static bool opt_line_number = FALSE;
359 static bool opt_rev_graph = TRUE;
360 static int opt_num_interval = NUMBER_INTERVAL;
361 static int opt_tab_size = TABSIZE;
362 static enum request opt_request = REQ_VIEW_MAIN;
363 static char opt_cmd[SIZEOF_CMD] = "";
364 static char opt_encoding[20] = "";
365 static bool opt_utf8 = TRUE;
366 static FILE *opt_pipe = NULL;
367
368 enum option_type {
369 OPT_NONE,
370 OPT_INT,
371 };
372
373 static bool
374 check_option(char *opt, char short_name, char *name, enum option_type type, ...)
375 {
376 va_list args;
377 char *value = "";
378 int *number;
379
380 if (opt[0] != '-')
381 return FALSE;
382
383 if (opt[1] == '-') {
384 int namelen = strlen(name);
385
386 opt += 2;
387
388 if (strncmp(opt, name, namelen))
389 return FALSE;
390
391 if (opt[namelen] == '=')
392 value = opt + namelen + 1;
393
394 } else {
395 if (!short_name || opt[1] != short_name)
396 return FALSE;
397 value = opt + 2;
398 }
399
400 va_start(args, type);
401 if (type == OPT_INT) {
402 number = va_arg(args, int *);
403 if (isdigit(*value))
404 *number = atoi(value);
405 }
406 va_end(args);
407
408 return TRUE;
409 }
410
411 /* Returns the index of log or diff command or -1 to exit. */
412 static bool
413 parse_options(int argc, char *argv[])
414 {
415 int i;
416
417 for (i = 1; i < argc; i++) {
418 char *opt = argv[i];
419
420 if (!strcmp(opt, "-l")) {
421 opt_request = REQ_VIEW_LOG;
422 continue;
423 }
424
425 if (!strcmp(opt, "-d")) {
426 opt_request = REQ_VIEW_DIFF;
427 continue;
428 }
429
430 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
431 opt_line_number = TRUE;
432 continue;
433 }
434
435 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
436 opt_tab_size = MIN(opt_tab_size, TABSIZE);
437 continue;
438 }
439
440 if (check_option(opt, 'v', "version", OPT_NONE)) {
441 printf("tig version %s\n", VERSION);
442 return FALSE;
443 }
444
445 if (check_option(opt, 'h', "help", OPT_NONE)) {
446 printf(usage);
447 return FALSE;
448 }
449
450 if (!strcmp(opt, "--")) {
451 i++;
452 break;
453 }
454
455 if (!strcmp(opt, "log") ||
456 !strcmp(opt, "diff") ||
457 !strcmp(opt, "show")) {
458 opt_request = opt[0] == 'l'
459 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
460 break;
461 }
462
463 if (opt[0] && opt[0] != '-')
464 break;
465
466 die("unknown option '%s'\n\n%s", opt, usage);
467 }
468
469 if (!isatty(STDIN_FILENO)) {
470 opt_request = REQ_VIEW_PAGER;
471 opt_pipe = stdin;
472
473 } else if (i < argc) {
474 size_t buf_size;
475
476 if (opt_request == REQ_VIEW_MAIN)
477 /* XXX: This is vulnerable to the user overriding
478 * options required for the main view parser. */
479 string_copy(opt_cmd, "git log --stat --pretty=raw");
480 else
481 string_copy(opt_cmd, "git");
482 buf_size = strlen(opt_cmd);
483
484 while (buf_size < sizeof(opt_cmd) && i < argc) {
485 opt_cmd[buf_size++] = ' ';
486 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
487 }
488
489 if (buf_size >= sizeof(opt_cmd))
490 die("command too long");
491
492 opt_cmd[buf_size] = 0;
493
494 }
495
496 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
497 opt_utf8 = FALSE;
498
499 return TRUE;
500 }
501
502
503 /*
504 * Line-oriented content detection.
505 */
506
507 #define LINE_INFO \
508 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
509 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
510 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
511 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
512 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
513 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
514 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
515 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
516 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
517 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
518 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
519 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
520 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
521 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
522 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
523 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
524 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
525 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
526 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
527 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
528 LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
529 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
530 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
531 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
532 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
533 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
534 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
535 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
536 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
537 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
538 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
539 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
540 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
541 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
542 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
543 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
544 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
545 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
546
547 enum line_type {
548 #define LINE(type, line, fg, bg, attr) \
549 LINE_##type
550 LINE_INFO
551 #undef LINE
552 };
553
554 struct line_info {
555 const char *name; /* Option name. */
556 int namelen; /* Size of option name. */
557 const char *line; /* The start of line to match. */
558 int linelen; /* Size of string to match. */
559 int fg, bg, attr; /* Color and text attributes for the lines. */
560 };
561
562 static struct line_info line_info[] = {
563 #define LINE(type, line, fg, bg, attr) \
564 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
565 LINE_INFO
566 #undef LINE
567 };
568
569 static enum line_type
570 get_line_type(char *line)
571 {
572 int linelen = strlen(line);
573 enum line_type type;
574
575 for (type = 0; type < ARRAY_SIZE(line_info); type++)
576 /* Case insensitive search matches Signed-off-by lines better. */
577 if (linelen >= line_info[type].linelen &&
578 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
579 return type;
580
581 return LINE_DEFAULT;
582 }
583
584 static inline int
585 get_line_attr(enum line_type type)
586 {
587 assert(type < ARRAY_SIZE(line_info));
588 return COLOR_PAIR(type) | line_info[type].attr;
589 }
590
591 static struct line_info *
592 get_line_info(char *name, int namelen)
593 {
594 enum line_type type;
595
596 for (type = 0; type < ARRAY_SIZE(line_info); type++)
597 if (namelen == line_info[type].namelen &&
598 !string_enum_compare(line_info[type].name, name, namelen))
599 return &line_info[type];
600
601 return NULL;
602 }
603
604 static void
605 init_colors(void)
606 {
607 int default_bg = COLOR_BLACK;
608 int default_fg = COLOR_WHITE;
609 enum line_type type;
610
611 start_color();
612
613 if (use_default_colors() != ERR) {
614 default_bg = -1;
615 default_fg = -1;
616 }
617
618 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
619 struct line_info *info = &line_info[type];
620 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
621 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
622
623 init_pair(type, fg, bg);
624 }
625 }
626
627 struct line {
628 enum line_type type;
629 void *data; /* User data */
630 };
631
632
633 /*
634 * Keys
635 */
636
637 struct keybinding {
638 int alias;
639 enum request request;
640 struct keybinding *next;
641 };
642
643 static struct keybinding default_keybindings[] = {
644 /* View switching */
645 { 'm', REQ_VIEW_MAIN },
646 { 'd', REQ_VIEW_DIFF },
647 { 'l', REQ_VIEW_LOG },
648 { 'p', REQ_VIEW_PAGER },
649 { 'h', REQ_VIEW_HELP },
650 { '?', REQ_VIEW_HELP },
651
652 /* View manipulation */
653 { 'q', REQ_VIEW_CLOSE },
654 { KEY_TAB, REQ_VIEW_NEXT },
655 { KEY_RETURN, REQ_ENTER },
656 { KEY_UP, REQ_PREVIOUS },
657 { KEY_DOWN, REQ_NEXT },
658
659 /* Cursor navigation */
660 { 'k', REQ_MOVE_UP },
661 { 'j', REQ_MOVE_DOWN },
662 { KEY_HOME, REQ_MOVE_FIRST_LINE },
663 { KEY_END, REQ_MOVE_LAST_LINE },
664 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
665 { ' ', REQ_MOVE_PAGE_DOWN },
666 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
667 { 'b', REQ_MOVE_PAGE_UP },
668 { '-', REQ_MOVE_PAGE_UP },
669
670 /* Scrolling */
671 { KEY_IC, REQ_SCROLL_LINE_UP },
672 { KEY_DC, REQ_SCROLL_LINE_DOWN },
673 { 'w', REQ_SCROLL_PAGE_UP },
674 { 's', REQ_SCROLL_PAGE_DOWN },
675
676 /* Misc */
677 { 'Q', REQ_QUIT },
678 { 'z', REQ_STOP_LOADING },
679 { 'v', REQ_SHOW_VERSION },
680 { 'r', REQ_SCREEN_REDRAW },
681 { 'n', REQ_TOGGLE_LINENO },
682 { 'g', REQ_TOGGLE_REV_GRAPH},
683 { ':', REQ_PROMPT },
684
685 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
686 { ERR, REQ_SCREEN_UPDATE },
687
688 /* Use the ncurses SIGWINCH handler. */
689 { KEY_RESIZE, REQ_SCREEN_RESIZE },
690 };
691
692 #define KEYMAP_INFO \
693 KEYMAP_(GENERIC), \
694 KEYMAP_(MAIN), \
695 KEYMAP_(DIFF), \
696 KEYMAP_(LOG), \
697 KEYMAP_(PAGER), \
698 KEYMAP_(HELP) \
699
700 enum keymap {
701 #define KEYMAP_(name) KEYMAP_##name
702 KEYMAP_INFO
703 #undef KEYMAP_
704 };
705
706 static struct int_map keymap_table[] = {
707 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
708 KEYMAP_INFO
709 #undef KEYMAP_
710 };
711
712 #define set_keymap(map, name) \
713 set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
714
715 static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
716
717 static void
718 add_keybinding(enum keymap keymap, enum request request, int key)
719 {
720 struct keybinding *keybinding;
721
722 keybinding = calloc(1, sizeof(*keybinding));
723 if (!keybinding)
724 die("Failed to allocate keybinding");
725
726 keybinding->alias = key;
727 keybinding->request = request;
728 keybinding->next = keybindings[keymap];
729 keybindings[keymap] = keybinding;
730 }
731
732 /* Looks for a key binding first in the given map, then in the generic map, and
733 * lastly in the default keybindings. */
734 static enum request
735 get_keybinding(enum keymap keymap, int key)
736 {
737 struct keybinding *kbd;
738 int i;
739
740 for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
741 if (kbd->alias == key)
742 return kbd->request;
743
744 for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
745 if (kbd->alias == key)
746 return kbd->request;
747
748 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
749 if (default_keybindings[i].alias == key)
750 return default_keybindings[i].request;
751
752 return (enum request) key;
753 }
754
755
756 struct key {
757 char *name;
758 int value;
759 };
760
761 static struct key key_table[] = {
762 { "Enter", KEY_RETURN },
763 { "Space", ' ' },
764 { "Backspace", KEY_BACKSPACE },
765 { "Tab", KEY_TAB },
766 { "Escape", KEY_ESC },
767 { "Left", KEY_LEFT },
768 { "Right", KEY_RIGHT },
769 { "Up", KEY_UP },
770 { "Down", KEY_DOWN },
771 { "Insert", KEY_IC },
772 { "Delete", KEY_DC },
773 { "Home", KEY_HOME },
774 { "End", KEY_END },
775 { "PageUp", KEY_PPAGE },
776 { "PageDown", KEY_NPAGE },
777 { "F1", KEY_F(1) },
778 { "F2", KEY_F(2) },
779 { "F3", KEY_F(3) },
780 { "F4", KEY_F(4) },
781 { "F5", KEY_F(5) },
782 { "F6", KEY_F(6) },
783 { "F7", KEY_F(7) },
784 { "F8", KEY_F(8) },
785 { "F9", KEY_F(9) },
786 { "F10", KEY_F(10) },
787 { "F11", KEY_F(11) },
788 { "F12", KEY_F(12) },
789 };
790
791 static int
792 get_key_value(const char *name)
793 {
794 int i;
795
796 for (i = 0; i < ARRAY_SIZE(key_table); i++)
797 if (!strcasecmp(key_table[i].name, name))
798 return key_table[i].value;
799
800 if (strlen(name) == 1 && isprint(*name))
801 return (int) *name;
802
803 return ERR;
804 }
805
806 static char *
807 get_key(enum request request)
808 {
809 static char buf[BUFSIZ];
810 static char key_char[] = "'X'";
811 int pos = 0;
812 char *sep = " ";
813 int i;
814
815 buf[pos] = 0;
816
817 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
818 struct keybinding *keybinding = &default_keybindings[i];
819 char *seq = NULL;
820 int key;
821
822 if (keybinding->request != request)
823 continue;
824
825 for (key = 0; key < ARRAY_SIZE(key_table); key++)
826 if (key_table[key].value == keybinding->alias)
827 seq = key_table[key].name;
828
829 if (seq == NULL &&
830 keybinding->alias < 127 &&
831 isprint(keybinding->alias)) {
832 key_char[1] = (char) keybinding->alias;
833 seq = key_char;
834 }
835
836 if (!seq)
837 seq = "'?'";
838
839 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
840 return "Too many keybindings!";
841 sep = ", ";
842 }
843
844 return buf;
845 }
846
847
848 /*
849 * User config file handling.
850 */
851
852 static struct int_map color_map[] = {
853 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
854 COLOR_MAP(DEFAULT),
855 COLOR_MAP(BLACK),
856 COLOR_MAP(BLUE),
857 COLOR_MAP(CYAN),
858 COLOR_MAP(GREEN),
859 COLOR_MAP(MAGENTA),
860 COLOR_MAP(RED),
861 COLOR_MAP(WHITE),
862 COLOR_MAP(YELLOW),
863 };
864
865 #define set_color(color, name) \
866 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
867
868 static struct int_map attr_map[] = {
869 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
870 ATTR_MAP(NORMAL),
871 ATTR_MAP(BLINK),
872 ATTR_MAP(BOLD),
873 ATTR_MAP(DIM),
874 ATTR_MAP(REVERSE),
875 ATTR_MAP(STANDOUT),
876 ATTR_MAP(UNDERLINE),
877 };
878
879 #define set_attribute(attr, name) \
880 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
881
882 static int config_lineno;
883 static bool config_errors;
884 static char *config_msg;
885
886 /* Wants: object fgcolor bgcolor [attr] */
887 static int
888 option_color_command(int argc, char *argv[])
889 {
890 struct line_info *info;
891
892 if (argc != 3 && argc != 4) {
893 config_msg = "Wrong number of arguments given to color command";
894 return ERR;
895 }
896
897 info = get_line_info(argv[0], strlen(argv[0]));
898 if (!info) {
899 config_msg = "Unknown color name";
900 return ERR;
901 }
902
903 if (set_color(&info->fg, argv[1]) == ERR) {
904 config_msg = "Unknown color";
905 return ERR;
906 }
907
908 if (set_color(&info->bg, argv[2]) == ERR) {
909 config_msg = "Unknown color";
910 return ERR;
911 }
912
913 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
914 config_msg = "Unknown attribute";
915 return ERR;
916 }
917
918 return OK;
919 }
920
921 /* Wants: name = value */
922 static int
923 option_set_command(int argc, char *argv[])
924 {
925 if (argc != 3) {
926 config_msg = "Wrong number of arguments given to set command";
927 return ERR;
928 }
929
930 if (strcmp(argv[1], "=")) {
931 config_msg = "No value assigned";
932 return ERR;
933 }
934
935 if (!strcmp(argv[0], "show-rev-graph")) {
936 opt_rev_graph = (!strcmp(argv[2], "1") ||
937 !strcmp(argv[2], "true") ||
938 !strcmp(argv[2], "yes"));
939 return OK;
940 }
941
942 if (!strcmp(argv[0], "line-number-interval")) {
943 opt_num_interval = atoi(argv[2]);
944 return OK;
945 }
946
947 if (!strcmp(argv[0], "tab-size")) {
948 opt_tab_size = atoi(argv[2]);
949 return OK;
950 }
951
952 if (!strcmp(argv[0], "encoding")) {
953 string_copy(opt_encoding, argv[2]);
954 return OK;
955 }
956
957 return ERR;
958 }
959
960 /* Wants: mode request key */
961 static int
962 option_bind_command(int argc, char *argv[])
963 {
964 enum request request;
965 int keymap;
966 int key;
967
968 if (argc != 3) {
969 config_msg = "Wrong number of arguments given to bind command";
970 return ERR;
971 }
972
973 if (set_keymap(&keymap, argv[0]) == ERR) {
974 config_msg = "Unknown key map";
975 return ERR;
976 }
977
978 key = get_key_value(argv[1]);
979 if (key == ERR) {
980 config_msg = "Unknown key";
981 return ERR;
982 }
983
984 request = get_request(argv[2]);
985 if (request == REQ_UNKNOWN) {
986 config_msg = "Unknown request name";
987 return ERR;
988 }
989
990 add_keybinding(keymap, request, key);
991
992 return OK;
993 }
994
995 static int
996 set_option(char *opt, char *value)
997 {
998 char *argv[16];
999 int valuelen;
1000 int argc = 0;
1001
1002 /* Tokenize */
1003 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1004 argv[argc++] = value;
1005
1006 value += valuelen;
1007 if (!*value)
1008 break;
1009
1010 *value++ = 0;
1011 while (isspace(*value))
1012 value++;
1013 }
1014
1015 if (!strcmp(opt, "color"))
1016 return option_color_command(argc, argv);
1017
1018 if (!strcmp(opt, "set"))
1019 return option_set_command(argc, argv);
1020
1021 if (!strcmp(opt, "bind"))
1022 return option_bind_command(argc, argv);
1023
1024 return ERR;
1025 }
1026
1027 static int
1028 read_option(char *opt, int optlen, char *value, int valuelen)
1029 {
1030 config_lineno++;
1031 config_msg = "Internal error";
1032
1033 optlen = strcspn(opt, "#;");
1034 if (optlen == 0) {
1035 /* The whole line is a commend or empty. */
1036 return OK;
1037
1038 } else if (opt[optlen] != 0) {
1039 /* Part of the option name is a comment, so the value part
1040 * should be ignored. */
1041 valuelen = 0;
1042 opt[optlen] = value[valuelen] = 0;
1043 } else {
1044 /* Else look for comment endings in the value. */
1045 valuelen = strcspn(value, "#;");
1046 value[valuelen] = 0;
1047 }
1048
1049 if (set_option(opt, value) == ERR) {
1050 fprintf(stderr, "Error on line %d, near '%.*s' option: %s\n",
1051 config_lineno, optlen, opt, config_msg);
1052 config_errors = TRUE;
1053 }
1054
1055 /* Always keep going if errors are encountered. */
1056 return OK;
1057 }
1058
1059 static int
1060 load_options(void)
1061 {
1062 char *home = getenv("HOME");
1063 char buf[1024];
1064 FILE *file;
1065
1066 config_lineno = 0;
1067 config_errors = FALSE;
1068
1069 if (!home || !string_format(buf, "%s/.tigrc", home))
1070 return ERR;
1071
1072 /* It's ok that the file doesn't exist. */
1073 file = fopen(buf, "r");
1074 if (!file)
1075 return OK;
1076
1077 if (read_properties(file, " \t", read_option) == ERR ||
1078 config_errors == TRUE)
1079 fprintf(stderr, "Errors while loading %s.\n", buf);
1080
1081 return OK;
1082 }
1083
1084
1085 /*
1086 * The viewer
1087 */
1088
1089 struct view;
1090 struct view_ops;
1091
1092 /* The display array of active views and the index of the current view. */
1093 static struct view *display[2];
1094 static unsigned int current_view;
1095
1096 #define foreach_view(view, i) \
1097 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1098
1099 #define displayed_views() (display[1] != NULL ? 2 : 1)
1100
1101 /* Current head and commit ID */
1102 static char ref_commit[SIZEOF_REF] = "HEAD";
1103 static char ref_head[SIZEOF_REF] = "HEAD";
1104
1105 struct view {
1106 const char *name; /* View name */
1107 const char *cmd_fmt; /* Default command line format */
1108 const char *cmd_env; /* Command line set via environment */
1109 const char *id; /* Points to either of ref_{head,commit} */
1110
1111 struct view_ops *ops; /* View operations */
1112
1113 enum keymap keymap; /* What keymap does this view have */
1114
1115 char cmd[SIZEOF_CMD]; /* Command buffer */
1116 char ref[SIZEOF_REF]; /* Hovered commit reference */
1117 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1118
1119 int height, width; /* The width and height of the main window */
1120 WINDOW *win; /* The main window */
1121 WINDOW *title; /* The title window living below the main window */
1122
1123 /* Navigation */
1124 unsigned long offset; /* Offset of the window top */
1125 unsigned long lineno; /* Current line number */
1126
1127 /* If non-NULL, points to the view that opened this view. If this view
1128 * is closed tig will switch back to the parent view. */
1129 struct view *parent;
1130
1131 /* Buffering */
1132 unsigned long lines; /* Total number of lines */
1133 struct line *line; /* Line index */
1134 unsigned long line_size;/* Total number of allocated lines */
1135 unsigned int digits; /* Number of digits in the lines member. */
1136
1137 /* Loading */
1138 FILE *pipe;
1139 time_t start_time;
1140 };
1141
1142 struct view_ops {
1143 /* What type of content being displayed. Used in the title bar. */
1144 const char *type;
1145 /* Draw one line; @lineno must be < view->height. */
1146 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1147 /* Read one line; updates view->line. */
1148 bool (*read)(struct view *view, char *data);
1149 /* Depending on view, change display based on current line. */
1150 bool (*enter)(struct view *view, struct line *line);
1151 };
1152
1153 static struct view_ops pager_ops;
1154 static struct view_ops main_ops;
1155
1156 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1157 { name, cmd, #env, ref, ops, map}
1158
1159 #define VIEW_(id, name, ops, ref) \
1160 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1161
1162
1163 static struct view views[] = {
1164 VIEW_(MAIN, "main", &main_ops, ref_head),
1165 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1166 VIEW_(LOG, "log", &pager_ops, ref_head),
1167 VIEW_(HELP, "help", &pager_ops, "static"),
1168 VIEW_(PAGER, "pager", &pager_ops, "static"),
1169 };
1170
1171 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1172
1173
1174 static bool
1175 draw_view_line(struct view *view, unsigned int lineno)
1176 {
1177 if (view->offset + lineno >= view->lines)
1178 return FALSE;
1179
1180 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
1181 }
1182
1183 static void
1184 redraw_view_from(struct view *view, int lineno)
1185 {
1186 assert(0 <= lineno && lineno < view->height);
1187
1188 for (; lineno < view->height; lineno++) {
1189 if (!draw_view_line(view, lineno))
1190 break;
1191 }
1192
1193 redrawwin(view->win);
1194 wrefresh(view->win);
1195 }
1196
1197 static void
1198 redraw_view(struct view *view)
1199 {
1200 wclear(view->win);
1201 redraw_view_from(view, 0);
1202 }
1203
1204
1205 static void
1206 update_view_title(struct view *view)
1207 {
1208 if (view == display[current_view])
1209 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1210 else
1211 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1212
1213 werase(view->title);
1214 wmove(view->title, 0, 0);
1215
1216 if (*view->ref)
1217 wprintw(view->title, "[%s] %s", view->name, view->ref);
1218 else
1219 wprintw(view->title, "[%s]", view->name);
1220
1221 if (view->lines || view->pipe) {
1222 unsigned int view_lines = view->offset + view->height;
1223 unsigned int lines = view->lines
1224 ? MIN(view_lines, view->lines) * 100 / view->lines
1225 : 0;
1226
1227 wprintw(view->title, " - %s %d of %d (%d%%)",
1228 view->ops->type,
1229 view->lineno + 1,
1230 view->lines,
1231 lines);
1232 }
1233
1234 if (view->pipe) {
1235 time_t secs = time(NULL) - view->start_time;
1236
1237 /* Three git seconds are a long time ... */
1238 if (secs > 2)
1239 wprintw(view->title, " %lds", secs);
1240 }
1241
1242 wmove(view->title, 0, view->width - 1);
1243 wrefresh(view->title);
1244 }
1245
1246 static void
1247 resize_display(void)
1248 {
1249 int offset, i;
1250 struct view *base = display[0];
1251 struct view *view = display[1] ? display[1] : display[0];
1252
1253 /* Setup window dimensions */
1254
1255 getmaxyx(stdscr, base->height, base->width);
1256
1257 /* Make room for the status window. */
1258 base->height -= 1;
1259
1260 if (view != base) {
1261 /* Horizontal split. */
1262 view->width = base->width;
1263 view->height = SCALE_SPLIT_VIEW(base->height);
1264 base->height -= view->height;
1265
1266 /* Make room for the title bar. */
1267 view->height -= 1;
1268 }
1269
1270 /* Make room for the title bar. */
1271 base->height -= 1;
1272
1273 offset = 0;
1274
1275 foreach_view (view, i) {
1276 if (!view->win) {
1277 view->win = newwin(view->height, 0, offset, 0);
1278 if (!view->win)
1279 die("Failed to create %s view", view->name);
1280
1281 scrollok(view->win, TRUE);
1282
1283 view->title = newwin(1, 0, offset + view->height, 0);
1284 if (!view->title)
1285 die("Failed to create title window");
1286
1287 } else {
1288 wresize(view->win, view->height, view->width);
1289 mvwin(view->win, offset, 0);
1290 mvwin(view->title, offset + view->height, 0);
1291 }
1292
1293 offset += view->height + 1;
1294 }
1295 }
1296
1297 static void
1298 redraw_display(void)
1299 {
1300 struct view *view;
1301 int i;
1302
1303 foreach_view (view, i) {
1304 redraw_view(view);
1305 update_view_title(view);
1306 }
1307 }
1308
1309 static void
1310 update_display_cursor(void)
1311 {
1312 struct view *view = display[current_view];
1313
1314 /* Move the cursor to the right-most column of the cursor line.
1315 *
1316 * XXX: This could turn out to be a bit expensive, but it ensures that
1317 * the cursor does not jump around. */
1318 if (view->lines) {
1319 wmove(view->win, view->lineno - view->offset, view->width - 1);
1320 wrefresh(view->win);
1321 }
1322 }
1323
1324 /*
1325 * Navigation
1326 */
1327
1328 /* Scrolling backend */
1329 static void
1330 do_scroll_view(struct view *view, int lines, bool redraw)
1331 {
1332 /* The rendering expects the new offset. */
1333 view->offset += lines;
1334
1335 assert(0 <= view->offset && view->offset < view->lines);
1336 assert(lines);
1337
1338 /* Redraw the whole screen if scrolling is pointless. */
1339 if (view->height < ABS(lines)) {
1340 redraw_view(view);
1341
1342 } else {
1343 int line = lines > 0 ? view->height - lines : 0;
1344 int end = line + ABS(lines);
1345
1346 wscrl(view->win, lines);
1347
1348 for (; line < end; line++) {
1349 if (!draw_view_line(view, line))
1350 break;
1351 }
1352 }
1353
1354 /* Move current line into the view. */
1355 if (view->lineno < view->offset) {
1356 view->lineno = view->offset;
1357 draw_view_line(view, 0);
1358
1359 } else if (view->lineno >= view->offset + view->height) {
1360 if (view->lineno == view->offset + view->height) {
1361 /* Clear the hidden line so it doesn't show if the view
1362 * is scrolled up. */
1363 wmove(view->win, view->height, 0);
1364 wclrtoeol(view->win);
1365 }
1366 view->lineno = view->offset + view->height - 1;
1367 draw_view_line(view, view->lineno - view->offset);
1368 }
1369
1370 assert(view->offset <= view->lineno && view->lineno < view->lines);
1371
1372 if (!redraw)
1373 return;
1374
1375 redrawwin(view->win);
1376 wrefresh(view->win);
1377 report("");
1378 }
1379
1380 /* Scroll frontend */
1381 static void
1382 scroll_view(struct view *view, enum request request)
1383 {
1384 int lines = 1;
1385
1386 switch (request) {
1387 case REQ_SCROLL_PAGE_DOWN:
1388 lines = view->height;
1389 case REQ_SCROLL_LINE_DOWN:
1390 if (view->offset + lines > view->lines)
1391 lines = view->lines - view->offset;
1392
1393 if (lines == 0 || view->offset + view->height >= view->lines) {
1394 report("Cannot scroll beyond the last line");
1395 return;
1396 }
1397 break;
1398
1399 case REQ_SCROLL_PAGE_UP:
1400 lines = view->height;
1401 case REQ_SCROLL_LINE_UP:
1402 if (lines > view->offset)
1403 lines = view->offset;
1404
1405 if (lines == 0) {
1406 report("Cannot scroll beyond the first line");
1407 return;
1408 }
1409
1410 lines = -lines;
1411 break;
1412
1413 default:
1414 die("request %d not handled in switch", request);
1415 }
1416
1417 do_scroll_view(view, lines, TRUE);
1418 }
1419
1420 /* Cursor moving */
1421 static void
1422 move_view(struct view *view, enum request request, bool redraw)
1423 {
1424 int steps;
1425
1426 switch (request) {
1427 case REQ_MOVE_FIRST_LINE:
1428 steps = -view->lineno;
1429 break;
1430
1431 case REQ_MOVE_LAST_LINE:
1432 steps = view->lines - view->lineno - 1;
1433 break;
1434
1435 case REQ_MOVE_PAGE_UP:
1436 steps = view->height > view->lineno
1437 ? -view->lineno : -view->height;
1438 break;
1439
1440 case REQ_MOVE_PAGE_DOWN:
1441 steps = view->lineno + view->height >= view->lines
1442 ? view->lines - view->lineno - 1 : view->height;
1443 break;
1444
1445 case REQ_MOVE_UP:
1446 steps = -1;
1447 break;
1448
1449 case REQ_MOVE_DOWN:
1450 steps = 1;
1451 break;
1452
1453 default:
1454 die("request %d not handled in switch", request);
1455 }
1456
1457 if (steps <= 0 && view->lineno == 0) {
1458 report("Cannot move beyond the first line");
1459 return;
1460
1461 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1462 report("Cannot move beyond the last line");
1463 return;
1464 }
1465
1466 /* Move the current line */
1467 view->lineno += steps;
1468 assert(0 <= view->lineno && view->lineno < view->lines);
1469
1470 /* Repaint the old "current" line if we be scrolling */
1471 if (ABS(steps) < view->height) {
1472 int prev_lineno = view->lineno - steps - view->offset;
1473
1474 wmove(view->win, prev_lineno, 0);
1475 wclrtoeol(view->win);
1476 draw_view_line(view, prev_lineno);
1477 }
1478
1479 /* Check whether the view needs to be scrolled */
1480 if (view->lineno < view->offset ||
1481 view->lineno >= view->offset + view->height) {
1482 if (steps < 0 && -steps > view->offset) {
1483 steps = -view->offset;
1484
1485 } else if (steps > 0) {
1486 if (view->lineno == view->lines - 1 &&
1487 view->lines > view->height) {
1488 steps = view->lines - view->offset - 1;
1489 if (steps >= view->height)
1490 steps -= view->height - 1;
1491 }
1492 }
1493
1494 do_scroll_view(view, steps, redraw);
1495 return;
1496 }
1497
1498 /* Draw the current line */
1499 draw_view_line(view, view->lineno - view->offset);
1500
1501 if (!redraw)
1502 return;
1503
1504 redrawwin(view->win);
1505 wrefresh(view->win);
1506 report("");
1507 }
1508
1509
1510 /*
1511 * Incremental updating
1512 */
1513
1514 static void
1515 end_update(struct view *view)
1516 {
1517 if (!view->pipe)
1518 return;
1519 set_nonblocking_input(FALSE);
1520 if (view->pipe == stdin)
1521 fclose(view->pipe);
1522 else
1523 pclose(view->pipe);
1524 view->pipe = NULL;
1525 }
1526
1527 static bool
1528 begin_update(struct view *view)
1529 {
1530 const char *id = view->id;
1531
1532 if (view->pipe)
1533 end_update(view);
1534
1535 if (opt_cmd[0]) {
1536 string_copy(view->cmd, opt_cmd);
1537 opt_cmd[0] = 0;
1538 /* When running random commands, the view ref could have become
1539 * invalid so clear it. */
1540 view->ref[0] = 0;
1541 } else {
1542 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1543
1544 if (!string_format(view->cmd, format, id, id, id, id, id))
1545 return FALSE;
1546 }
1547
1548 /* Special case for the pager view. */
1549 if (opt_pipe) {
1550 view->pipe = opt_pipe;
1551 opt_pipe = NULL;
1552 } else {
1553 view->pipe = popen(view->cmd, "r");
1554 }
1555
1556 if (!view->pipe)
1557 return FALSE;
1558
1559 set_nonblocking_input(TRUE);
1560
1561 view->offset = 0;
1562 view->lines = 0;
1563 view->lineno = 0;
1564 string_copy(view->vid, id);
1565
1566 if (view->line) {
1567 int i;
1568
1569 for (i = 0; i < view->lines; i++)
1570 if (view->line[i].data)
1571 free(view->line[i].data);
1572
1573 free(view->line);
1574 view->line = NULL;
1575 }
1576
1577 view->start_time = time(NULL);
1578
1579 return TRUE;
1580 }
1581
1582 static struct line *
1583 realloc_lines(struct view *view, size_t line_size)
1584 {
1585 struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1586
1587 if (!tmp)
1588 return NULL;
1589
1590 view->line = tmp;
1591 view->line_size = line_size;
1592 return view->line;
1593 }
1594
1595 static bool
1596 update_view(struct view *view)
1597 {
1598 char buffer[BUFSIZ];
1599 char *line;
1600 /* The number of lines to read. If too low it will cause too much
1601 * redrawing (and possible flickering), if too high responsiveness
1602 * will suffer. */
1603 unsigned long lines = view->height;
1604 int redraw_from = -1;
1605
1606 if (!view->pipe)
1607 return TRUE;
1608
1609 /* Only redraw if lines are visible. */
1610 if (view->offset + view->height >= view->lines)
1611 redraw_from = view->lines - view->offset;
1612
1613 if (!realloc_lines(view, view->lines + lines))
1614 goto alloc_error;
1615
1616 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1617 int linelen = strlen(line);
1618
1619 if (linelen)
1620 line[linelen - 1] = 0;
1621
1622 if (!view->ops->read(view, line))
1623 goto alloc_error;
1624
1625 if (lines-- == 1)
1626 break;
1627 }
1628
1629 {
1630 int digits;
1631
1632 lines = view->lines;
1633 for (digits = 0; lines; digits++)
1634 lines /= 10;
1635
1636 /* Keep the displayed view in sync with line number scaling. */
1637 if (digits != view->digits) {
1638 view->digits = digits;
1639 redraw_from = 0;
1640 }
1641 }
1642
1643 if (redraw_from >= 0) {
1644 /* If this is an incremental update, redraw the previous line
1645 * since for commits some members could have changed when
1646 * loading the main view. */
1647 if (redraw_from > 0)
1648 redraw_from--;
1649
1650 /* Incrementally draw avoids flickering. */
1651 redraw_view_from(view, redraw_from);
1652 }
1653
1654 /* Update the title _after_ the redraw so that if the redraw picks up a
1655 * commit reference in view->ref it'll be available here. */
1656 update_view_title(view);
1657
1658 if (ferror(view->pipe)) {
1659 report("Failed to read: %s", strerror(errno));
1660 goto end;
1661
1662 } else if (feof(view->pipe)) {
1663 report("");
1664 goto end;
1665 }
1666
1667 return TRUE;
1668
1669 alloc_error:
1670 report("Allocation failure");
1671
1672 end:
1673 end_update(view);
1674 return FALSE;
1675 }
1676
1677
1678 /*
1679 * View opening
1680 */
1681
1682 static void open_help_view(struct view *view)
1683 {
1684 char buf[BUFSIZ];
1685 int lines = ARRAY_SIZE(req_info) + 2;
1686 int i;
1687
1688 if (view->lines > 0)
1689 return;
1690
1691 for (i = 0; i < ARRAY_SIZE(req_info); i++)
1692 if (!req_info[i].request)
1693 lines++;
1694
1695 view->line = calloc(lines, sizeof(*view->line));
1696 if (!view->line) {
1697 report("Allocation failure");
1698 return;
1699 }
1700
1701 view->ops->read(view, "Quick reference for tig keybindings:");
1702
1703 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
1704 char *key;
1705
1706 if (!req_info[i].request) {
1707 view->ops->read(view, "");
1708 view->ops->read(view, req_info[i].help);
1709 continue;
1710 }
1711
1712 key = get_key(req_info[i].request);
1713 if (!string_format(buf, "%-25s %s", key, req_info[i].help))
1714 continue;
1715
1716 view->ops->read(view, buf);
1717 }
1718 }
1719
1720 enum open_flags {
1721 OPEN_DEFAULT = 0, /* Use default view switching. */
1722 OPEN_SPLIT = 1, /* Split current view. */
1723 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1724 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1725 };
1726
1727 static void
1728 open_view(struct view *prev, enum request request, enum open_flags flags)
1729 {
1730 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1731 bool split = !!(flags & OPEN_SPLIT);
1732 bool reload = !!(flags & OPEN_RELOAD);
1733 struct view *view = VIEW(request);
1734 int nviews = displayed_views();
1735 struct view *base_view = display[0];
1736
1737 if (view == prev && nviews == 1 && !reload) {
1738 report("Already in %s view", view->name);
1739 return;
1740 }
1741
1742 if (view == VIEW(REQ_VIEW_HELP)) {
1743 open_help_view(view);
1744
1745 } else if ((reload || strcmp(view->vid, view->id)) &&
1746 !begin_update(view)) {
1747 report("Failed to load %s view", view->name);
1748 return;
1749 }
1750
1751 if (split) {
1752 display[1] = view;
1753 if (!backgrounded)
1754 current_view = 1;
1755 } else {
1756 /* Maximize the current view. */
1757 memset(display, 0, sizeof(display));
1758 current_view = 0;
1759 display[current_view] = view;
1760 }
1761
1762 /* Resize the view when switching between split- and full-screen,
1763 * or when switching between two different full-screen views. */
1764 if (nviews != displayed_views() ||
1765 (nviews == 1 && base_view != display[0]))
1766 resize_display();
1767
1768 if (split && prev->lineno - prev->offset >= prev->height) {
1769 /* Take the title line into account. */
1770 int lines = prev->lineno - prev->offset - prev->height + 1;
1771
1772 /* Scroll the view that was split if the current line is
1773 * outside the new limited view. */
1774 do_scroll_view(prev, lines, TRUE);
1775 }
1776
1777 if (prev && view != prev) {
1778 if (split && !backgrounded) {
1779 /* "Blur" the previous view. */
1780 update_view_title(prev);
1781 }
1782
1783 view->parent = prev;
1784 }
1785
1786 if (view->pipe && view->lines == 0) {
1787 /* Clear the old view and let the incremental updating refill
1788 * the screen. */
1789 wclear(view->win);
1790 report("");
1791 } else {
1792 redraw_view(view);
1793 report("");
1794 }
1795
1796 /* If the view is backgrounded the above calls to report()
1797 * won't redraw the view title. */
1798 if (backgrounded)
1799 update_view_title(view);
1800 }
1801
1802
1803 /*
1804 * User request switch noodle
1805 */
1806
1807 static int
1808 view_driver(struct view *view, enum request request)
1809 {
1810 int i;
1811
1812 switch (request) {
1813 case REQ_MOVE_UP:
1814 case REQ_MOVE_DOWN:
1815 case REQ_MOVE_PAGE_UP:
1816 case REQ_MOVE_PAGE_DOWN:
1817 case REQ_MOVE_FIRST_LINE:
1818 case REQ_MOVE_LAST_LINE:
1819 move_view(view, request, TRUE);
1820 break;
1821
1822 case REQ_SCROLL_LINE_DOWN:
1823 case REQ_SCROLL_LINE_UP:
1824 case REQ_SCROLL_PAGE_DOWN:
1825 case REQ_SCROLL_PAGE_UP:
1826 scroll_view(view, request);
1827 break;
1828
1829 case REQ_VIEW_MAIN:
1830 case REQ_VIEW_DIFF:
1831 case REQ_VIEW_LOG:
1832 case REQ_VIEW_HELP:
1833 case REQ_VIEW_PAGER:
1834 open_view(view, request, OPEN_DEFAULT);
1835 break;
1836
1837 case REQ_NEXT:
1838 case REQ_PREVIOUS:
1839 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1840
1841 if (view == VIEW(REQ_VIEW_DIFF) &&
1842 view->parent == VIEW(REQ_VIEW_MAIN)) {
1843 bool redraw = display[1] == view;
1844
1845 view = view->parent;
1846 move_view(view, request, redraw);
1847 if (redraw)
1848 update_view_title(view);
1849 } else {
1850 move_view(view, request, TRUE);
1851 break;
1852 }
1853 /* Fall-through */
1854
1855 case REQ_ENTER:
1856 if (!view->lines) {
1857 report("Nothing to enter");
1858 break;
1859 }
1860 return view->ops->enter(view, &view->line[view->lineno]);
1861
1862 case REQ_VIEW_NEXT:
1863 {
1864 int nviews = displayed_views();
1865 int next_view = (current_view + 1) % nviews;
1866
1867 if (next_view == current_view) {
1868 report("Only one view is displayed");
1869 break;
1870 }
1871
1872 current_view = next_view;
1873 /* Blur out the title of the previous view. */
1874 update_view_title(view);
1875 report("");
1876 break;
1877 }
1878 case REQ_TOGGLE_LINENO:
1879 opt_line_number = !opt_line_number;
1880 redraw_display();
1881 break;
1882
1883 case REQ_TOGGLE_REV_GRAPH:
1884 opt_rev_graph = !opt_rev_graph;
1885 redraw_display();
1886 break;
1887
1888 case REQ_PROMPT:
1889 /* Always reload^Wrerun commands from the prompt. */
1890 open_view(view, opt_request, OPEN_RELOAD);
1891 break;
1892
1893 case REQ_STOP_LOADING:
1894 for (i = 0; i < ARRAY_SIZE(views); i++) {
1895 view = &views[i];
1896 if (view->pipe)
1897 report("Stopped loading the %s view", view->name),
1898 end_update(view);
1899 }
1900 break;
1901
1902 case REQ_SHOW_VERSION:
1903 report("%s (built %s)", VERSION, __DATE__);
1904 return TRUE;
1905
1906 case REQ_SCREEN_RESIZE:
1907 resize_display();
1908 /* Fall-through */
1909 case REQ_SCREEN_REDRAW:
1910 redraw_display();
1911 break;
1912
1913 case REQ_SCREEN_UPDATE:
1914 doupdate();
1915 return TRUE;
1916
1917 case REQ_VIEW_CLOSE:
1918 /* XXX: Mark closed views by letting view->parent point to the
1919 * view itself. Parents to closed view should never be
1920 * followed. */
1921 if (view->parent &&
1922 view->parent->parent != view->parent) {
1923 memset(display, 0, sizeof(display));
1924 current_view = 0;
1925 display[current_view] = view->parent;
1926 view->parent = view;
1927 resize_display();
1928 redraw_display();
1929 break;
1930 }
1931 /* Fall-through */
1932 case REQ_QUIT:
1933 return FALSE;
1934
1935 default:
1936 /* An unknown key will show most commonly used commands. */
1937 report("Unknown key, press 'h' for help");
1938 return TRUE;
1939 }
1940
1941 return TRUE;
1942 }
1943
1944
1945 /*
1946 * Pager backend
1947 */
1948
1949 static bool
1950 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1951 {
1952 char *text = line->data;
1953 enum line_type type = line->type;
1954 int textlen = strlen(text);
1955 int attr;
1956
1957 wmove(view->win, lineno, 0);
1958
1959 if (view->offset + lineno == view->lineno) {
1960 if (type == LINE_COMMIT) {
1961 string_copy(view->ref, text + 7);
1962 string_copy(ref_commit, view->ref);
1963 }
1964
1965 type = LINE_CURSOR;
1966 wchgat(view->win, -1, 0, type, NULL);
1967 }
1968
1969 attr = get_line_attr(type);
1970 wattrset(view->win, attr);
1971
1972 if (opt_line_number || opt_tab_size < TABSIZE) {
1973 static char spaces[] = " ";
1974 int col_offset = 0, col = 0;
1975
1976 if (opt_line_number) {
1977 unsigned long real_lineno = view->offset + lineno + 1;
1978
1979 if (real_lineno == 1 ||
1980 (real_lineno % opt_num_interval) == 0) {
1981 wprintw(view->win, "%.*d", view->digits, real_lineno);
1982
1983 } else {
1984 waddnstr(view->win, spaces,
1985 MIN(view->digits, STRING_SIZE(spaces)));
1986 }
1987 waddstr(view->win, ": ");
1988 col_offset = view->digits + 2;
1989 }
1990
1991 while (text && col_offset + col < view->width) {
1992 int cols_max = view->width - col_offset - col;
1993 char *pos = text;
1994 int cols;
1995
1996 if (*text == '\t') {
1997 text++;
1998 assert(sizeof(spaces) > TABSIZE);
1999 pos = spaces;
2000 cols = opt_tab_size - (col % opt_tab_size);
2001
2002 } else {
2003 text = strchr(text, '\t');
2004 cols = line ? text - pos : strlen(pos);
2005 }
2006
2007 waddnstr(view->win, pos, MIN(cols, cols_max));
2008 col += cols;
2009 }
2010
2011 } else {
2012 int col = 0, pos = 0;
2013
2014 for (; pos < textlen && col < view->width; pos++, col++)
2015 if (text[pos] == '\t')
2016 col += TABSIZE - (col % TABSIZE) - 1;
2017
2018 waddnstr(view->win, text, pos);
2019 }
2020
2021 return TRUE;
2022 }
2023
2024 static void
2025 add_pager_refs(struct view *view, struct line *line)
2026 {
2027 char buf[1024];
2028 char *data = line->data;
2029 struct ref **refs;
2030 int bufpos = 0, refpos = 0;
2031 const char *sep = "Refs: ";
2032
2033 assert(line->type == LINE_COMMIT);
2034
2035 refs = get_refs(data + STRING_SIZE("commit "));
2036 if (!refs)
2037 return;
2038
2039 do {
2040 struct ref *ref = refs[refpos];
2041 char *fmt = ref->tag ? "%s[%s]" : "%s%s";
2042
2043 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2044 return;
2045 sep = ", ";
2046 } while (refs[refpos++]->next);
2047
2048 if (!realloc_lines(view, view->line_size + 1))
2049 return;
2050
2051 line = &view->line[view->lines];
2052 line->data = strdup(buf);
2053 if (!line->data)
2054 return;
2055
2056 line->type = LINE_PP_REFS;
2057 view->lines++;
2058 }
2059
2060 static bool
2061 pager_read(struct view *view, char *data)
2062 {
2063 struct line *line = &view->line[view->lines];
2064
2065 line->data = strdup(data);
2066 if (!line->data)
2067 return FALSE;
2068
2069 line->type = get_line_type(line->data);
2070 view->lines++;
2071
2072 if (line->type == LINE_COMMIT &&
2073 (view == VIEW(REQ_VIEW_DIFF) ||
2074 view == VIEW(REQ_VIEW_LOG)))
2075 add_pager_refs(view, line);
2076
2077 return TRUE;
2078 }
2079
2080 static bool
2081 pager_enter(struct view *view, struct line *line)
2082 {
2083 int split = 0;
2084
2085 if (line->type == LINE_COMMIT &&
2086 (view == VIEW(REQ_VIEW_LOG) ||
2087 view == VIEW(REQ_VIEW_PAGER))) {
2088 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2089 split = 1;
2090 }
2091
2092 /* Always scroll the view even if it was split. That way
2093 * you can use Enter to scroll through the log view and
2094 * split open each commit diff. */
2095 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2096
2097 /* FIXME: A minor workaround. Scrolling the view will call report("")
2098 * but if we are scrolling a non-current view this won't properly
2099 * update the view title. */
2100 if (split)
2101 update_view_title(view);
2102
2103 return TRUE;
2104 }
2105
2106 static struct view_ops pager_ops = {
2107 "line",
2108 pager_draw,
2109 pager_read,
2110 pager_enter,
2111 };
2112
2113
2114 /*
2115 * Main view backend
2116 */
2117
2118 struct commit {
2119 char id[41]; /* SHA1 ID. */
2120 char title[75]; /* First line of the commit message. */
2121 char author[75]; /* Author of the commit. */
2122 struct tm time; /* Date from the author ident. */
2123 struct ref **refs; /* Repository references. */
2124 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
2125 size_t graph_size; /* The width of the graph array. */
2126 };
2127
2128 static bool
2129 main_draw(struct view *view, struct line *line, unsigned int lineno)
2130 {
2131 char buf[DATE_COLS + 1];
2132 struct commit *commit = line->data;
2133 enum line_type type;
2134 int col = 0;
2135 size_t timelen;
2136 size_t authorlen;
2137 int trimmed = 1;
2138
2139 if (!*commit->author)
2140 return FALSE;
2141
2142 wmove(view->win, lineno, col);
2143
2144 if (view->offset + lineno == view->lineno) {
2145 string_copy(view->ref, commit->id);
2146 string_copy(ref_commit, view->ref);
2147 type = LINE_CURSOR;
2148 wattrset(view->win, get_line_attr(type));
2149 wchgat(view->win, -1, 0, type, NULL);
2150
2151 } else {
2152 type = LINE_MAIN_COMMIT;
2153 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
2154 }
2155
2156 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
2157 waddnstr(view->win, buf, timelen);
2158 waddstr(view->win, " ");
2159
2160 col += DATE_COLS;
2161 wmove(view->win, lineno, col);
2162 if (type != LINE_CURSOR)
2163 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
2164
2165 if (opt_utf8) {
2166 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2167 } else {
2168 authorlen = strlen(commit->author);
2169 if (authorlen > AUTHOR_COLS - 2) {
2170 authorlen = AUTHOR_COLS - 2;
2171 trimmed = 1;
2172 }
2173 }
2174
2175 if (trimmed) {
2176 waddnstr(view->win, commit->author, authorlen);
2177 if (type != LINE_CURSOR)
2178 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2179 waddch(view->win, '~');
2180 } else {
2181 waddstr(view->win, commit->author);
2182 }
2183
2184 col += AUTHOR_COLS;
2185 if (type != LINE_CURSOR)
2186 wattrset(view->win, A_NORMAL);
2187
2188 if (opt_rev_graph && commit->graph_size) {
2189 size_t i;
2190
2191 wmove(view->win, lineno, col);
2192 /* Using waddch() instead of waddnstr() ensures that
2193 * they'll be rendered correctly for the cursor line. */
2194 for (i = 0; i < commit->graph_size; i++)
2195 waddch(view->win, commit->graph[i]);
2196
2197 col += commit->graph_size + 1;
2198 }
2199
2200 wmove(view->win, lineno, col);
2201
2202 if (commit->refs) {
2203 size_t i = 0;
2204
2205 do {
2206 if (type == LINE_CURSOR)
2207 ;
2208 else if (commit->refs[i]->tag)
2209 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2210 else
2211 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2212 waddstr(view->win, "[");
2213 waddstr(view->win, commit->refs[i]->name);
2214 waddstr(view->win, "]");
2215 if (type != LINE_CURSOR)
2216 wattrset(view->win, A_NORMAL);
2217 waddstr(view->win, " ");
2218 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2219 } while (commit->refs[i++]->next);
2220 }
2221
2222 if (type != LINE_CURSOR)
2223 wattrset(view->win, get_line_attr(type));
2224
2225 {
2226 int titlelen = strlen(commit->title);
2227
2228 if (col + titlelen > view->width)
2229 titlelen = view->width - col;
2230
2231 waddnstr(view->win, commit->title, titlelen);
2232 }
2233
2234 return TRUE;
2235 }
2236
2237 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2238 static bool
2239 main_read(struct view *view, char *line)
2240 {
2241 enum line_type type = get_line_type(line);
2242 struct commit *commit = view->lines
2243 ? view->line[view->lines - 1].data : NULL;
2244
2245 switch (type) {
2246 case LINE_COMMIT:
2247 commit = calloc(1, sizeof(struct commit));
2248 if (!commit)
2249 return FALSE;
2250
2251 line += STRING_SIZE("commit ");
2252
2253 view->line[view->lines++].data = commit;
2254 string_copy(commit->id, line);
2255 commit->refs = get_refs(commit->id);
2256 commit->graph[commit->graph_size++] = ACS_LTEE;
2257 break;
2258
2259 case LINE_AUTHOR:
2260 {
2261 char *ident = line + STRING_SIZE("author ");
2262 char *end = strchr(ident, '<');
2263
2264 if (!commit)
2265 break;
2266
2267 if (end) {
2268 for (; end > ident && isspace(end[-1]); end--) ;
2269 *end = 0;
2270 }
2271
2272 string_copy(commit->author, ident);
2273
2274 /* Parse epoch and timezone */
2275 if (end) {
2276 char *secs = strchr(end + 1, '>');
2277 char *zone;
2278 time_t time;
2279
2280 if (!secs || secs[1] != ' ')
2281 break;
2282
2283 secs += 2;
2284 time = (time_t) atol(secs);
2285 zone = strchr(secs, ' ');
2286 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2287 long tz;
2288
2289 zone++;
2290 tz = ('0' - zone[1]) * 60 * 60 * 10;
2291 tz += ('0' - zone[2]) * 60 * 60;
2292 tz += ('0' - zone[3]) * 60;
2293 tz += ('0' - zone[4]) * 60;
2294
2295 if (zone[0] == '-')
2296 tz = -tz;
2297
2298 time -= tz;
2299 }
2300 gmtime_r(&time, &commit->time);
2301 }
2302 break;
2303 }
2304 default:
2305 if (!commit)
2306 break;
2307
2308 /* Fill in the commit title if it has not already been set. */
2309 if (commit->title[0])
2310 break;
2311
2312 /* Require titles to start with a non-space character at the
2313 * offset used by git log. */
2314 /* FIXME: More gracefull handling of titles; append "..." to
2315 * shortened titles, etc. */
2316 if (strncmp(line, " ", 4) ||
2317 isspace(line[4]))
2318 break;
2319
2320 string_copy(commit->title, line + 4);
2321 }
2322
2323 return TRUE;
2324 }
2325
2326 static bool
2327 main_enter(struct view *view, struct line *line)
2328 {
2329 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2330
2331 open_view(view, REQ_VIEW_DIFF, flags);
2332 return TRUE;
2333 }
2334
2335 static struct view_ops main_ops = {
2336 "commit",
2337 main_draw,
2338 main_read,
2339 main_enter,
2340 };
2341
2342
2343 /*
2344 * Unicode / UTF-8 handling
2345 *
2346 * NOTE: Much of the following code for dealing with unicode is derived from
2347 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2348 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2349 */
2350
2351 /* I've (over)annotated a lot of code snippets because I am not entirely
2352 * confident that the approach taken by this small UTF-8 interface is correct.
2353 * --jonas */
2354
2355 static inline int
2356 unicode_width(unsigned long c)
2357 {
2358 if (c >= 0x1100 &&
2359 (c <= 0x115f /* Hangul Jamo */
2360 || c == 0x2329
2361 || c == 0x232a
2362 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2363 /* CJK ... Yi */
2364 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2365 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2366 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2367 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2368 || (c >= 0xffe0 && c <= 0xffe6)
2369 || (c >= 0x20000 && c <= 0x2fffd)
2370 || (c >= 0x30000 && c <= 0x3fffd)))
2371 return 2;
2372
2373 return 1;
2374 }
2375
2376 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2377 * Illegal bytes are set one. */
2378 static const unsigned char utf8_bytes[256] = {
2379 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2380 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2381 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2382 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2383 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2384 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2385 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,
2386 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,
2387 };
2388
2389 /* Decode UTF-8 multi-byte representation into a unicode character. */
2390 static inline unsigned long
2391 utf8_to_unicode(const char *string, size_t length)
2392 {
2393 unsigned long unicode;
2394
2395 switch (length) {
2396 case 1:
2397 unicode = string[0];
2398 break;
2399 case 2:
2400 unicode = (string[0] & 0x1f) << 6;
2401 unicode += (string[1] & 0x3f);
2402 break;
2403 case 3:
2404 unicode = (string[0] & 0x0f) << 12;
2405 unicode += ((string[1] & 0x3f) << 6);
2406 unicode += (string[2] & 0x3f);
2407 break;
2408 case 4:
2409 unicode = (string[0] & 0x0f) << 18;
2410 unicode += ((string[1] & 0x3f) << 12);
2411 unicode += ((string[2] & 0x3f) << 6);
2412 unicode += (string[3] & 0x3f);
2413 break;
2414 case 5:
2415 unicode = (string[0] & 0x0f) << 24;
2416 unicode += ((string[1] & 0x3f) << 18);
2417 unicode += ((string[2] & 0x3f) << 12);
2418 unicode += ((string[3] & 0x3f) << 6);
2419 unicode += (string[4] & 0x3f);
2420 break;
2421 case 6:
2422 unicode = (string[0] & 0x01) << 30;
2423 unicode += ((string[1] & 0x3f) << 24);
2424 unicode += ((string[2] & 0x3f) << 18);
2425 unicode += ((string[3] & 0x3f) << 12);
2426 unicode += ((string[4] & 0x3f) << 6);
2427 unicode += (string[5] & 0x3f);
2428 break;
2429 default:
2430 die("Invalid unicode length");
2431 }
2432
2433 /* Invalid characters could return the special 0xfffd value but NUL
2434 * should be just as good. */
2435 return unicode > 0xffff ? 0 : unicode;
2436 }
2437
2438 /* Calculates how much of string can be shown within the given maximum width
2439 * and sets trimmed parameter to non-zero value if all of string could not be
2440 * shown.
2441 *
2442 * Additionally, adds to coloffset how many many columns to move to align with
2443 * the expected position. Takes into account how multi-byte and double-width
2444 * characters will effect the cursor position.
2445 *
2446 * Returns the number of bytes to output from string to satisfy max_width. */
2447 static size_t
2448 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2449 {
2450 const char *start = string;
2451 const char *end = strchr(string, '\0');
2452 size_t mbwidth = 0;
2453 size_t width = 0;
2454
2455 *trimmed = 0;
2456
2457 while (string < end) {
2458 int c = *(unsigned char *) string;
2459 unsigned char bytes = utf8_bytes[c];
2460 size_t ucwidth;
2461 unsigned long unicode;
2462
2463 if (string + bytes > end)
2464 break;
2465
2466 /* Change representation to figure out whether
2467 * it is a single- or double-width character. */
2468
2469 unicode = utf8_to_unicode(string, bytes);
2470 /* FIXME: Graceful handling of invalid unicode character. */
2471 if (!unicode)
2472 break;
2473
2474 ucwidth = unicode_width(unicode);
2475 width += ucwidth;
2476 if (width > max_width) {
2477 *trimmed = 1;
2478 break;
2479 }
2480
2481 /* The column offset collects the differences between the
2482 * number of bytes encoding a character and the number of
2483 * columns will be used for rendering said character.
2484 *
2485 * So if some character A is encoded in 2 bytes, but will be
2486 * represented on the screen using only 1 byte this will and up
2487 * adding 1 to the multi-byte column offset.
2488 *
2489 * Assumes that no double-width character can be encoding in
2490 * less than two bytes. */
2491 if (bytes > ucwidth)
2492 mbwidth += bytes - ucwidth;
2493
2494 string += bytes;
2495 }
2496
2497 *coloffset += mbwidth;
2498
2499 return string - start;
2500 }
2501
2502
2503 /*
2504 * Status management
2505 */
2506
2507 /* Whether or not the curses interface has been initialized. */
2508 static bool cursed = FALSE;
2509
2510 /* The status window is used for polling keystrokes. */
2511 static WINDOW *status_win;
2512
2513 /* Update status and title window. */
2514 static void
2515 report(const char *msg, ...)
2516 {
2517 static bool empty = TRUE;
2518 struct view *view = display[current_view];
2519
2520 if (!empty || *msg) {
2521 va_list args;
2522
2523 va_start(args, msg);
2524
2525 werase(status_win);
2526 wmove(status_win, 0, 0);
2527 if (*msg) {
2528 vwprintw(status_win, msg, args);
2529 empty = FALSE;
2530 } else {
2531 empty = TRUE;
2532 }
2533 wrefresh(status_win);
2534
2535 va_end(args);
2536 }
2537
2538 update_view_title(view);
2539 update_display_cursor();
2540 }
2541
2542 /* Controls when nodelay should be in effect when polling user input. */
2543 static void
2544 set_nonblocking_input(bool loading)
2545 {
2546 static unsigned int loading_views;
2547
2548 if ((loading == FALSE && loading_views-- == 1) ||
2549 (loading == TRUE && loading_views++ == 0))
2550 nodelay(status_win, loading);
2551 }
2552
2553 static void
2554 init_display(void)
2555 {
2556 int x, y;
2557
2558 /* Initialize the curses library */
2559 if (isatty(STDIN_FILENO)) {
2560 cursed = !!initscr();
2561 } else {
2562 /* Leave stdin and stdout alone when acting as a pager. */
2563 FILE *io = fopen("/dev/tty", "r+");
2564
2565 cursed = !!newterm(NULL, io, io);
2566 }
2567
2568 if (!cursed)
2569 die("Failed to initialize curses");
2570
2571 nonl(); /* Tell curses not to do NL->CR/NL on output */
2572 cbreak(); /* Take input chars one at a time, no wait for \n */
2573 noecho(); /* Don't echo input */
2574 leaveok(stdscr, TRUE);
2575
2576 if (has_colors())
2577 init_colors();
2578
2579 getmaxyx(stdscr, y, x);
2580 status_win = newwin(1, 0, y - 1, 0);
2581 if (!status_win)
2582 die("Failed to create status window");
2583
2584 /* Enable keyboard mapping */
2585 keypad(status_win, TRUE);
2586 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2587 }
2588
2589
2590 /*
2591 * Repository references
2592 */
2593
2594 static struct ref *refs;
2595 static size_t refs_size;
2596
2597 /* Id <-> ref store */
2598 static struct ref ***id_refs;
2599 static size_t id_refs_size;
2600
2601 static struct ref **
2602 get_refs(char *id)
2603 {
2604 struct ref ***tmp_id_refs;
2605 struct ref **ref_list = NULL;
2606 size_t ref_list_size = 0;
2607 size_t i;
2608
2609 for (i = 0; i < id_refs_size; i++)
2610 if (!strcmp(id, id_refs[i][0]->id))
2611 return id_refs[i];
2612
2613 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2614 if (!tmp_id_refs)
2615 return NULL;
2616
2617 id_refs = tmp_id_refs;
2618
2619 for (i = 0; i < refs_size; i++) {
2620 struct ref **tmp;
2621
2622 if (strcmp(id, refs[i].id))
2623 continue;
2624
2625 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2626 if (!tmp) {
2627 if (ref_list)
2628 free(ref_list);
2629 return NULL;
2630 }
2631
2632 ref_list = tmp;
2633 if (ref_list_size > 0)
2634 ref_list[ref_list_size - 1]->next = 1;
2635 ref_list[ref_list_size] = &refs[i];
2636
2637 /* XXX: The properties of the commit chains ensures that we can
2638 * safely modify the shared ref. The repo references will
2639 * always be similar for the same id. */
2640 ref_list[ref_list_size]->next = 0;
2641 ref_list_size++;
2642 }
2643
2644 if (ref_list)
2645 id_refs[id_refs_size++] = ref_list;
2646
2647 return ref_list;
2648 }
2649
2650 static int
2651 read_ref(char *id, int idlen, char *name, int namelen)
2652 {
2653 struct ref *ref;
2654 bool tag = FALSE;
2655
2656 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2657 /* Commits referenced by tags has "^{}" appended. */
2658 if (name[namelen - 1] != '}')
2659 return OK;
2660
2661 while (namelen > 0 && name[namelen] != '^')
2662 namelen--;
2663
2664 tag = TRUE;
2665 namelen -= STRING_SIZE("refs/tags/");
2666 name += STRING_SIZE("refs/tags/");
2667
2668 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2669 namelen -= STRING_SIZE("refs/heads/");
2670 name += STRING_SIZE("refs/heads/");
2671
2672 } else if (!strcmp(name, "HEAD")) {
2673 return OK;
2674 }
2675
2676 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2677 if (!refs)
2678 return ERR;
2679
2680 ref = &refs[refs_size++];
2681 ref->name = malloc(namelen + 1);
2682 if (!ref->name)
2683 return ERR;
2684
2685 strncpy(ref->name, name, namelen);
2686 ref->name[namelen] = 0;
2687 ref->tag = tag;
2688 string_copy(ref->id, id);
2689
2690 return OK;
2691 }
2692
2693 static int
2694 load_refs(void)
2695 {
2696 const char *cmd_env = getenv("TIG_LS_REMOTE");
2697 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2698
2699 return read_properties(popen(cmd, "r"), "\t", read_ref);
2700 }
2701
2702 static int
2703 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2704 {
2705 if (!strcmp(name, "i18n.commitencoding"))
2706 string_copy(opt_encoding, value);
2707
2708 return OK;
2709 }
2710
2711 static int
2712 load_repo_config(void)
2713 {
2714 return read_properties(popen("git repo-config --list", "r"),
2715 "=", read_repo_config_option);
2716 }
2717
2718 static int
2719 read_properties(FILE *pipe, const char *separators,
2720 int (*read_property)(char *, int, char *, int))
2721 {
2722 char buffer[BUFSIZ];
2723 char *name;
2724 int state = OK;
2725
2726 if (!pipe)
2727 return ERR;
2728
2729 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2730 char *value;
2731 size_t namelen;
2732 size_t valuelen;
2733
2734 name = chomp_string(name);
2735 namelen = strcspn(name, separators);
2736
2737 if (name[namelen]) {
2738 name[namelen] = 0;
2739 value = chomp_string(name + namelen + 1);
2740 valuelen = strlen(value);
2741
2742 } else {
2743 value = "";
2744 valuelen = 0;
2745 }
2746
2747 state = read_property(name, namelen, value, valuelen);
2748 }
2749
2750 if (state != ERR && ferror(pipe))
2751 state = ERR;
2752
2753 pclose(pipe);
2754
2755 return state;
2756 }
2757
2758
2759 /*
2760 * Main
2761 */
2762
2763 static void __NORETURN
2764 quit(int sig)
2765 {
2766 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2767 if (cursed)
2768 endwin();
2769 exit(0);
2770 }
2771
2772 static void __NORETURN
2773 die(const char *err, ...)
2774 {
2775 va_list args;
2776
2777 endwin();
2778
2779 va_start(args, err);
2780 fputs("tig: ", stderr);
2781 vfprintf(stderr, err, args);
2782 fputs("\n", stderr);
2783 va_end(args);
2784
2785 exit(1);
2786 }
2787
2788 int
2789 main(int argc, char *argv[])
2790 {
2791 struct view *view;
2792 enum request request;
2793 size_t i;
2794
2795 signal(SIGINT, quit);
2796
2797 if (load_options() == ERR)
2798 die("Failed to load user config.");
2799
2800 /* Load the repo config file so options can be overwritten from
2801 * the command line. */
2802 if (load_repo_config() == ERR)
2803 die("Failed to load repo config.");
2804
2805 if (!parse_options(argc, argv))
2806 return 0;
2807
2808 if (load_refs() == ERR)
2809 die("Failed to load refs.");
2810
2811 /* Require a git repository unless when running in pager mode. */
2812 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2813 die("Not a git repository");
2814
2815 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2816 view->cmd_env = getenv(view->cmd_env);
2817
2818 request = opt_request;
2819
2820 init_display();
2821
2822 while (view_driver(display[current_view], request)) {
2823 int key;
2824 int i;
2825
2826 foreach_view (view, i)
2827 update_view(view);
2828
2829 /* Refresh, accept single keystroke of input */
2830 key = wgetch(status_win);
2831
2832 request = get_keybinding(display[current_view]->keymap, key);
2833
2834 /* Some low-level request handling. This keeps access to
2835 * status_win restricted. */
2836 switch (request) {
2837 case REQ_PROMPT:
2838 report(":");
2839 /* Temporarily switch to line-oriented and echoed
2840 * input. */
2841 nocbreak();
2842 echo();
2843
2844 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2845 memcpy(opt_cmd, "git ", 4);
2846 opt_request = REQ_VIEW_PAGER;
2847 } else {
2848 report("Prompt interrupted by loading view, "
2849 "press 'z' to stop loading views");
2850 request = REQ_SCREEN_UPDATE;
2851 }
2852
2853 noecho();
2854 cbreak();
2855 break;
2856
2857 case REQ_SCREEN_RESIZE:
2858 {
2859 int height, width;
2860
2861 getmaxyx(stdscr, height, width);
2862
2863 /* Resize the status view and let the view driver take
2864 * care of resizing the displayed views. */
2865 wresize(status_win, 1, width);
2866 mvwin(status_win, height - 1, 0);
2867 wrefresh(status_win);
2868 break;
2869 }
2870 default:
2871 break;
2872 }
2873 }
2874
2875 quit(0);
2876
2877 return 0;
2878 }
Full-screen terminal Git browser.