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