~mdw / tig / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update_display_cursor: take view as arg
[tig] / tig.c
CommitLineData
4a2909a7 1/* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
192d9a60 2 *
5cfbde75
JF		 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.
192d9a60
JF		 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 */
b801d8b2 13
b76c2afc 14#ifndef VERSION
0f11e3a9 15#define VERSION "tig-0.4.git"
b76c2afc
JF		 16#endif
17
8855ada4
JF		 18#ifndef DEBUG
19#define NDEBUG
20#endif
21
22f66b0a 22#include <assert.h>
4c6fabc2 23#include <errno.h>
22f66b0a
JF		 24#include <ctype.h>
25#include <signal.h>
b801d8b2 26#include <stdarg.h>
b801d8b2 27#include <stdio.h>
22f66b0a 28#include <stdlib.h>
b801d8b2 29#include <string.h>
6908bdbd 30#include <unistd.h>
b76c2afc 31#include <time.h>
b801d8b2 32
4af34daa
JF		 33#include <sys/types.h>
34#include <regex.h>
35
6b68fd24
JF		 36#include <locale.h>
37#include <langinfo.h>
38#include <iconv.h>
39
b801d8b2 40#include <curses.h>
b801d8b2 41
e2da526d
JF		 42#if __GNUC__ >= 3
43#define __NORETURN __attribute__((__noreturn__))
44#else
45#define __NORETURN
46#endif
47
48static void __NORETURN die(const char *err, ...);
b801d8b2 49static void report(const char *msg, ...);
4a63c884 50static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
1ba2ae4b 51static void set_nonblocking_input(bool loading);
10e290ee 52static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
6b161b31
JF		 53
54#define ABS(x) ((x) >= 0 ? (x) : -(x))
55#define MIN(x, y) ((x) < (y) ? (x) : (y))
56
57#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
58#define STRING_SIZE(x) (sizeof(x) - 1)
b76c2afc 59
17482b11 60#define SIZEOF_STR 1024 /* Default string size. */
2e8488b4 61#define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
10446330 62#define SIZEOF_REV 41 /* Holds a SHA-1 and an ending NUL */
54efb62b 63#define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */
b801d8b2 64
82e78006
JF		 65/* This color name can be used to refer to the default term colors. */
66#define COLOR_DEFAULT (-1)
78c70acd 67
6b68fd24
JF		 68#define ICONV_NONE ((iconv_t) -1)
69
82e78006 70/* The format and size of the date column in the main view. */
4c6fabc2 71#define DATE_FORMAT "%Y-%m-%d %H:%M"
6b161b31 72#define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
4c6fabc2 73
10e290ee
JF		 74#define AUTHOR_COLS 20
75
a28bcc22 76/* The default interval between line numbers. */
4a2909a7 77#define NUMBER_INTERVAL 1
82e78006 78
6706b2ba
JF		 79#define TABSIZE 8
80
a28bcc22
JF		 81#define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
82
8eb62770
JF		 83#define TIG_LS_REMOTE \
84 "git ls-remote . 2>/dev/null"
85
86#define TIG_DIFF_CMD \
73fb51d5 87 "git show --root --patch-with-stat --find-copies-harder -B -C %s 2>/dev/null"
8eb62770
JF		 88
89#define TIG_LOG_CMD \
8fee6614 90 "git log --cc --stat -n100 %s 2>/dev/null"
8eb62770
JF		 91
92#define TIG_MAIN_CMD \
8fee6614 93 "git log --topo-order --pretty=raw %s 2>/dev/null"
8eb62770 94
e733ee54
JF		 95#define TIG_TREE_CMD \
96 "git ls-tree %s %s"
97
98#define TIG_BLOB_CMD \
99 "git cat-file blob %s"
100
8eb62770
JF		 101/* XXX: Needs to be defined to the empty string. */
102#define TIG_HELP_CMD ""
103#define TIG_PAGER_CMD ""
104
8855ada4 105/* Some ascii-shorthands fitted into the ncurses namespace. */
a28bcc22
JF		 106#define KEY_TAB '\t'
107#define KEY_RETURN '\r'
4a2909a7
JF		 108#define KEY_ESC 27
109
6706b2ba 110
c34d9c9f 111struct ref {
468876c9 112 char *name; /* Ref name; tag or head names are shortened. */
10446330 113 char id[SIZEOF_REV]; /* Commit SHA1 ID */
468876c9
JF		 114 unsigned int tag:1; /* Is it a tag? */
115 unsigned int next:1; /* For ref lists: are there more refs? */
c34d9c9f
JF		 116};
117
ff26aa29 118static struct ref **get_refs(char *id);
4c6fabc2 119
660e09ad
JF		 120struct int_map {
121 const char *name;
122 int namelen;
123 int value;
124};
125
126static int
127set_from_int_map(struct int_map *map, size_t map_size,
128 int *value, const char *name, int namelen)
129{
130
131 int i;
132
133 for (i = 0; i < map_size; i++)
134 if (namelen == map[i].namelen &&
135 !strncasecmp(name, map[i].name, namelen)) {
136 *value = map[i].value;
137 return OK;
138 }
139
140 return ERR;
141}
142
6706b2ba 143
03a93dbb
JF		 144/*
145 * String helpers
146 */
78c70acd 147
82e78006 148static inline void
9a48919b 149string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
82e78006 150{
9a48919b
JF		 151 if (srclen > dstlen - 1)
152 srclen = dstlen - 1;
03a93dbb 153
9a48919b
JF		 154 strncpy(dst, src, srclen);
155 dst[srclen] = 0;
82e78006
JF		 156}
157
9a48919b
JF		 158/* Shorthands for safely copying into a fixed buffer. */
159
82e78006 160#define string_copy(dst, src) \
9a48919b
JF		 161 string_ncopy_do(dst, sizeof(dst), src, sizeof(dst))
162
163#define string_ncopy(dst, src, srclen) \
164 string_ncopy_do(dst, sizeof(dst), src, srclen)
82e78006 165
4a63c884
JF		 166static char *
167chomp_string(char *name)
168{
169 int namelen;
170
171 while (isspace(*name))
172 name++;
173
174 namelen = strlen(name) - 1;
175 while (namelen > 0 && isspace(name[namelen]))
176 name[namelen--] = 0;
177
178 return name;
179}
180
cc2d1364 181static bool
d65ced0d 182string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
cc2d1364
JF		 183{
184 va_list args;
d65ced0d 185 size_t pos = bufpos ? *bufpos : 0;
cc2d1364
JF		 186
187 va_start(args, fmt);
188 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
189 va_end(args);
190
191 if (bufpos)
192 *bufpos = pos;
193
194 return pos >= bufsize ? FALSE : TRUE;
195}
196
197#define string_format(buf, fmt, args...) \
198 string_nformat(buf, sizeof(buf), NULL, fmt, args)
199
200#define string_format_from(buf, from, fmt, args...) \
201 string_nformat(buf, sizeof(buf), from, fmt, args)
6706b2ba 202
201f5a18
JF		 203static int
204string_enum_compare(const char *str1, const char *str2, int len)
205{
206 size_t i;
207
208#define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
209
210 /* Diff-Header == DIFF_HEADER */
211 for (i = 0; i < len; i++) {
212 if (toupper(str1[i]) == toupper(str2[i]))
213 continue;
214
215 if (string_enum_sep(str1[i]) &&
216 string_enum_sep(str2[i]))
217 continue;
218
219 return str1[i] - str2[i];
220 }
221
222 return 0;
223}
224
03a93dbb
JF		 225/* Shell quoting
226 *
227 * NOTE: The following is a slightly modified copy of the git project's shell
228 * quoting routines found in the quote.c file.
229 *
230 * Help to copy the thing properly quoted for the shell safety. any single
231 * quote is replaced with '\'', any exclamation point is replaced with '\!',
232 * and the whole thing is enclosed in a
233 *
234 * E.g.
235 * original sq_quote result
236 * name ==> name ==> 'name'
237 * a b ==> a b ==> 'a b'
238 * a'b ==> a'\''b ==> 'a'\''b'
239 * a!b ==> a'\!'b ==> 'a'\!'b'
240 */
241
242static size_t
17482b11 243sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src)
03a93dbb
JF		 244{
245 char c;
246
17482b11 247#define BUFPUT(x) do { if (bufsize < SIZEOF_STR) buf[bufsize++] = (x); } while (0)
03a93dbb
JF		 248
249 BUFPUT('\'');
250 while ((c = *src++)) {
251 if (c == '\'' || c == '!') {
252 BUFPUT('\'');
253 BUFPUT('\\');
254 BUFPUT(c);
255 BUFPUT('\'');
256 } else {
257 BUFPUT(c);
258 }
259 }
260 BUFPUT('\'');
261
262 return bufsize;
263}
264
82e78006 265
24b5b3e0
JF		 266/*
267 * User requests
268 */
269
270#define REQ_INFO \
271 /* XXX: Keep the view request first and in sync with views[]. */ \
272 REQ_GROUP("View switching") \
273 REQ_(VIEW_MAIN, "Show main view"), \
274 REQ_(VIEW_DIFF, "Show diff view"), \
275 REQ_(VIEW_LOG, "Show log view"), \
e733ee54
JF		 276 REQ_(VIEW_TREE, "Show tree view"), \
277 REQ_(VIEW_BLOB, "Show blob view"), \
24b5b3e0
JF		 278 REQ_(VIEW_HELP, "Show help page"), \
279 REQ_(VIEW_PAGER, "Show pager view"), \
280 \
281 REQ_GROUP("View manipulation") \
282 REQ_(ENTER, "Enter current line and scroll"), \
283 REQ_(NEXT, "Move to next"), \
284 REQ_(PREVIOUS, "Move to previous"), \
285 REQ_(VIEW_NEXT, "Move focus to next view"), \
286 REQ_(VIEW_CLOSE, "Close the current view"), \
287 REQ_(QUIT, "Close all views and quit"), \
288 \
289 REQ_GROUP("Cursor navigation") \
290 REQ_(MOVE_UP, "Move cursor one line up"), \
291 REQ_(MOVE_DOWN, "Move cursor one line down"), \
292 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
293 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
294 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
295 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
296 \
297 REQ_GROUP("Scrolling") \
298 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
299 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
300 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
301 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
302 \
4af34daa
JF		 303 REQ_GROUP("Searching") \
304 REQ_(SEARCH, "Search the view"), \
305 REQ_(SEARCH_BACK, "Search backwards in the view"), \
306 REQ_(FIND_NEXT, "Find next search match"), \
307 REQ_(FIND_PREV, "Find previous search match"), \
308 \
24b5b3e0 309 REQ_GROUP("Misc") \
1d754561 310 REQ_(NONE, "Do nothing"), \
24b5b3e0 311 REQ_(PROMPT, "Bring up the prompt"), \
24b5b3e0
JF		 312 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
313 REQ_(SCREEN_RESIZE, "Resize the screen"), \
314 REQ_(SHOW_VERSION, "Show version information"), \
315 REQ_(STOP_LOADING, "Stop all loading views"), \
54efb62b 316 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
04e2b7b2 317 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization")
24b5b3e0
JF		 318
319
320/* User action requests. */
321enum request {
322#define REQ_GROUP(help)
323#define REQ_(req, help) REQ_##req
324
325 /* Offset all requests to avoid conflicts with ncurses getch values. */
326 REQ_OFFSET = KEY_MAX + 1,
04e2b7b2
JF		 327 REQ_INFO,
328 REQ_UNKNOWN,
24b5b3e0
JF		 329
330#undef REQ_GROUP
331#undef REQ_
332};
333
334struct request_info {
335 enum request request;
04e2b7b2
JF		 336 char *name;
337 int namelen;
24b5b3e0
JF		 338 char *help;
339};
340
341static struct request_info req_info[] = {
04e2b7b2
JF		 342#define REQ_GROUP(help) { 0, NULL, 0, (help) },
343#define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
24b5b3e0
JF		 344 REQ_INFO
345#undef REQ_GROUP
346#undef REQ_
347};
348
04e2b7b2
JF		 349static enum request
350get_request(const char *name)
351{
352 int namelen = strlen(name);
353 int i;
354
355 for (i = 0; i < ARRAY_SIZE(req_info); i++)
356 if (req_info[i].namelen == namelen &&
357 !string_enum_compare(req_info[i].name, name, namelen))
358 return req_info[i].request;
359
360 return REQ_UNKNOWN;
361}
362
363
8eb62770
JF		 364/*
365 * Options
366 */
b76c2afc 367
4b8c01a3
JF		 368static const char usage[] =
369VERSION " (" __DATE__ ")\n"
370"\n"
371"Usage: tig [options]\n"
372" or: tig [options] [--] [git log options]\n"
373" or: tig [options] log [git log options]\n"
374" or: tig [options] diff [git diff options]\n"
375" or: tig [options] show [git show options]\n"
376" or: tig [options] < [git command output]\n"
377"\n"
378"Options:\n"
379" -l Start up in log view\n"
380" -d Start up in diff view\n"
381" -n[I], --line-number[=I] Show line numbers with given interval\n"
b3c965c9 382" -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
4b8c01a3
JF		 383" -- Mark end of tig options\n"
384" -v, --version Show version and exit\n"
385" -h, --help Show help message and exit\n";
386
6706b2ba 387/* Option and state variables. */
92d30f5c
JF		 388static bool opt_line_number = FALSE;
389static bool opt_rev_graph = TRUE;
390static int opt_num_interval = NUMBER_INTERVAL;
391static int opt_tab_size = TABSIZE;
392static enum request opt_request = REQ_VIEW_MAIN;
393static char opt_cmd[SIZEOF_STR] = "";
e733ee54 394static char opt_path[SIZEOF_STR] = "";
92d30f5c
JF		 395static FILE *opt_pipe = NULL;
396static char opt_encoding[20] = "UTF-8";
397static bool opt_utf8 = TRUE;
398static char opt_codeset[20] = "UTF-8";
399static iconv_t opt_iconv = ICONV_NONE;
400static char opt_search[SIZEOF_STR] = "";
b76c2afc 401
6dbf6c19
JF		 402enum option_type {
403 OPT_NONE,
404 OPT_INT,
405};
406
407static bool
408check_option(char *opt, char short_name, char *name, enum option_type type, ...)
409{
410 va_list args;
411 char *value = "";
412 int *number;
413
414 if (opt[0] != '-')
415 return FALSE;
416
417 if (opt[1] == '-') {
418 int namelen = strlen(name);
419
420 opt += 2;
421
422 if (strncmp(opt, name, namelen))
423 return FALSE;
424
425 if (opt[namelen] == '=')
426 value = opt + namelen + 1;
427
428 } else {
429 if (!short_name || opt[1] != short_name)
430 return FALSE;
431 value = opt + 2;
432 }
433
434 va_start(args, type);
435 if (type == OPT_INT) {
436 number = va_arg(args, int *);
437 if (isdigit(*value))
438 *number = atoi(value);
439 }
440 va_end(args);
441
442 return TRUE;
443}
444
b76c2afc 445/* Returns the index of log or diff command or -1 to exit. */
8855ada4 446static bool
b76c2afc
JF		 447parse_options(int argc, char *argv[])
448{
449 int i;
450
451 for (i = 1; i < argc; i++) {
452 char *opt = argv[i];
453
6b161b31 454 if (!strcmp(opt, "-l")) {
4a2909a7 455 opt_request = REQ_VIEW_LOG;
6b161b31
JF		 456 continue;
457 }
b76c2afc 458
6b161b31 459 if (!strcmp(opt, "-d")) {
4a2909a7 460 opt_request = REQ_VIEW_DIFF;
6b161b31
JF		 461 continue;
462 }
b76c2afc 463
6dbf6c19 464 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
6b161b31
JF		 465 opt_line_number = TRUE;
466 continue;
467 }
b76c2afc 468
6dbf6c19
JF		 469 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
470 opt_tab_size = MIN(opt_tab_size, TABSIZE);
6706b2ba
JF		 471 continue;
472 }
473
6dbf6c19 474 if (check_option(opt, 'v', "version", OPT_NONE)) {
b76c2afc 475 printf("tig version %s\n", VERSION);
8855ada4 476 return FALSE;
6b161b31 477 }
b76c2afc 478
6dbf6c19 479 if (check_option(opt, 'h', "help", OPT_NONE)) {
4b8c01a3
JF		 480 printf(usage);
481 return FALSE;
482 }
483
6908bdbd
JF		 484 if (!strcmp(opt, "--")) {
485 i++;
486 break;
487 }
03a93dbb 488
8855ada4
JF		 489 if (!strcmp(opt, "log") ||
490 !strcmp(opt, "diff") ||
491 !strcmp(opt, "show")) {
492 opt_request = opt[0] == 'l'
493 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
494 break;
495 }
496
03a93dbb 497 if (opt[0] && opt[0] != '-')
6908bdbd 498 break;
6b161b31 499
bf174187 500 die("unknown option '%s'\n\n%s", opt, usage);
b76c2afc
JF		 501 }
502
6908bdbd 503 if (!isatty(STDIN_FILENO)) {
6908bdbd
JF		 504 opt_request = REQ_VIEW_PAGER;
505 opt_pipe = stdin;
506
507 } else if (i < argc) {
508 size_t buf_size;
509
6908bdbd 510 if (opt_request == REQ_VIEW_MAIN)
8855ada4
JF		 511 /* XXX: This is vulnerable to the user overriding
512 * options required for the main view parser. */
6908bdbd
JF		 513 string_copy(opt_cmd, "git log --stat --pretty=raw");
514 else
515 string_copy(opt_cmd, "git");
516 buf_size = strlen(opt_cmd);
517
518 while (buf_size < sizeof(opt_cmd) && i < argc) {
519 opt_cmd[buf_size++] = ' ';
520 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
521 }
522
523 if (buf_size >= sizeof(opt_cmd))
524 die("command too long");
525
526 opt_cmd[buf_size] = 0;
527
528 }
529
afdc35b3
JF		 530 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
531 opt_utf8 = FALSE;
532
8855ada4 533 return TRUE;
b76c2afc
JF		 534}
535
536
54efb62b
JF		 537/*
538 * Line-oriented content detection.
539 */
540
2e8488b4 541#define LINE_INFO \
660e09ad 542LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
a28bcc22
JF		 543LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
544LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
545LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
660e09ad
JF		 546LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
547LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
548LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
549LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
550LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
551LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
552LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
553LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
554LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
555LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
6908bdbd 556LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
8855ada4 557LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
6908bdbd
JF		 558LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
559LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
8855ada4
JF		 560LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
561LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
7b99a34c 562LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
a28bcc22
JF		 563LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
564LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
565LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
8855ada4 566LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
a28bcc22 567LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
a28bcc22 568LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
d4d8de8f 569LINE(ACKED, " Acked-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
a28bcc22
JF		 570LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
571LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
572LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
6b161b31
JF		 573LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
574LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
a28bcc22
JF		 575LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
576LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
577LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
c34d9c9f
JF		 578LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
579LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
660e09ad 580LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
e733ee54
JF		 581LINE(TREE_DIR, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
582LINE(TREE_FILE, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL)
660e09ad 583
78c70acd 584enum line_type {
2e8488b4
JF		 585#define LINE(type, line, fg, bg, attr) \
586 LINE_##type
587 LINE_INFO
588#undef LINE
78c70acd
JF		 589};
590
591struct line_info {
660e09ad
JF		 592 const char *name; /* Option name. */
593 int namelen; /* Size of option name. */
4685845e 594 const char *line; /* The start of line to match. */
2e8488b4
JF		 595 int linelen; /* Size of string to match. */
596 int fg, bg, attr; /* Color and text attributes for the lines. */
78c70acd
JF		 597};
598
2e8488b4 599static struct line_info line_info[] = {
78c70acd 600#define LINE(type, line, fg, bg, attr) \
660e09ad 601 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
2e8488b4
JF		 602 LINE_INFO
603#undef LINE
78c70acd
JF		 604};
605
2e8488b4
JF		 606static enum line_type
607get_line_type(char *line)
78c70acd
JF		 608{
609 int linelen = strlen(line);
a28bcc22 610 enum line_type type;
78c70acd 611
a28bcc22 612 for (type = 0; type < ARRAY_SIZE(line_info); type++)
2e8488b4 613 /* Case insensitive search matches Signed-off-by lines better. */
a28bcc22
JF		 614 if (linelen >= line_info[type].linelen &&
615 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
616 return type;
78c70acd 617
2e8488b4 618 return LINE_DEFAULT;
78c70acd
JF		 619}
620
2e8488b4 621static inline int
78c70acd
JF		 622get_line_attr(enum line_type type)
623{
2e8488b4
JF		 624 assert(type < ARRAY_SIZE(line_info));
625 return COLOR_PAIR(type) | line_info[type].attr;
78c70acd
JF		 626}
627
660e09ad
JF		 628static struct line_info *
629get_line_info(char *name, int namelen)
630{
631 enum line_type type;
660e09ad
JF		 632
633 for (type = 0; type < ARRAY_SIZE(line_info); type++)
634 if (namelen == line_info[type].namelen &&
201f5a18 635 !string_enum_compare(line_info[type].name, name, namelen))
660e09ad
JF		 636 return &line_info[type];
637
638 return NULL;
639}
640
78c70acd
JF		 641static void
642init_colors(void)
643{
82e78006
JF		 644 int default_bg = COLOR_BLACK;
645 int default_fg = COLOR_WHITE;
a28bcc22 646 enum line_type type;
78c70acd
JF		 647
648 start_color();
649
650 if (use_default_colors() != ERR) {
82e78006
JF		 651 default_bg = -1;
652 default_fg = -1;
78c70acd
JF		 653 }
654
a28bcc22
JF		 655 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
656 struct line_info *info = &line_info[type];
82e78006
JF		 657 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
658 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
78c70acd 659
a28bcc22 660 init_pair(type, fg, bg);
78c70acd
JF		 661 }
662}
663
fe7233c3
JF		 664struct line {
665 enum line_type type;
3c571d67
JF		 666
667 /* State flags */
668 unsigned int selected:1;
669
fe7233c3
JF		 670 void *data; /* User data */
671};
672
78c70acd 673
1899507c 674/*
37157fa0
JF		 675 * Keys
676 */
677
93a97d86 678struct keybinding {
37157fa0 679 int alias;
93a97d86 680 enum request request;
04e2b7b2 681 struct keybinding *next;
37157fa0
JF		 682};
683
93a97d86 684static struct keybinding default_keybindings[] = {
37157fa0
JF		 685 /* View switching */
686 { 'm', REQ_VIEW_MAIN },
687 { 'd', REQ_VIEW_DIFF },
688 { 'l', REQ_VIEW_LOG },
e733ee54 689 { 't', REQ_VIEW_TREE },
0001fc34 690 { 'f', REQ_VIEW_BLOB },
37157fa0
JF		 691 { 'p', REQ_VIEW_PAGER },
692 { 'h', REQ_VIEW_HELP },
37157fa0
JF		 693
694 /* View manipulation */
695 { 'q', REQ_VIEW_CLOSE },
696 { KEY_TAB, REQ_VIEW_NEXT },
697 { KEY_RETURN, REQ_ENTER },
698 { KEY_UP, REQ_PREVIOUS },
699 { KEY_DOWN, REQ_NEXT },
700
701 /* Cursor navigation */
702 { 'k', REQ_MOVE_UP },
703 { 'j', REQ_MOVE_DOWN },
704 { KEY_HOME, REQ_MOVE_FIRST_LINE },
705 { KEY_END, REQ_MOVE_LAST_LINE },
706 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
707 { ' ', REQ_MOVE_PAGE_DOWN },
708 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
709 { 'b', REQ_MOVE_PAGE_UP },
710 { '-', REQ_MOVE_PAGE_UP },
711
712 /* Scrolling */
713 { KEY_IC, REQ_SCROLL_LINE_UP },
714 { KEY_DC, REQ_SCROLL_LINE_DOWN },
715 { 'w', REQ_SCROLL_PAGE_UP },
716 { 's', REQ_SCROLL_PAGE_DOWN },
717
4af34daa
JF		 718 /* Searching */
719 { '/', REQ_SEARCH },
720 { '?', REQ_SEARCH_BACK },
721 { 'n', REQ_FIND_NEXT },
722 { 'N', REQ_FIND_PREV },
723
37157fa0
JF		 724 /* Misc */
725 { 'Q', REQ_QUIT },
726 { 'z', REQ_STOP_LOADING },
727 { 'v', REQ_SHOW_VERSION },
728 { 'r', REQ_SCREEN_REDRAW },
904e68d8 729 { '.', REQ_TOGGLE_LINENO },
73fb51d5 730 { 'g', REQ_TOGGLE_REV_GRAPH },
37157fa0
JF		 731 { ':', REQ_PROMPT },
732
733 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
1d754561 734 { ERR, REQ_NONE },
37157fa0 735
1d754561 736 /* Using the ncurses SIGWINCH handler. */
37157fa0
JF		 737 { KEY_RESIZE, REQ_SCREEN_RESIZE },
738};
739
04e2b7b2
JF		 740#define KEYMAP_INFO \
741 KEYMAP_(GENERIC), \
742 KEYMAP_(MAIN), \
743 KEYMAP_(DIFF), \
744 KEYMAP_(LOG), \
e733ee54
JF		 745 KEYMAP_(TREE), \
746 KEYMAP_(BLOB), \
04e2b7b2
JF		 747 KEYMAP_(PAGER), \
748 KEYMAP_(HELP) \
749
750enum keymap {
751#define KEYMAP_(name) KEYMAP_##name
752 KEYMAP_INFO
753#undef KEYMAP_
754};
755
756static struct int_map keymap_table[] = {
757#define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
758 KEYMAP_INFO
759#undef KEYMAP_
760};
761
762#define set_keymap(map, name) \
763 set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
764
765static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
766
767static void
768add_keybinding(enum keymap keymap, enum request request, int key)
769{
770 struct keybinding *keybinding;
771
772 keybinding = calloc(1, sizeof(*keybinding));
773 if (!keybinding)
774 die("Failed to allocate keybinding");
775
776 keybinding->alias = key;
777 keybinding->request = request;
778 keybinding->next = keybindings[keymap];
779 keybindings[keymap] = keybinding;
780}
781
782/* Looks for a key binding first in the given map, then in the generic map, and
783 * lastly in the default keybindings. */
37157fa0 784static enum request
04e2b7b2 785get_keybinding(enum keymap keymap, int key)
37157fa0 786{
04e2b7b2 787 struct keybinding *kbd;
37157fa0
JF		 788 int i;
789
04e2b7b2
JF		 790 for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
791 if (kbd->alias == key)
792 return kbd->request;
793
794 for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
795 if (kbd->alias == key)
796 return kbd->request;
797
93a97d86
JF		 798 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
799 if (default_keybindings[i].alias == key)
800 return default_keybindings[i].request;
37157fa0
JF		 801
802 return (enum request) key;
803}
804
93a97d86 805
37157fa0
JF		 806struct key {
807 char *name;
808 int value;
809};
810
811static struct key key_table[] = {
812 { "Enter", KEY_RETURN },
813 { "Space", ' ' },
814 { "Backspace", KEY_BACKSPACE },
815 { "Tab", KEY_TAB },
816 { "Escape", KEY_ESC },
817 { "Left", KEY_LEFT },
818 { "Right", KEY_RIGHT },
819 { "Up", KEY_UP },
820 { "Down", KEY_DOWN },
821 { "Insert", KEY_IC },
822 { "Delete", KEY_DC },
74f83ee6 823 { "Hash", '#' },
37157fa0
JF		 824 { "Home", KEY_HOME },
825 { "End", KEY_END },
826 { "PageUp", KEY_PPAGE },
827 { "PageDown", KEY_NPAGE },
828 { "F1", KEY_F(1) },
829 { "F2", KEY_F(2) },
830 { "F3", KEY_F(3) },
831 { "F4", KEY_F(4) },
832 { "F5", KEY_F(5) },
833 { "F6", KEY_F(6) },
834 { "F7", KEY_F(7) },
835 { "F8", KEY_F(8) },
836 { "F9", KEY_F(9) },
837 { "F10", KEY_F(10) },
838 { "F11", KEY_F(11) },
839 { "F12", KEY_F(12) },
840};
841
04e2b7b2
JF		 842static int
843get_key_value(const char *name)
844{
845 int i;
846
847 for (i = 0; i < ARRAY_SIZE(key_table); i++)
848 if (!strcasecmp(key_table[i].name, name))
849 return key_table[i].value;
850
851 if (strlen(name) == 1 && isprint(*name))
852 return (int) *name;
853
854 return ERR;
855}
856
37157fa0
JF		 857static char *
858get_key(enum request request)
859{
860 static char buf[BUFSIZ];
861 static char key_char[] = "'X'";
d65ced0d 862 size_t pos = 0;
37157fa0
JF		 863 char *sep = " ";
864 int i;
865
866 buf[pos] = 0;
867
93a97d86
JF		 868 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
869 struct keybinding *keybinding = &default_keybindings[i];
37157fa0
JF		 870 char *seq = NULL;
871 int key;
872
93a97d86 873 if (keybinding->request != request)
37157fa0
JF		 874 continue;
875
876 for (key = 0; key < ARRAY_SIZE(key_table); key++)
93a97d86 877 if (key_table[key].value == keybinding->alias)
37157fa0
JF		 878 seq = key_table[key].name;
879
880 if (seq == NULL &&
93a97d86
JF		 881 keybinding->alias < 127 &&
882 isprint(keybinding->alias)) {
883 key_char[1] = (char) keybinding->alias;
37157fa0
JF		 884 seq = key_char;
885 }
886
887 if (!seq)
888 seq = "'?'";
889
890 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
891 return "Too many keybindings!";
892 sep = ", ";
893 }
894
895 return buf;
896}
897
898
899/*
1899507c
JF		 900 * User config file handling.
901 */
902
5dc795f2
JF		 903static struct int_map color_map[] = {
904#define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
905 COLOR_MAP(DEFAULT),
906 COLOR_MAP(BLACK),
907 COLOR_MAP(BLUE),
908 COLOR_MAP(CYAN),
909 COLOR_MAP(GREEN),
910 COLOR_MAP(MAGENTA),
911 COLOR_MAP(RED),
912 COLOR_MAP(WHITE),
913 COLOR_MAP(YELLOW),
914};
915
9256ab05
JF		 916#define set_color(color, name) \
917 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
660e09ad 918
5dc795f2
JF		 919static struct int_map attr_map[] = {
920#define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
921 ATTR_MAP(NORMAL),
922 ATTR_MAP(BLINK),
923 ATTR_MAP(BOLD),
924 ATTR_MAP(DIM),
925 ATTR_MAP(REVERSE),
926 ATTR_MAP(STANDOUT),
927 ATTR_MAP(UNDERLINE),
928};
929
9256ab05
JF		 930#define set_attribute(attr, name) \
931 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
660e09ad 932
3c3801c2
JF		 933static int config_lineno;
934static bool config_errors;
935static char *config_msg;
936
5bfd96c7 937/* Wants: object fgcolor bgcolor [attr] */
660e09ad 938static int
5bfd96c7 939option_color_command(int argc, char *argv[])
660e09ad 940{
bca8fcaa
JF		 941 struct line_info *info;
942
9256ab05
JF		 943 if (argc != 3 && argc != 4) {
944 config_msg = "Wrong number of arguments given to color command";
945 return ERR;
946 }
947
948 info = get_line_info(argv[0], strlen(argv[0]));
bca8fcaa
JF		 949 if (!info) {
950 config_msg = "Unknown color name";
951 return ERR;
952 }
660e09ad 953
a3653368
JF		 954 if (set_color(&info->fg, argv[1]) == ERR ||
955 set_color(&info->bg, argv[2]) == ERR) {
bca8fcaa
JF		 956 config_msg = "Unknown color";
957 return ERR;
958 }
660e09ad 959
9256ab05 960 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
bca8fcaa
JF		 961 config_msg = "Unknown attribute";
962 return ERR;
660e09ad
JF		 963 }
964
bca8fcaa
JF		 965 return OK;
966}
967
5bfd96c7
JF		 968/* Wants: name = value */
969static int
970option_set_command(int argc, char *argv[])
971{
972 if (argc != 3) {
973 config_msg = "Wrong number of arguments given to set command";
974 return ERR;
975 }
976
977 if (strcmp(argv[1], "=")) {
978 config_msg = "No value assigned";
979 return ERR;
980 }
981
982 if (!strcmp(argv[0], "show-rev-graph")) {
983 opt_rev_graph = (!strcmp(argv[2], "1") ||
984 !strcmp(argv[2], "true") ||
985 !strcmp(argv[2], "yes"));
986 return OK;
987 }
988
989 if (!strcmp(argv[0], "line-number-interval")) {
990 opt_num_interval = atoi(argv[2]);
991 return OK;
992 }
993
994 if (!strcmp(argv[0], "tab-size")) {
995 opt_tab_size = atoi(argv[2]);
996 return OK;
997 }
998
cb7267ee 999 if (!strcmp(argv[0], "commit-encoding")) {
3cc9a4d4
JF		 1000 char *arg = argv[2];
1001 int delimiter = *arg;
1002 int i;
1003
1004 switch (delimiter) {
1005 case '"':
1006 case '\'':
1007 for (arg++, i = 0; arg[i]; i++)
1008 if (arg[i] == delimiter) {
1009 arg[i] = 0;
1010 break;
1011 }
1012 default:
1013 string_copy(opt_encoding, arg);
1014 return OK;
1015 }
5bfd96c7
JF		 1016 }
1017
a3653368 1018 config_msg = "Unknown variable name";
5bfd96c7
JF		 1019 return ERR;
1020}
1021
04e2b7b2
JF		 1022/* Wants: mode request key */
1023static int
1024option_bind_command(int argc, char *argv[])
1025{
1026 enum request request;
1027 int keymap;
1028 int key;
1029
1030 if (argc != 3) {
1031 config_msg = "Wrong number of arguments given to bind command";
1032 return ERR;
1033 }
1034
1035 if (set_keymap(&keymap, argv[0]) == ERR) {
1036 config_msg = "Unknown key map";
1037 return ERR;
1038 }
1039
1040 key = get_key_value(argv[1]);
1041 if (key == ERR) {
1042 config_msg = "Unknown key";
1043 return ERR;
1044 }
1045
1046 request = get_request(argv[2]);
1047 if (request == REQ_UNKNOWN) {
1048 config_msg = "Unknown request name";
1049 return ERR;
1050 }
1051
1052 add_keybinding(keymap, request, key);
1053
1054 return OK;
1055}
1056
bca8fcaa 1057static int
9256ab05 1058set_option(char *opt, char *value)
bca8fcaa 1059{
9256ab05
JF		 1060 char *argv[16];
1061 int valuelen;
1062 int argc = 0;
1063
1064 /* Tokenize */
1065 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1066 argv[argc++] = value;
1067
1068 value += valuelen;
1069 if (!*value)
1070 break;
1071
1072 *value++ = 0;
1073 while (isspace(*value))
1074 value++;
1075 }
1076
1077 if (!strcmp(opt, "color"))
5bfd96c7
JF		 1078 return option_color_command(argc, argv);
1079
1080 if (!strcmp(opt, "set"))
1081 return option_set_command(argc, argv);
bca8fcaa 1082
04e2b7b2
JF		 1083 if (!strcmp(opt, "bind"))
1084 return option_bind_command(argc, argv);
1085
a3653368 1086 config_msg = "Unknown option command";
660e09ad
JF		 1087 return ERR;
1088}
1089
1090static int
3c3801c2
JF		 1091read_option(char *opt, int optlen, char *value, int valuelen)
1092{
a3653368
JF		 1093 int status = OK;
1094
3c3801c2
JF		 1095 config_lineno++;
1096 config_msg = "Internal error";
1097
a3653368
JF		 1098 /* Check for comment markers, since read_properties() will
1099 * only ensure opt and value are split at first " \t". */
74f83ee6 1100 optlen = strcspn(opt, "#");
a3653368 1101 if (optlen == 0)
3c3801c2
JF		 1102 return OK;
1103
a3653368
JF		 1104 if (opt[optlen] != 0) {
1105 config_msg = "No option value";
1106 status = ERR;
1107
1108 } else {
1109 /* Look for comment endings in the value. */
74f83ee6 1110 int len = strcspn(value, "#");
a3653368
JF		 1111
1112 if (len < valuelen) {
1113 valuelen = len;
1114 value[valuelen] = 0;
1115 }
1116
1117 status = set_option(opt, value);
3c3801c2
JF		 1118 }
1119
a3653368
JF		 1120 if (status == ERR) {
1121 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
3c3801c2
JF		 1122 config_lineno, optlen, opt, config_msg);
1123 config_errors = TRUE;
1124 }
1125
1126 /* Always keep going if errors are encountered. */
1127 return OK;
1128}
1129
1130static int
660e09ad
JF		 1131load_options(void)
1132{
1133 char *home = getenv("HOME");
17482b11 1134 char buf[SIZEOF_STR];
660e09ad
JF		 1135 FILE *file;
1136
3c3801c2
JF		 1137 config_lineno = 0;
1138 config_errors = FALSE;
1139
cc2d1364 1140 if (!home || !string_format(buf, "%s/.tigrc", home))
660e09ad
JF		 1141 return ERR;
1142
1143 /* It's ok that the file doesn't exist. */
1144 file = fopen(buf, "r");
1145 if (!file)
1146 return OK;
1147
3c3801c2
JF		 1148 if (read_properties(file, " \t", read_option) == ERR ||
1149 config_errors == TRUE)
1150 fprintf(stderr, "Errors while loading %s.\n", buf);
1151
1152 return OK;
660e09ad
JF		 1153}
1154
1155
d839253b 1156/*
468876c9 1157 * The viewer
d839253b 1158 */
c2124ccd
JF		 1159
1160struct view;
fe7233c3 1161struct view_ops;
c2124ccd
JF		 1162
1163/* The display array of active views and the index of the current view. */
1164static struct view *display[2];
1165static unsigned int current_view;
1166
33c4f9ea 1167#define foreach_displayed_view(view, i) \
c2124ccd
JF		 1168 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1169
9f41488f 1170#define displayed_views() (display[1] != NULL ? 2 : 1)
c2124ccd 1171
d839253b 1172/* Current head and commit ID */
e733ee54 1173static char ref_blob[SIZEOF_REF] = "";
c2124ccd
JF		 1174static char ref_commit[SIZEOF_REF] = "HEAD";
1175static char ref_head[SIZEOF_REF] = "HEAD";
1176
b801d8b2 1177struct view {
03a93dbb 1178 const char *name; /* View name */
4685845e
TH		 1179 const char *cmd_fmt; /* Default command line format */
1180 const char *cmd_env; /* Command line set via environment */
e733ee54 1181 const char *id; /* Points to either of ref_{head,commit,blob} */
6b161b31 1182
fe7233c3 1183 struct view_ops *ops; /* View operations */
22f66b0a 1184
04e2b7b2
JF		 1185 enum keymap keymap; /* What keymap does this view have */
1186
17482b11 1187 char cmd[SIZEOF_STR]; /* Command buffer */
49f2b43f
JF		 1188 char ref[SIZEOF_REF]; /* Hovered commit reference */
1189 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
2e8488b4 1190
8855ada4
JF		 1191 int height, width; /* The width and height of the main window */
1192 WINDOW *win; /* The main window */
1193 WINDOW *title; /* The title window living below the main window */
b801d8b2
JF		 1194
1195 /* Navigation */
1196 unsigned long offset; /* Offset of the window top */
1197 unsigned long lineno; /* Current line number */
1198
4af34daa
JF		 1199 /* Searching */
1200 char grep[SIZEOF_STR]; /* Search string */
b77b2cb8 1201 regex_t *regex; /* Pre-compiled regex */
4af34daa 1202
f6da0b66
JF		 1203 /* If non-NULL, points to the view that opened this view. If this view
1204 * is closed tig will switch back to the parent view. */
1205 struct view *parent;
1206
b801d8b2
JF		 1207 /* Buffering */
1208 unsigned long lines; /* Total number of lines */
fe7233c3 1209 struct line *line; /* Line index */
e2c01617 1210 unsigned long line_size;/* Total number of allocated lines */
8855ada4 1211 unsigned int digits; /* Number of digits in the lines member. */
b801d8b2
JF		 1212
1213 /* Loading */
1214 FILE *pipe;
2e8488b4 1215 time_t start_time;
b801d8b2
JF		 1216};
1217
fe7233c3
JF		 1218struct view_ops {
1219 /* What type of content being displayed. Used in the title bar. */
1220 const char *type;
1221 /* Draw one line; @lineno must be < view->height. */
5dcf8064 1222 bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
fe7233c3 1223 /* Read one line; updates view->line. */
701e4f5d 1224 bool (*read)(struct view *view, char *data);
fe7233c3
JF		 1225 /* Depending on view, change display based on current line. */
1226 bool (*enter)(struct view *view, struct line *line);
4af34daa
JF		 1227 /* Search for regex in a line. */
1228 bool (*grep)(struct view *view, struct line *line);
d720de4b
JF		 1229 /* Select line */
1230 void (*select)(struct view *view, struct line *line);
fe7233c3
JF		 1231};
1232
6b161b31
JF		 1233static struct view_ops pager_ops;
1234static struct view_ops main_ops;
e733ee54
JF		 1235static struct view_ops tree_ops;
1236static struct view_ops blob_ops;
a28bcc22 1237
04e2b7b2
JF		 1238#define VIEW_STR(name, cmd, env, ref, ops, map) \
1239 { name, cmd, #env, ref, ops, map}
1ba2ae4b 1240
95d7ddcd 1241#define VIEW_(id, name, ops, ref) \
04e2b7b2 1242 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1ba2ae4b 1243
c2124ccd 1244
b801d8b2 1245static struct view views[] = {
95d7ddcd
JF		 1246 VIEW_(MAIN, "main", &main_ops, ref_head),
1247 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1248 VIEW_(LOG, "log", &pager_ops, ref_head),
e733ee54
JF		 1249 VIEW_(TREE, "tree", &tree_ops, ref_commit),
1250 VIEW_(BLOB, "blob", &blob_ops, ref_blob),
95d7ddcd
JF		 1251 VIEW_(HELP, "help", &pager_ops, "static"),
1252 VIEW_(PAGER, "pager", &pager_ops, "static"),
b801d8b2
JF		 1253};
1254
a28bcc22
JF		 1255#define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1256
699ae55b
JF		 1257#define foreach_view(view, i) \
1258 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1259
1260#define view_is_displayed(view) \
1261 (view == display[0] || view == display[1])
4c6fabc2 1262
fe7233c3
JF		 1263static bool
1264draw_view_line(struct view *view, unsigned int lineno)
1265{
d720de4b 1266 struct line *line;
5dcf8064 1267 bool selected = (view->offset + lineno == view->lineno);
d720de4b 1268
699ae55b
JF		 1269 assert(view_is_displayed(view));
1270
fe7233c3
JF		 1271 if (view->offset + lineno >= view->lines)
1272 return FALSE;
1273
d720de4b
JF		 1274 line = &view->line[view->offset + lineno];
1275
3c571d67
JF		 1276 if (selected) {
1277 line->selected = TRUE;
d720de4b 1278 view->ops->select(view, line);
3c571d67
JF		 1279 } else if (line->selected) {
1280 line->selected = FALSE;
1281 wmove(view->win, lineno, 0);
1282 wclrtoeol(view->win);
1283 }
d720de4b 1284
5dcf8064 1285 return view->ops->draw(view, line, lineno, selected);
fe7233c3
JF		 1286}
1287
b801d8b2 1288static void
82e78006 1289redraw_view_from(struct view *view, int lineno)
b801d8b2 1290{
82e78006 1291 assert(0 <= lineno && lineno < view->height);
b801d8b2 1292
82e78006 1293 for (; lineno < view->height; lineno++) {
fe7233c3 1294 if (!draw_view_line(view, lineno))
fd85fef1 1295 break;
b801d8b2
JF		 1296 }
1297
1298 redrawwin(view->win);
1299 wrefresh(view->win);
1300}
1301
b76c2afc 1302static void
82e78006
JF		 1303redraw_view(struct view *view)
1304{
1305 wclear(view->win);
1306 redraw_view_from(view, 0);
1307}
1308
c2124ccd 1309
6b161b31 1310static void
81030ec8
JF		 1311update_view_title(struct view *view)
1312{
699ae55b
JF		 1313 assert(view_is_displayed(view));
1314
81030ec8
JF		 1315 if (view == display[current_view])
1316 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1317 else
1318 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1319
1320 werase(view->title);
1321 wmove(view->title, 0, 0);
1322
81030ec8
JF		 1323 if (*view->ref)
1324 wprintw(view->title, "[%s] %s", view->name, view->ref);
1325 else
1326 wprintw(view->title, "[%s]", view->name);
1327
c19f8017 1328 if (view->lines || view->pipe) {
6d9c07af 1329 unsigned int view_lines = view->offset + view->height;
c19f8017 1330 unsigned int lines = view->lines
6d9c07af 1331 ? MIN(view_lines, view->lines) * 100 / view->lines
c19f8017
JF		 1332 : 0;
1333
81030ec8
JF		 1334 wprintw(view->title, " - %s %d of %d (%d%%)",
1335 view->ops->type,
1336 view->lineno + 1,
1337 view->lines,
c19f8017 1338 lines);
81030ec8
JF		 1339 }
1340
f97f4012
JF		 1341 if (view->pipe) {
1342 time_t secs = time(NULL) - view->start_time;
1343
1344 /* Three git seconds are a long time ... */
1345 if (secs > 2)
1346 wprintw(view->title, " %lds", secs);
1347 }
1348
976447f8 1349 wmove(view->title, 0, view->width - 1);
81030ec8
JF		 1350 wrefresh(view->title);
1351}
1352
1353static void
6b161b31 1354resize_display(void)
b76c2afc 1355{
03a93dbb 1356 int offset, i;
6b161b31
JF		 1357 struct view *base = display[0];
1358 struct view *view = display[1] ? display[1] : display[0];
b76c2afc 1359
6b161b31 1360 /* Setup window dimensions */
b76c2afc 1361
03a93dbb 1362 getmaxyx(stdscr, base->height, base->width);
b76c2afc 1363
6b161b31 1364 /* Make room for the status window. */
03a93dbb 1365 base->height -= 1;
6b161b31
JF		 1366
1367 if (view != base) {
03a93dbb
JF		 1368 /* Horizontal split. */
1369 view->width = base->width;
6b161b31
JF		 1370 view->height = SCALE_SPLIT_VIEW(base->height);
1371 base->height -= view->height;
1372
1373 /* Make room for the title bar. */
1374 view->height -= 1;
1375 }
1376
1377 /* Make room for the title bar. */
1378 base->height -= 1;
1379
1380 offset = 0;
1381
33c4f9ea 1382 foreach_displayed_view (view, i) {
b76c2afc 1383 if (!view->win) {
c19f8017 1384 view->win = newwin(view->height, 0, offset, 0);
6b161b31
JF		 1385 if (!view->win)
1386 die("Failed to create %s view", view->name);
1387
1388 scrollok(view->win, TRUE);
1389
1390 view->title = newwin(1, 0, offset + view->height, 0);
1391 if (!view->title)
1392 die("Failed to create title window");
1393
1394 } else {
c19f8017 1395 wresize(view->win, view->height, view->width);
6b161b31
JF		 1396 mvwin(view->win, offset, 0);
1397 mvwin(view->title, offset + view->height, 0);
a28bcc22 1398 }
a28bcc22 1399
6b161b31 1400 offset += view->height + 1;
b76c2afc 1401 }
6b161b31 1402}
b76c2afc 1403
6b161b31 1404static void
20bb5e18
JF		 1405redraw_display(void)
1406{
1407 struct view *view;
1408 int i;
1409
33c4f9ea 1410 foreach_displayed_view (view, i) {
20bb5e18
JF		 1411 redraw_view(view);
1412 update_view_title(view);
1413 }
1414}
1415
85af6284 1416static void
2bee3bde 1417update_display_cursor(struct view *view)
85af6284 1418{
85af6284
JF		 1419 /* Move the cursor to the right-most column of the cursor line.
1420 *
1421 * XXX: This could turn out to be a bit expensive, but it ensures that
1422 * the cursor does not jump around. */
1423 if (view->lines) {
1424 wmove(view->win, view->lineno - view->offset, view->width - 1);
1425 wrefresh(view->win);
1426 }
1427}
20bb5e18 1428
2e8488b4
JF		 1429/*
1430 * Navigation
1431 */
1432
4a2909a7 1433/* Scrolling backend */
b801d8b2 1434static void
8c317212 1435do_scroll_view(struct view *view, int lines)
b801d8b2 1436{
a0087dd5
JF		 1437 bool redraw_current_line = FALSE;
1438
fd85fef1
JF		 1439 /* The rendering expects the new offset. */
1440 view->offset += lines;
1441
1442 assert(0 <= view->offset && view->offset < view->lines);
1443 assert(lines);
b801d8b2 1444
a0087dd5
JF		 1445 /* Move current line into the view. */
1446 if (view->lineno < view->offset) {
1447 view->lineno = view->offset;
1448 redraw_current_line = TRUE;
1449 } else if (view->lineno >= view->offset + view->height) {
1450 view->lineno = view->offset + view->height - 1;
1451 redraw_current_line = TRUE;
1452 }
1453
1454 assert(view->offset <= view->lineno && view->lineno < view->lines);
1455
82e78006 1456 /* Redraw the whole screen if scrolling is pointless. */
4c6fabc2 1457 if (view->height < ABS(lines)) {
b76c2afc
JF		 1458 redraw_view(view);
1459
1460 } else {
22f66b0a 1461 int line = lines > 0 ? view->height - lines : 0;
82e78006 1462 int end = line + ABS(lines);
fd85fef1
JF		 1463
1464 wscrl(view->win, lines);
1465
22f66b0a 1466 for (; line < end; line++) {
fe7233c3 1467 if (!draw_view_line(view, line))
fd85fef1
JF		 1468 break;
1469 }
fd85fef1 1470
a0087dd5
JF		 1471 if (redraw_current_line)
1472 draw_view_line(view, view->lineno - view->offset);
fd85fef1
JF		 1473 }
1474
fd85fef1
JF		 1475 redrawwin(view->win);
1476 wrefresh(view->win);
9d3f5834 1477 report("");
fd85fef1 1478}
78c70acd 1479
4a2909a7 1480/* Scroll frontend */
fd85fef1 1481static void
6b161b31 1482scroll_view(struct view *view, enum request request)
fd85fef1
JF		 1483{
1484 int lines = 1;
b801d8b2 1485
8c317212
JF		 1486 assert(view_is_displayed(view));
1487
b801d8b2 1488 switch (request) {
4a2909a7 1489 case REQ_SCROLL_PAGE_DOWN:
fd85fef1 1490 lines = view->height;
4a2909a7 1491 case REQ_SCROLL_LINE_DOWN:
b801d8b2 1492 if (view->offset + lines > view->lines)
bde3653a 1493 lines = view->lines - view->offset;
b801d8b2 1494
fd85fef1 1495 if (lines == 0 || view->offset + view->height >= view->lines) {
eb98559e 1496 report("Cannot scroll beyond the last line");
b801d8b2
JF		 1497 return;
1498 }
1499 break;
1500
4a2909a7 1501 case REQ_SCROLL_PAGE_UP:
fd85fef1 1502 lines = view->height;
4a2909a7 1503 case REQ_SCROLL_LINE_UP:
b801d8b2
JF		 1504 if (lines > view->offset)
1505 lines = view->offset;
1506
1507 if (lines == 0) {
eb98559e 1508 report("Cannot scroll beyond the first line");
b801d8b2
JF		 1509 return;
1510 }
1511
fd85fef1 1512 lines = -lines;
b801d8b2 1513 break;
03a93dbb 1514
6b161b31
JF		 1515 default:
1516 die("request %d not handled in switch", request);
b801d8b2
JF		 1517 }
1518
8c317212 1519 do_scroll_view(view, lines);
fd85fef1 1520}
b801d8b2 1521
4a2909a7 1522/* Cursor moving */
fd85fef1 1523static void
8522ecc7 1524move_view(struct view *view, enum request request)
fd85fef1 1525{
dfaa6c81 1526 int scroll_steps = 0;
fd85fef1 1527 int steps;
b801d8b2 1528
fd85fef1 1529 switch (request) {
4a2909a7 1530 case REQ_MOVE_FIRST_LINE:
78c70acd
JF		 1531 steps = -view->lineno;
1532 break;
1533
4a2909a7 1534 case REQ_MOVE_LAST_LINE:
78c70acd
JF		 1535 steps = view->lines - view->lineno - 1;
1536 break;
1537
4a2909a7 1538 case REQ_MOVE_PAGE_UP:
78c70acd
JF		 1539 steps = view->height > view->lineno
1540 ? -view->lineno : -view->height;
1541 break;
1542
4a2909a7 1543 case REQ_MOVE_PAGE_DOWN:
78c70acd
JF		 1544 steps = view->lineno + view->height >= view->lines
1545 ? view->lines - view->lineno - 1 : view->height;
1546 break;
1547
4a2909a7 1548 case REQ_MOVE_UP:
fd85fef1
JF		 1549 steps = -1;
1550 break;
b801d8b2 1551
4a2909a7 1552 case REQ_MOVE_DOWN:
fd85fef1
JF		 1553 steps = 1;
1554 break;
6b161b31
JF		 1555
1556 default:
1557 die("request %d not handled in switch", request);
78c70acd 1558 }
b801d8b2 1559
4c6fabc2 1560 if (steps <= 0 && view->lineno == 0) {
eb98559e 1561 report("Cannot move beyond the first line");
78c70acd 1562 return;
b801d8b2 1563
6908bdbd 1564 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
eb98559e 1565 report("Cannot move beyond the last line");
78c70acd 1566 return;
fd85fef1
JF		 1567 }
1568
4c6fabc2 1569 /* Move the current line */
fd85fef1 1570 view->lineno += steps;
4c6fabc2
JF		 1571 assert(0 <= view->lineno && view->lineno < view->lines);
1572
4c6fabc2 1573 /* Check whether the view needs to be scrolled */
fd85fef1
JF		 1574 if (view->lineno < view->offset ||
1575 view->lineno >= view->offset + view->height) {
dfaa6c81 1576 scroll_steps = steps;
fd85fef1 1577 if (steps < 0 && -steps > view->offset) {
dfaa6c81 1578 scroll_steps = -view->offset;
b76c2afc
JF		 1579
1580 } else if (steps > 0) {
1581 if (view->lineno == view->lines - 1 &&
1582 view->lines > view->height) {
dfaa6c81
JF		 1583 scroll_steps = view->lines - view->offset - 1;
1584 if (scroll_steps >= view->height)
1585 scroll_steps -= view->height - 1;
b76c2afc 1586 }
b801d8b2 1587 }
8522ecc7
JF		 1588 }
1589
1590 if (!view_is_displayed(view)) {
1591 view->offset += steps;
1592 view->ops->select(view, &view->line[view->lineno]);
1593 return;
1594 }
1595
1596 /* Repaint the old "current" line if we be scrolling */
1597 if (ABS(steps) < view->height)
1598 draw_view_line(view, view->lineno - steps - view->offset);
1599
dfaa6c81
JF		 1600 if (scroll_steps) {
1601 do_scroll_view(view, scroll_steps);
fd85fef1 1602 return;
b801d8b2
JF		 1603 }
1604
4c6fabc2 1605 /* Draw the current line */
fe7233c3 1606 draw_view_line(view, view->lineno - view->offset);
fd85fef1 1607
b801d8b2
JF		 1608 redrawwin(view->win);
1609 wrefresh(view->win);
9d3f5834 1610 report("");
b801d8b2
JF		 1611}
1612
b801d8b2 1613
2e8488b4 1614/*
4af34daa
JF		 1615 * Searching
1616 */
1617
c02d8fce 1618static void search_view(struct view *view, enum request request);
4af34daa
JF		 1619
1620static bool
1621find_next_line(struct view *view, unsigned long lineno, struct line *line)
1622{
699ae55b
JF		 1623 assert(view_is_displayed(view));
1624
4af34daa
JF		 1625 if (!view->ops->grep(view, line))
1626 return FALSE;
1627
1628 if (lineno - view->offset >= view->height) {
1629 view->offset = lineno;
1630 view->lineno = lineno;
1631 redraw_view(view);
1632
1633 } else {
1634 unsigned long old_lineno = view->lineno - view->offset;
1635
1636 view->lineno = lineno;
4af34daa
JF		 1637 draw_view_line(view, old_lineno);
1638
1639 draw_view_line(view, view->lineno - view->offset);
1640 redrawwin(view->win);
1641 wrefresh(view->win);
1642 }
1643
1644 report("Line %ld matches '%s'", lineno + 1, view->grep);
1645 return TRUE;
1646}
1647
1648static void
1649find_next(struct view *view, enum request request)
1650{
1651 unsigned long lineno = view->lineno;
1652 int direction;
1653
1654 if (!*view->grep) {
1655 if (!*opt_search)
1656 report("No previous search");
1657 else
c02d8fce 1658 search_view(view, request);
4af34daa
JF		 1659 return;
1660 }
1661
1662 switch (request) {
1663 case REQ_SEARCH:
1664 case REQ_FIND_NEXT:
1665 direction = 1;
1666 break;
1667
1668 case REQ_SEARCH_BACK:
1669 case REQ_FIND_PREV:
1670 direction = -1;
1671 break;
1672
1673 default:
1674 return;
1675 }
1676
1677 if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1678 lineno += direction;
1679
1680 /* Note, lineno is unsigned long so will wrap around in which case it
1681 * will become bigger than view->lines. */
1682 for (; lineno < view->lines; lineno += direction) {
1683 struct line *line = &view->line[lineno];
1684
1685 if (find_next_line(view, lineno, line))
1686 return;
1687 }
1688
1689 report("No match found for '%s'", view->grep);
1690}
1691
1692static void
c02d8fce 1693search_view(struct view *view, enum request request)
4af34daa
JF		 1694{
1695 int regex_err;
1696
b77b2cb8
JF		 1697 if (view->regex) {
1698 regfree(view->regex);
4af34daa 1699 *view->grep = 0;
b77b2cb8
JF		 1700 } else {
1701 view->regex = calloc(1, sizeof(*view->regex));
1702 if (!view->regex)
1703 return;
4af34daa
JF		 1704 }
1705
c02d8fce 1706 regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
4af34daa
JF		 1707 if (regex_err != 0) {
1708 char buf[SIZEOF_STR] = "unknown error";
1709
b77b2cb8 1710 regerror(regex_err, view->regex, buf, sizeof(buf));
e9cacd58 1711 report("Search failed: %s", buf);
4af34daa
JF		 1712 return;
1713 }
1714
c02d8fce 1715 string_copy(view->grep, opt_search);
4af34daa
JF		 1716
1717 find_next(view, request);
1718}
1719
1720/*
2e8488b4
JF		 1721 * Incremental updating
1722 */
b801d8b2 1723
199d1288
JF		 1724static void
1725end_update(struct view *view)
1726{
1727 if (!view->pipe)
1728 return;
1729 set_nonblocking_input(FALSE);
1730 if (view->pipe == stdin)
1731 fclose(view->pipe);
1732 else
1733 pclose(view->pipe);
1734 view->pipe = NULL;
1735}
1736
03a93dbb 1737static bool
b801d8b2
JF		 1738begin_update(struct view *view)
1739{
4685845e 1740 const char *id = view->id;
fd85fef1 1741
199d1288
JF		 1742 if (view->pipe)
1743 end_update(view);
1744
03a93dbb
JF		 1745 if (opt_cmd[0]) {
1746 string_copy(view->cmd, opt_cmd);
1747 opt_cmd[0] = 0;
8855ada4
JF		 1748 /* When running random commands, the view ref could have become
1749 * invalid so clear it. */
1750 view->ref[0] = 0;
e733ee54
JF		 1751
1752 } else if (view == VIEW(REQ_VIEW_TREE)) {
1753 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1754
1755 if (strcmp(view->vid, view->id))
1756 opt_path[0] = 0;
1757
4ea4ce91 1758 if (!string_format(view->cmd, format, id, opt_path))
e733ee54
JF		 1759 return FALSE;
1760
03a93dbb 1761 } else {
4685845e 1762 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1ba2ae4b 1763
cc2d1364 1764 if (!string_format(view->cmd, format, id, id, id, id, id))
03a93dbb
JF		 1765 return FALSE;
1766 }
b801d8b2 1767
6908bdbd
JF		 1768 /* Special case for the pager view. */
1769 if (opt_pipe) {
1770 view->pipe = opt_pipe;
1771 opt_pipe = NULL;
1772 } else {
1773 view->pipe = popen(view->cmd, "r");
1774 }
1775
2e8488b4
JF		 1776 if (!view->pipe)
1777 return FALSE;
b801d8b2 1778
6b161b31 1779 set_nonblocking_input(TRUE);
b801d8b2
JF		 1780
1781 view->offset = 0;
1782 view->lines = 0;
1783 view->lineno = 0;
49f2b43f 1784 string_copy(view->vid, id);
b801d8b2 1785
2e8488b4
JF		 1786 if (view->line) {
1787 int i;
1788
1789 for (i = 0; i < view->lines; i++)
fe7233c3
JF		 1790 if (view->line[i].data)
1791 free(view->line[i].data);
2e8488b4
JF		 1792
1793 free(view->line);
1794 view->line = NULL;
1795 }
1796
1797 view->start_time = time(NULL);
1798
b801d8b2
JF		 1799 return TRUE;
1800}
1801
e2c01617
JF		 1802static struct line *
1803realloc_lines(struct view *view, size_t line_size)
1804{
1805 struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1806
1807 if (!tmp)
1808 return NULL;
1809
1810 view->line = tmp;
1811 view->line_size = line_size;
1812 return view->line;
1813}
1814
03a93dbb 1815static bool
b801d8b2
JF		 1816update_view(struct view *view)
1817{
6b68fd24
JF		 1818 char in_buffer[BUFSIZ];
1819 char out_buffer[BUFSIZ * 2];
b801d8b2 1820 char *line;
82e78006
JF		 1821 /* The number of lines to read. If too low it will cause too much
1822 * redrawing (and possible flickering), if too high responsiveness
1823 * will suffer. */
8855ada4 1824 unsigned long lines = view->height;
82e78006 1825 int redraw_from = -1;
b801d8b2
JF		 1826
1827 if (!view->pipe)
1828 return TRUE;
1829
82e78006
JF		 1830 /* Only redraw if lines are visible. */
1831 if (view->offset + view->height >= view->lines)
1832 redraw_from = view->lines - view->offset;
b801d8b2 1833
699ae55b 1834 /* FIXME: This is probably not perfect for backgrounded views. */
e2c01617 1835 if (!realloc_lines(view, view->lines + lines))
b801d8b2
JF		 1836 goto alloc_error;
1837
6b68fd24
JF		 1838 while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
1839 size_t linelen = strlen(line);
b801d8b2 1840
b801d8b2
JF		 1841 if (linelen)
1842 line[linelen - 1] = 0;
1843
6b68fd24
JF		 1844 if (opt_iconv != ICONV_NONE) {
1845 char *inbuf = line;
1846 size_t inlen = linelen;
1847
1848 char *outbuf = out_buffer;
1849 size_t outlen = sizeof(out_buffer);
1850
1851 size_t ret;
1852
1853 ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
1854 if (ret != (size_t) -1) {
1855 line = out_buffer;
1856 linelen = strlen(out_buffer);
1857 }
1858 }
1859
701e4f5d 1860 if (!view->ops->read(view, line))
b801d8b2 1861 goto alloc_error;
fd85fef1
JF		 1862
1863 if (lines-- == 1)
1864 break;
b801d8b2
JF		 1865 }
1866
8855ada4
JF		 1867 {
1868 int digits;
1869
1870 lines = view->lines;
1871 for (digits = 0; lines; digits++)
1872 lines /= 10;
1873
1874 /* Keep the displayed view in sync with line number scaling. */
1875 if (digits != view->digits) {
1876 view->digits = digits;
1877 redraw_from = 0;
1878 }
1879 }
1880
699ae55b
JF		 1881 if (!view_is_displayed(view))
1882 goto check_pipe;
1883
e733ee54
JF		 1884 if (view == VIEW(REQ_VIEW_TREE)) {
1885 /* Clear the view and redraw everything since the tree sorting
1886 * might have rearranged things. */
1887 redraw_view(view);
1888
1889 } else if (redraw_from >= 0) {
82e78006 1890 /* If this is an incremental update, redraw the previous line
a28bcc22
JF		 1891 * since for commits some members could have changed when
1892 * loading the main view. */
82e78006
JF		 1893 if (redraw_from > 0)
1894 redraw_from--;
1895
1896 /* Incrementally draw avoids flickering. */
1897 redraw_view_from(view, redraw_from);
4c6fabc2 1898 }
b801d8b2 1899
eb98559e
JF		 1900 /* Update the title _after_ the redraw so that if the redraw picks up a
1901 * commit reference in view->ref it'll be available here. */
1902 update_view_title(view);
1903
699ae55b 1904check_pipe:
b801d8b2 1905 if (ferror(view->pipe)) {
03a93dbb 1906 report("Failed to read: %s", strerror(errno));
b801d8b2
JF		 1907 goto end;
1908
1909 } else if (feof(view->pipe)) {
f97f4012 1910 report("");
b801d8b2
JF		 1911 goto end;
1912 }
1913
1914 return TRUE;
1915
1916alloc_error:
2e8488b4 1917 report("Allocation failure");
b801d8b2
JF		 1918
1919end:
1920 end_update(view);
1921 return FALSE;
1922}
1923
79d445ca 1924
e10154d5
JF		 1925/*
1926 * View opening
1927 */
1928
79d445ca
JF		 1929static void open_help_view(struct view *view)
1930{
1931 char buf[BUFSIZ];
1932 int lines = ARRAY_SIZE(req_info) + 2;
1933 int i;
1934
1935 if (view->lines > 0)
1936 return;
1937
1938 for (i = 0; i < ARRAY_SIZE(req_info); i++)
1939 if (!req_info[i].request)
1940 lines++;
1941
1942 view->line = calloc(lines, sizeof(*view->line));
1943 if (!view->line) {
1944 report("Allocation failure");
1945 return;
1946 }
1947
1948 view->ops->read(view, "Quick reference for tig keybindings:");
1949
1950 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
1951 char *key;
1952
1953 if (!req_info[i].request) {
1954 view->ops->read(view, "");
1955 view->ops->read(view, req_info[i].help);
1956 continue;
1957 }
1958
1959 key = get_key(req_info[i].request);
1960 if (!string_format(buf, "%-25s %s", key, req_info[i].help))
1961 continue;
1962
1963 view->ops->read(view, buf);
1964 }
1965}
1966
49f2b43f
JF		 1967enum open_flags {
1968 OPEN_DEFAULT = 0, /* Use default view switching. */
1969 OPEN_SPLIT = 1, /* Split current view. */
1970 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1971 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1972};
1973
6b161b31 1974static void
49f2b43f 1975open_view(struct view *prev, enum request request, enum open_flags flags)
b801d8b2 1976{
49f2b43f
JF		 1977 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1978 bool split = !!(flags & OPEN_SPLIT);
1979 bool reload = !!(flags & OPEN_RELOAD);
a28bcc22 1980 struct view *view = VIEW(request);
9f41488f 1981 int nviews = displayed_views();
6e950a52 1982 struct view *base_view = display[0];
b801d8b2 1983
49f2b43f 1984 if (view == prev && nviews == 1 && !reload) {
6b161b31
JF		 1985 report("Already in %s view", view->name);
1986 return;
1987 }
b801d8b2 1988
2509b112 1989 if (view == VIEW(REQ_VIEW_HELP)) {
79d445ca 1990 open_help_view(view);
2509b112
JF		 1991
1992 } else if ((reload || strcmp(view->vid, view->id)) &&
1993 !begin_update(view)) {
6b161b31
JF		 1994 report("Failed to load %s view", view->name);
1995 return;
1996 }
a28bcc22 1997
6b161b31 1998 if (split) {
8d741c06 1999 display[1] = view;
6b161b31 2000 if (!backgrounded)
8d741c06 2001 current_view = 1;
6b161b31
JF		 2002 } else {
2003 /* Maximize the current view. */
2004 memset(display, 0, sizeof(display));
2005 current_view = 0;
2006 display[current_view] = view;
a28bcc22 2007 }
b801d8b2 2008
6e950a52
JF		 2009 /* Resize the view when switching between split- and full-screen,
2010 * or when switching between two different full-screen views. */
2011 if (nviews != displayed_views() ||
2012 (nviews == 1 && base_view != display[0]))
a006db63 2013 resize_display();
b801d8b2 2014
a8891802 2015 if (split && prev->lineno - prev->offset >= prev->height) {
03a93dbb 2016 /* Take the title line into account. */
eb98559e 2017 int lines = prev->lineno - prev->offset - prev->height + 1;
03a93dbb
JF		 2018
2019 /* Scroll the view that was split if the current line is
2020 * outside the new limited view. */
8c317212 2021 do_scroll_view(prev, lines);
03a93dbb
JF		 2022 }
2023
6b161b31 2024 if (prev && view != prev) {
9b995f0c 2025 if (split && !backgrounded) {
f0b3ab80
JF		 2026 /* "Blur" the previous view. */
2027 update_view_title(prev);
9f396969 2028 }
f0b3ab80 2029
f6da0b66 2030 view->parent = prev;
b801d8b2
JF		 2031 }
2032
9f396969 2033 if (view->pipe && view->lines == 0) {
03a93dbb
JF		 2034 /* Clear the old view and let the incremental updating refill
2035 * the screen. */
2036 wclear(view->win);
f97f4012 2037 report("");
03a93dbb
JF		 2038 } else {
2039 redraw_view(view);
24b5b3e0 2040 report("");
03a93dbb 2041 }
6706b2ba
JF		 2042
2043 /* If the view is backgrounded the above calls to report()
2044 * won't redraw the view title. */
2045 if (backgrounded)
2046 update_view_title(view);
b801d8b2
JF		 2047}
2048
2049
6b161b31
JF		 2050/*
2051 * User request switch noodle
2052 */
2053
b801d8b2 2054static int
6b161b31 2055view_driver(struct view *view, enum request request)
b801d8b2 2056{
b801d8b2
JF		 2057 int i;
2058
2059 switch (request) {
4a2909a7
JF		 2060 case REQ_MOVE_UP:
2061 case REQ_MOVE_DOWN:
2062 case REQ_MOVE_PAGE_UP:
2063 case REQ_MOVE_PAGE_DOWN:
2064 case REQ_MOVE_FIRST_LINE:
2065 case REQ_MOVE_LAST_LINE:
8522ecc7 2066 move_view(view, request);
fd85fef1
JF		 2067 break;
2068
4a2909a7
JF		 2069 case REQ_SCROLL_LINE_DOWN:
2070 case REQ_SCROLL_LINE_UP:
2071 case REQ_SCROLL_PAGE_DOWN:
2072 case REQ_SCROLL_PAGE_UP:
a28bcc22 2073 scroll_view(view, request);
b801d8b2
JF		 2074 break;
2075
e733ee54
JF		 2076 case REQ_VIEW_BLOB:
2077 if (!ref_blob[0]) {
2078 report("No file chosen, press 't' to open tree view");
2079 break;
2080 }
2081 /* Fall-through */
4a2909a7 2082 case REQ_VIEW_MAIN:
4a2909a7 2083 case REQ_VIEW_DIFF:
2e8488b4 2084 case REQ_VIEW_LOG:
e733ee54 2085 case REQ_VIEW_TREE:
2e8488b4 2086 case REQ_VIEW_HELP:
6908bdbd 2087 case REQ_VIEW_PAGER:
49f2b43f 2088 open_view(view, request, OPEN_DEFAULT);
b801d8b2
JF		 2089 break;
2090
b3a54cba
JF		 2091 case REQ_NEXT:
2092 case REQ_PREVIOUS:
2093 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2094
e733ee54
JF		 2095 if ((view == VIEW(REQ_VIEW_DIFF) &&
2096 view->parent == VIEW(REQ_VIEW_MAIN)) ||
2097 (view == VIEW(REQ_VIEW_BLOB) &&
2098 view->parent == VIEW(REQ_VIEW_TREE))) {
b3a54cba 2099 view = view->parent;
8522ecc7
JF		 2100 move_view(view, request);
2101 if (view_is_displayed(view))
f0b3ab80 2102 update_view_title(view);
b3a54cba 2103 } else {
8522ecc7 2104 move_view(view, request);
b3a54cba
JF		 2105 break;
2106 }
6706b2ba
JF		 2107 /* Fall-through */
2108
6b161b31 2109 case REQ_ENTER:
6908bdbd
JF		 2110 if (!view->lines) {
2111 report("Nothing to enter");
2112 break;
2113 }
fe7233c3 2114 return view->ops->enter(view, &view->line[view->lineno]);
6b161b31 2115
03a93dbb
JF		 2116 case REQ_VIEW_NEXT:
2117 {
9f41488f 2118 int nviews = displayed_views();
03a93dbb
JF		 2119 int next_view = (current_view + 1) % nviews;
2120
2121 if (next_view == current_view) {
2122 report("Only one view is displayed");
2123 break;
2124 }
2125
2126 current_view = next_view;
2127 /* Blur out the title of the previous view. */
2128 update_view_title(view);
6734f6b9 2129 report("");
03a93dbb
JF		 2130 break;
2131 }
24b5b3e0 2132 case REQ_TOGGLE_LINENO:
b76c2afc 2133 opt_line_number = !opt_line_number;
20bb5e18 2134 redraw_display();
b801d8b2
JF		 2135 break;
2136
54efb62b
JF		 2137 case REQ_TOGGLE_REV_GRAPH:
2138 opt_rev_graph = !opt_rev_graph;
2139 redraw_display();
2140 break;
2141
03a93dbb 2142 case REQ_PROMPT:
8855ada4 2143 /* Always reload^Wrerun commands from the prompt. */
49f2b43f 2144 open_view(view, opt_request, OPEN_RELOAD);
03a93dbb
JF		 2145 break;
2146
4af34daa
JF		 2147 case REQ_SEARCH:
2148 case REQ_SEARCH_BACK:
c02d8fce 2149 search_view(view, request);
4af34daa
JF		 2150 break;
2151
2152 case REQ_FIND_NEXT:
2153 case REQ_FIND_PREV:
2154 find_next(view, request);
2155 break;
2156
4a2909a7 2157 case REQ_STOP_LOADING:
59a45d3a
JF		 2158 for (i = 0; i < ARRAY_SIZE(views); i++) {
2159 view = &views[i];
2e8488b4 2160 if (view->pipe)
6a7bb912 2161 report("Stopped loading the %s view", view->name),
03a93dbb
JF		 2162 end_update(view);
2163 }
b801d8b2
JF		 2164 break;
2165
4a2909a7 2166 case REQ_SHOW_VERSION:
6cb291b7 2167 report("%s (built %s)", VERSION, __DATE__);
b801d8b2
JF		 2168 return TRUE;
2169
fac7db6c
JF		 2170 case REQ_SCREEN_RESIZE:
2171 resize_display();
2172 /* Fall-through */
4a2909a7 2173 case REQ_SCREEN_REDRAW:
20bb5e18 2174 redraw_display();
4a2909a7
JF		 2175 break;
2176
1d754561 2177 case REQ_NONE:
b801d8b2
JF		 2178 doupdate();
2179 return TRUE;
2180
4f9b667a 2181 case REQ_VIEW_CLOSE:
2fcf5401
JF		 2182 /* XXX: Mark closed views by letting view->parent point to the
2183 * view itself. Parents to closed view should never be
2184 * followed. */
2185 if (view->parent &&
2186 view->parent->parent != view->parent) {
4f9b667a
JF		 2187 memset(display, 0, sizeof(display));
2188 current_view = 0;
f6da0b66 2189 display[current_view] = view->parent;
2fcf5401 2190 view->parent = view;
4f9b667a
JF		 2191 resize_display();
2192 redraw_display();
2193 break;
2194 }
2195 /* Fall-through */
b801d8b2
JF		 2196 case REQ_QUIT:
2197 return FALSE;
2198
2199 default:
2e8488b4 2200 /* An unknown key will show most commonly used commands. */
468876c9 2201 report("Unknown key, press 'h' for help");
b801d8b2
JF		 2202 return TRUE;
2203 }
2204
2205 return TRUE;
2206}
2207
2208
2209/*
ff26aa29 2210 * Pager backend
b801d8b2
JF		 2211 */
2212
6b161b31 2213static bool
5dcf8064 2214pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
b801d8b2 2215{
fe7233c3
JF		 2216 char *text = line->data;
2217 enum line_type type = line->type;
2218 int textlen = strlen(text);
78c70acd 2219 int attr;
b801d8b2 2220
6706b2ba
JF		 2221 wmove(view->win, lineno, 0);
2222
5dcf8064 2223 if (selected) {
78c70acd 2224 type = LINE_CURSOR;
6706b2ba 2225 wchgat(view->win, -1, 0, type, NULL);
fd85fef1
JF		 2226 }
2227
78c70acd 2228 attr = get_line_attr(type);
b801d8b2 2229 wattrset(view->win, attr);
b76c2afc 2230
6706b2ba
JF		 2231 if (opt_line_number || opt_tab_size < TABSIZE) {
2232 static char spaces[] = " ";
2233 int col_offset = 0, col = 0;
2234
2235 if (opt_line_number) {
2236 unsigned long real_lineno = view->offset + lineno + 1;
82e78006 2237
6706b2ba
JF		 2238 if (real_lineno == 1 ||
2239 (real_lineno % opt_num_interval) == 0) {
2240 wprintw(view->win, "%.*d", view->digits, real_lineno);
8855ada4 2241
6706b2ba
JF		 2242 } else {
2243 waddnstr(view->win, spaces,
2244 MIN(view->digits, STRING_SIZE(spaces)));
2245 }
2246 waddstr(view->win, ": ");
2247 col_offset = view->digits + 2;
2248 }
8855ada4 2249
fe7233c3 2250 while (text && col_offset + col < view->width) {
6706b2ba 2251 int cols_max = view->width - col_offset - col;
fe7233c3 2252 char *pos = text;
6706b2ba 2253 int cols;
4c6fabc2 2254
fe7233c3
JF		 2255 if (*text == '\t') {
2256 text++;
6706b2ba 2257 assert(sizeof(spaces) > TABSIZE);
fe7233c3 2258 pos = spaces;
6706b2ba 2259 cols = opt_tab_size - (col % opt_tab_size);
82e78006 2260
b76c2afc 2261 } else {
fe7233c3
JF		 2262 text = strchr(text, '\t');
2263 cols = line ? text - pos : strlen(pos);
b76c2afc 2264 }
6706b2ba 2265
fe7233c3 2266 waddnstr(view->win, pos, MIN(cols, cols_max));
6706b2ba 2267 col += cols;
b76c2afc 2268 }
b76c2afc
JF		 2269
2270 } else {
6706b2ba 2271 int col = 0, pos = 0;
b801d8b2 2272
fe7233c3
JF		 2273 for (; pos < textlen && col < view->width; pos++, col++)
2274 if (text[pos] == '\t')
6706b2ba
JF		 2275 col += TABSIZE - (col % TABSIZE) - 1;
2276
fe7233c3 2277 waddnstr(view->win, text, pos);
6706b2ba 2278 }
2e8488b4 2279
b801d8b2
JF		 2280 return TRUE;
2281}
2282
dc23c0e3 2283static bool
d65ced0d 2284add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
dc23c0e3 2285{
17482b11 2286 char refbuf[SIZEOF_STR];
dc23c0e3
JF		 2287 char *ref = NULL;
2288 FILE *pipe;
2289
2290 if (!string_format(refbuf, "git describe %s", commit_id))
2291 return TRUE;
2292
2293 pipe = popen(refbuf, "r");
2294 if (!pipe)
2295 return TRUE;
2296
2297 if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2298 ref = chomp_string(ref);
2299 pclose(pipe);
2300
2301 if (!ref || !*ref)
2302 return TRUE;
2303
2304 /* This is the only fatal call, since it can "corrupt" the buffer. */
17482b11 2305 if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
dc23c0e3
JF		 2306 return FALSE;
2307
2308 return TRUE;
2309}
2310
7b99a34c
JF		 2311static void
2312add_pager_refs(struct view *view, struct line *line)
2313{
17482b11 2314 char buf[SIZEOF_STR];
c9ca1ec3 2315 char *commit_id = line->data + STRING_SIZE("commit ");
7b99a34c 2316 struct ref **refs;
d65ced0d 2317 size_t bufpos = 0, refpos = 0;
7b99a34c 2318 const char *sep = "Refs: ";
dc23c0e3 2319 bool is_tag = FALSE;
7b99a34c
JF		 2320
2321 assert(line->type == LINE_COMMIT);
2322
c9ca1ec3 2323 refs = get_refs(commit_id);
dc23c0e3
JF		 2324 if (!refs) {
2325 if (view == VIEW(REQ_VIEW_DIFF))
2326 goto try_add_describe_ref;
7b99a34c 2327 return;
dc23c0e3 2328 }
7b99a34c
JF		 2329
2330 do {
cc2d1364
JF		 2331 struct ref *ref = refs[refpos];
2332 char *fmt = ref->tag ? "%s[%s]" : "%s%s";
7b99a34c 2333
cc2d1364
JF		 2334 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2335 return;
7b99a34c 2336 sep = ", ";
dc23c0e3
JF		 2337 if (ref->tag)
2338 is_tag = TRUE;
7b99a34c
JF		 2339 } while (refs[refpos++]->next);
2340
dc23c0e3
JF		 2341 if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2342try_add_describe_ref:
d42c8a35 2343 /* Add <tag>-g<commit_id> "fake" reference. */
dc23c0e3
JF		 2344 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2345 return;
2346 }
2347
d42c8a35
JF		 2348 if (bufpos == 0)
2349 return;
2350
cc2d1364 2351 if (!realloc_lines(view, view->line_size + 1))
7b99a34c
JF		 2352 return;
2353
2354 line = &view->line[view->lines];
2355 line->data = strdup(buf);
2356 if (!line->data)
2357 return;
2358
2359 line->type = LINE_PP_REFS;
2360 view->lines++;
2361}
2362
6b161b31 2363static bool
701e4f5d 2364pager_read(struct view *view, char *data)
22f66b0a 2365{
7b99a34c 2366 struct line *line = &view->line[view->lines];
22f66b0a 2367
7b99a34c
JF		 2368 line->data = strdup(data);
2369 if (!line->data)
2370 return FALSE;
fe7233c3 2371
7b99a34c 2372 line->type = get_line_type(line->data);
22f66b0a 2373 view->lines++;
7b99a34c
JF		 2374
2375 if (line->type == LINE_COMMIT &&
2376 (view == VIEW(REQ_VIEW_DIFF) ||
2377 view == VIEW(REQ_VIEW_LOG)))
2378 add_pager_refs(view, line);
2379
22f66b0a
JF		 2380 return TRUE;
2381}
2382
6b161b31 2383static bool
fe7233c3 2384pager_enter(struct view *view, struct line *line)
6b161b31 2385{
91e8e277 2386 int split = 0;
6b161b31 2387
9fbbd28f
JF		 2388 if (line->type == LINE_COMMIT &&
2389 (view == VIEW(REQ_VIEW_LOG) ||
2390 view == VIEW(REQ_VIEW_PAGER))) {
91e8e277
JF		 2391 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2392 split = 1;
67e48ac5
JF		 2393 }
2394
91e8e277
JF		 2395 /* Always scroll the view even if it was split. That way
2396 * you can use Enter to scroll through the log view and
2397 * split open each commit diff. */
2398 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2399
2400 /* FIXME: A minor workaround. Scrolling the view will call report("")
9d82d824
JF		 2401 * but if we are scrolling a non-current view this won't properly
2402 * update the view title. */
91e8e277
JF		 2403 if (split)
2404 update_view_title(view);
6b161b31
JF		 2405
2406 return TRUE;
2407}
2408
4af34daa
JF		 2409static bool
2410pager_grep(struct view *view, struct line *line)
2411{
2412 regmatch_t pmatch;
2413 char *text = line->data;
2414
2415 if (!*text)
2416 return FALSE;
2417
b77b2cb8 2418 if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
4af34daa
JF		 2419 return FALSE;
2420
2421 return TRUE;
2422}
2423
d720de4b
JF		 2424static void
2425pager_select(struct view *view, struct line *line)
2426{
2427 if (line->type == LINE_COMMIT) {
2428 char *text = line->data;
2429
5dcf8064 2430 string_copy(view->ref, text + STRING_SIZE("commit "));
d720de4b
JF		 2431 string_copy(ref_commit, view->ref);
2432 }
2433}
2434
6b161b31 2435static struct view_ops pager_ops = {
6734f6b9 2436 "line",
6b161b31
JF		 2437 pager_draw,
2438 pager_read,
2439 pager_enter,
4af34daa 2440 pager_grep,
d720de4b 2441 pager_select,
6b161b31
JF		 2442};
2443
80ce96ea 2444
ff26aa29 2445/*
e733ee54
JF		 2446 * Tree backend
2447 */
2448
4795d620 2449/* Parse output from git-ls-tree(1):
e733ee54
JF		 2450 *
2451 * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
2452 * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
2453 * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
2454 * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
2455 */
2456
2457#define SIZEOF_TREE_ATTR \
2458 STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
2459
2460#define TREE_UP_FORMAT "040000 tree %s\t.."
2461
2462static int
2463tree_compare_entry(enum line_type type1, char *name1,
2464 enum line_type type2, char *name2)
2465{
2466 if (type1 != type2) {
2467 if (type1 == LINE_TREE_DIR)
2468 return -1;
2469 return 1;
2470 }
2471
2472 return strcmp(name1, name2);
2473}
2474
2475static bool
2476tree_read(struct view *view, char *text)
2477{
2478 size_t textlen = strlen(text);
2479 char buf[SIZEOF_STR];
2480 unsigned long pos;
2481 enum line_type type;
f88a5319 2482 bool first_read = view->lines == 0;
e733ee54
JF		 2483
2484 if (textlen <= SIZEOF_TREE_ATTR)
2485 return FALSE;
2486
2487 type = text[STRING_SIZE("100644 ")] == 't'
2488 ? LINE_TREE_DIR : LINE_TREE_FILE;
2489
f88a5319 2490 if (first_read) {
e733ee54 2491 /* Add path info line */
4ea4ce91 2492 if (string_format(buf, "Directory path /%s", opt_path) &&
e733ee54
JF		 2493 realloc_lines(view, view->line_size + 1) &&
2494 pager_read(view, buf))
2495 view->line[view->lines - 1].type = LINE_DEFAULT;
2496 else
2497 return FALSE;
2498
2499 /* Insert "link" to parent directory. */
2500 if (*opt_path &&
4ea4ce91 2501 string_format(buf, TREE_UP_FORMAT, view->ref) &&
e733ee54
JF		 2502 realloc_lines(view, view->line_size + 1) &&
2503 pager_read(view, buf))
2504 view->line[view->lines - 1].type = LINE_TREE_DIR;
2505 else if (*opt_path)
2506 return FALSE;
2507 }
2508
2509 /* Strip the path part ... */
2510 if (*opt_path) {
2511 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
2512 size_t striplen = strlen(opt_path);
2513 char *path = text + SIZEOF_TREE_ATTR;
2514
2515 if (pathlen > striplen)
2516 memmove(path, path + striplen,
2517 pathlen - striplen + 1);
2518 }
2519
2520 /* Skip "Directory ..." and ".." line. */
2521 for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
2522 struct line *line = &view->line[pos];
2523 char *path1 = ((char *) line->data) + SIZEOF_TREE_ATTR;
2524 char *path2 = text + SIZEOF_TREE_ATTR;
2525 int cmp = tree_compare_entry(line->type, path1, type, path2);
2526
2527 if (cmp <= 0)
2528 continue;
2529
2530 text = strdup(text);
2531 if (!text)
2532 return FALSE;
2533
2534 if (view->lines > pos)
2535 memmove(&view->line[pos + 1], &view->line[pos],
2536 (view->lines - pos) * sizeof(*line));
2537
2538 line = &view->line[pos];
2539 line->data = text;
2540 line->type = type;
2541 view->lines++;
2542 return TRUE;
2543 }
2544
2545 if (!pager_read(view, text))
2546 return FALSE;
2547
f88a5319
JF		 2548 /* Move the current line to the first tree entry. */
2549 if (first_read)
2550 view->lineno++;
2551
e733ee54
JF		 2552 view->line[view->lines - 1].type = type;
2553 return TRUE;
2554}
2555
2556static bool
2557tree_enter(struct view *view, struct line *line)
2558{
2b42e5d6 2559 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
e733ee54
JF		 2560 enum request request;
2561
2562 switch (line->type) {
2563 case LINE_TREE_DIR:
2564 /* Depending on whether it is a subdir or parent (updir?) link
2565 * mangle the path buffer. */
2566 if (line == &view->line[1] && *opt_path) {
2567 size_t path_len = strlen(opt_path);
2568 char *dirsep = opt_path + path_len - 1;
2569
2570 while (dirsep > opt_path && dirsep[-1] != '/')
2571 dirsep--;
2572
2573 dirsep[0] = 0;
2574
2575 } else {
d65ced0d 2576 size_t pathlen = strlen(opt_path);
4ea4ce91 2577 size_t origlen = pathlen;
4795d620 2578 char *data = line->data;
e733ee54
JF		 2579 char *basename = data + SIZEOF_TREE_ATTR;
2580
4038038f 2581 if (!string_format_from(opt_path, &pathlen, "%s/", basename)) {
4ea4ce91
JF		 2582 opt_path[origlen] = 0;
2583 return TRUE;
2584 }
e733ee54
JF		 2585 }
2586
2587 /* Trees and subtrees share the same ID, so they are not not
2588 * unique like blobs. */
2589 flags |= OPEN_RELOAD;
2590 request = REQ_VIEW_TREE;
2591 break;
2592
2593 case LINE_TREE_FILE:
e733ee54
JF		 2594 request = REQ_VIEW_BLOB;
2595 break;
2596
2597 default:
2598 return TRUE;
2599 }
2600
2601 open_view(view, request, flags);
2602
e733ee54
JF		 2603 return TRUE;
2604}
2605
d720de4b
JF		 2606static void
2607tree_select(struct view *view, struct line *line)
2608{
73c76ef5
JF		 2609 char *text = line->data;
2610
2611 text += STRING_SIZE("100644 blob ");
2612
2613 if (line->type == LINE_TREE_FILE) {
2614 string_ncopy(ref_blob, text, 40);
2615 /* Also update the blob view's ref, since all there must always
2616 * be in sync. */
2617 string_copy(VIEW(REQ_VIEW_BLOB)->ref, ref_blob);
d720de4b 2618
ebbaf4fe
JF		 2619 } else if (line->type != LINE_TREE_DIR) {
2620 return;
d720de4b 2621 }
ebbaf4fe
JF		 2622
2623 string_ncopy(view->ref, text, 40);
d720de4b
JF		 2624}
2625
e733ee54
JF		 2626static struct view_ops tree_ops = {
2627 "file",
2628 pager_draw,
2629 tree_read,
2630 tree_enter,
2631 pager_grep,
d720de4b 2632 tree_select,
e733ee54
JF		 2633};
2634
2635static bool
2636blob_read(struct view *view, char *line)
2637{
2638 bool state = pager_read(view, line);
2639
2640 if (state == TRUE)
2641 view->line[view->lines - 1].type = LINE_DEFAULT;
2642
2643 return state;
2644}
2645
2646static struct view_ops blob_ops = {
2647 "line",
2648 pager_draw,
2649 blob_read,
2650 pager_enter,
2651 pager_grep,
d720de4b 2652 pager_select,
e733ee54
JF		 2653};
2654
2655
2656/*
ff26aa29
JF		 2657 * Main view backend
2658 */
2659
2660struct commit {
10446330 2661 char id[SIZEOF_REV]; /* SHA1 ID. */
54efb62b
JF		 2662 char title[75]; /* First line of the commit message. */
2663 char author[75]; /* Author of the commit. */
2664 struct tm time; /* Date from the author ident. */
2665 struct ref **refs; /* Repository references. */
2666 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
2667 size_t graph_size; /* The width of the graph array. */
ff26aa29 2668};
c34d9c9f 2669
6b161b31 2670static bool
5dcf8064 2671main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
22f66b0a 2672{
2e8488b4 2673 char buf[DATE_COLS + 1];
fe7233c3 2674 struct commit *commit = line->data;
78c70acd 2675 enum line_type type;
6706b2ba 2676 int col = 0;
b76c2afc 2677 size_t timelen;
10e290ee 2678 size_t authorlen;
9989bf60 2679 int trimmed = 1;
22f66b0a 2680
4c6fabc2
JF		 2681 if (!*commit->author)
2682 return FALSE;
22f66b0a 2683
6706b2ba
JF		 2684 wmove(view->win, lineno, col);
2685
5dcf8064 2686 if (selected) {
78c70acd 2687 type = LINE_CURSOR;
6706b2ba
JF		 2688 wattrset(view->win, get_line_attr(type));
2689 wchgat(view->win, -1, 0, type, NULL);
2690
78c70acd 2691 } else {
b76c2afc 2692 type = LINE_MAIN_COMMIT;
6706b2ba 2693 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
b76c2afc
JF		 2694 }
2695
4c6fabc2 2696 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
b76c2afc 2697 waddnstr(view->win, buf, timelen);
4c6fabc2 2698 waddstr(view->win, " ");
b76c2afc 2699
6706b2ba
JF		 2700 col += DATE_COLS;
2701 wmove(view->win, lineno, col);
2702 if (type != LINE_CURSOR)
2703 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
b76c2afc 2704
9989bf60
JF		 2705 if (opt_utf8) {
2706 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2707 } else {
2708 authorlen = strlen(commit->author);
2709 if (authorlen > AUTHOR_COLS - 2) {
2710 authorlen = AUTHOR_COLS - 2;
2711 trimmed = 1;
2712 }
2713 }
10e290ee
JF		 2714
2715 if (trimmed) {
2716 waddnstr(view->win, commit->author, authorlen);
6706b2ba
JF		 2717 if (type != LINE_CURSOR)
2718 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
b76c2afc
JF		 2719 waddch(view->win, '~');
2720 } else {
2721 waddstr(view->win, commit->author);
22f66b0a
JF		 2722 }
2723
10e290ee 2724 col += AUTHOR_COLS;
6706b2ba
JF		 2725 if (type != LINE_CURSOR)
2726 wattrset(view->win, A_NORMAL);
2727
54efb62b
JF		 2728 if (opt_rev_graph && commit->graph_size) {
2729 size_t i;
2730
2731 wmove(view->win, lineno, col);
2732 /* Using waddch() instead of waddnstr() ensures that
2733 * they'll be rendered correctly for the cursor line. */
2734 for (i = 0; i < commit->graph_size; i++)
2735 waddch(view->win, commit->graph[i]);
2736
2737 col += commit->graph_size + 1;
2738 }
2739
2740 wmove(view->win, lineno, col);
c34d9c9f
JF		 2741
2742 if (commit->refs) {
2743 size_t i = 0;
2744
2745 do {
6706b2ba
JF		 2746 if (type == LINE_CURSOR)
2747 ;
2748 else if (commit->refs[i]->tag)
c34d9c9f
JF		 2749 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2750 else
2751 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2752 waddstr(view->win, "[");
2753 waddstr(view->win, commit->refs[i]->name);
2754 waddstr(view->win, "]");
6706b2ba
JF		 2755 if (type != LINE_CURSOR)
2756 wattrset(view->win, A_NORMAL);
c34d9c9f 2757 waddstr(view->win, " ");
6706b2ba 2758 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
c34d9c9f
JF		 2759 } while (commit->refs[i++]->next);
2760 }
2761
6706b2ba
JF		 2762 if (type != LINE_CURSOR)
2763 wattrset(view->win, get_line_attr(type));
2764
2765 {
2766 int titlelen = strlen(commit->title);
2767
2768 if (col + titlelen > view->width)
2769 titlelen = view->width - col;
2770
2771 waddnstr(view->win, commit->title, titlelen);
2772 }
22f66b0a
JF		 2773
2774 return TRUE;
2775}
2776
4c6fabc2 2777/* Reads git log --pretty=raw output and parses it into the commit struct. */
6b161b31 2778static bool
701e4f5d 2779main_read(struct view *view, char *line)
22f66b0a 2780{
78c70acd 2781 enum line_type type = get_line_type(line);
701e4f5d
JF		 2782 struct commit *commit = view->lines
2783 ? view->line[view->lines - 1].data : NULL;
22f66b0a 2784
78c70acd
JF		 2785 switch (type) {
2786 case LINE_COMMIT:
22f66b0a
JF		 2787 commit = calloc(1, sizeof(struct commit));
2788 if (!commit)
2789 return FALSE;
2790
4c6fabc2 2791 line += STRING_SIZE("commit ");
b76c2afc 2792
fe7233c3 2793 view->line[view->lines++].data = commit;
82e78006 2794 string_copy(commit->id, line);
c34d9c9f 2795 commit->refs = get_refs(commit->id);
54efb62b 2796 commit->graph[commit->graph_size++] = ACS_LTEE;
78c70acd 2797 break;
22f66b0a 2798
8855ada4 2799 case LINE_AUTHOR:
b76c2afc 2800 {
4c6fabc2 2801 char *ident = line + STRING_SIZE("author ");
b76c2afc
JF		 2802 char *end = strchr(ident, '<');
2803
701e4f5d 2804 if (!commit)
fe7233c3
JF		 2805 break;
2806
b76c2afc 2807 if (end) {
cbbf2d1b
JF		 2808 char *email = end + 1;
2809
b76c2afc 2810 for (; end > ident && isspace(end[-1]); end--) ;
cbbf2d1b
JF		 2811
2812 if (end == ident && *email) {
2813 ident = email;
2814 end = strchr(ident, '>');
2815 for (; end > ident && isspace(end[-1]); end--) ;
2816 }
b76c2afc
JF		 2817 *end = 0;
2818 }
2819
cbbf2d1b
JF		 2820 /* End is NULL or ident meaning there's no author. */
2821 if (end <= ident)
2822 ident = "Unknown";
2823
82e78006 2824 string_copy(commit->author, ident);
b76c2afc 2825
4c6fabc2 2826 /* Parse epoch and timezone */
b76c2afc
JF		 2827 if (end) {
2828 char *secs = strchr(end + 1, '>');
2829 char *zone;
2830 time_t time;
2831
2832 if (!secs || secs[1] != ' ')
2833 break;
2834
2835 secs += 2;
2836 time = (time_t) atol(secs);
2837 zone = strchr(secs, ' ');
4c6fabc2 2838 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
b76c2afc
JF		 2839 long tz;
2840
2841 zone++;
2842 tz = ('0' - zone[1]) * 60 * 60 * 10;
2843 tz += ('0' - zone[2]) * 60 * 60;
2844 tz += ('0' - zone[3]) * 60;
2845 tz += ('0' - zone[4]) * 60;
2846
2847 if (zone[0] == '-')
2848 tz = -tz;
2849
2850 time -= tz;
2851 }
2852 gmtime_r(&time, &commit->time);
2853 }
2854 break;
2855 }
78c70acd 2856 default:
701e4f5d 2857 if (!commit)
2e8488b4
JF		 2858 break;
2859
2860 /* Fill in the commit title if it has not already been set. */
2e8488b4
JF		 2861 if (commit->title[0])
2862 break;
2863
2864 /* Require titles to start with a non-space character at the
2865 * offset used by git log. */
eb98559e
JF		 2866 /* FIXME: More gracefull handling of titles; append "..." to
2867 * shortened titles, etc. */
2e8488b4 2868 if (strncmp(line, " ", 4) ||
eb98559e 2869 isspace(line[4]))
82e78006
JF		 2870 break;
2871
2872 string_copy(commit->title, line + 4);
22f66b0a
JF		 2873 }
2874
2875 return TRUE;
2876}
2877
6b161b31 2878static bool
fe7233c3 2879main_enter(struct view *view, struct line *line)
b801d8b2 2880{
b3a54cba
JF		 2881 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2882
2883 open_view(view, REQ_VIEW_DIFF, flags);
6b161b31 2884 return TRUE;
b801d8b2
JF		 2885}
2886
4af34daa
JF		 2887static bool
2888main_grep(struct view *view, struct line *line)
2889{
2890 struct commit *commit = line->data;
2891 enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
2892 char buf[DATE_COLS + 1];
2893 regmatch_t pmatch;
2894
2895 for (state = S_TITLE; state < S_END; state++) {
2896 char *text;
2897
2898 switch (state) {
2899 case S_TITLE: text = commit->title; break;
2900 case S_AUTHOR: text = commit->author; break;
2901 case S_DATE:
2902 if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
2903 continue;
2904 text = buf;
2905 break;
2906
2907 default:
2908 return FALSE;
2909 }
2910
b77b2cb8 2911 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4af34daa
JF		 2912 return TRUE;
2913 }
2914
2915 return FALSE;
2916}
2917
d720de4b
JF		 2918static void
2919main_select(struct view *view, struct line *line)
2920{
2921 struct commit *commit = line->data;
2922
2923 string_copy(view->ref, commit->id);
2924 string_copy(ref_commit, view->ref);
2925}
2926
6b161b31 2927static struct view_ops main_ops = {
6734f6b9 2928 "commit",
6b161b31
JF		 2929 main_draw,
2930 main_read,
2931 main_enter,
4af34daa 2932 main_grep,
d720de4b 2933 main_select,
6b161b31 2934};
2e8488b4 2935
c34d9c9f 2936
6b161b31 2937/*
10e290ee
JF		 2938 * Unicode / UTF-8 handling
2939 *
2940 * NOTE: Much of the following code for dealing with unicode is derived from
2941 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2942 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2943 */
2944
2945/* I've (over)annotated a lot of code snippets because I am not entirely
2946 * confident that the approach taken by this small UTF-8 interface is correct.
2947 * --jonas */
2948
2949static inline int
2950unicode_width(unsigned long c)
2951{
2952 if (c >= 0x1100 &&
2953 (c <= 0x115f /* Hangul Jamo */
2954 || c == 0x2329
2955 || c == 0x232a
2956 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
f97f4012 2957 /* CJK ... Yi */
10e290ee
JF		 2958 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2959 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2960 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2961 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2962 || (c >= 0xffe0 && c <= 0xffe6)
2963 || (c >= 0x20000 && c <= 0x2fffd)
2964 || (c >= 0x30000 && c <= 0x3fffd)))
2965 return 2;
2966
2967 return 1;
2968}
2969
2970/* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2971 * Illegal bytes are set one. */
2972static const unsigned char utf8_bytes[256] = {
2973 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2974 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2975 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2976 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2977 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2978 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2979 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,
2980 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,
2981};
2982
2983/* Decode UTF-8 multi-byte representation into a unicode character. */
2984static inline unsigned long
2985utf8_to_unicode(const char *string, size_t length)
2986{
2987 unsigned long unicode;
2988
2989 switch (length) {
2990 case 1:
2991 unicode = string[0];
2992 break;
2993 case 2:
2994 unicode = (string[0] & 0x1f) << 6;
2995 unicode += (string[1] & 0x3f);
2996 break;
2997 case 3:
2998 unicode = (string[0] & 0x0f) << 12;
2999 unicode += ((string[1] & 0x3f) << 6);
3000 unicode += (string[2] & 0x3f);
3001 break;
3002 case 4:
3003 unicode = (string[0] & 0x0f) << 18;
3004 unicode += ((string[1] & 0x3f) << 12);
3005 unicode += ((string[2] & 0x3f) << 6);
3006 unicode += (string[3] & 0x3f);
3007 break;
3008 case 5:
3009 unicode = (string[0] & 0x0f) << 24;
3010 unicode += ((string[1] & 0x3f) << 18);
3011 unicode += ((string[2] & 0x3f) << 12);
3012 unicode += ((string[3] & 0x3f) << 6);
3013 unicode += (string[4] & 0x3f);
3014 break;
68b6e0eb 3015 case 6:
10e290ee
JF		 3016 unicode = (string[0] & 0x01) << 30;
3017 unicode += ((string[1] & 0x3f) << 24);
3018 unicode += ((string[2] & 0x3f) << 18);
3019 unicode += ((string[3] & 0x3f) << 12);
3020 unicode += ((string[4] & 0x3f) << 6);
3021 unicode += (string[5] & 0x3f);
3022 break;
3023 default:
3024 die("Invalid unicode length");
3025 }
3026
3027 /* Invalid characters could return the special 0xfffd value but NUL
3028 * should be just as good. */
3029 return unicode > 0xffff ? 0 : unicode;
3030}
3031
3032/* Calculates how much of string can be shown within the given maximum width
3033 * and sets trimmed parameter to non-zero value if all of string could not be
3034 * shown.
3035 *
3036 * Additionally, adds to coloffset how many many columns to move to align with
3037 * the expected position. Takes into account how multi-byte and double-width
3038 * characters will effect the cursor position.
3039 *
3040 * Returns the number of bytes to output from string to satisfy max_width. */
3041static size_t
3042utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
3043{
3044 const char *start = string;
3045 const char *end = strchr(string, '\0');
3046 size_t mbwidth = 0;
3047 size_t width = 0;
3048
3049 *trimmed = 0;
3050
3051 while (string < end) {
3052 int c = *(unsigned char *) string;
3053 unsigned char bytes = utf8_bytes[c];
3054 size_t ucwidth;
3055 unsigned long unicode;
3056
3057 if (string + bytes > end)
3058 break;
3059
3060 /* Change representation to figure out whether
3061 * it is a single- or double-width character. */
3062
3063 unicode = utf8_to_unicode(string, bytes);
3064 /* FIXME: Graceful handling of invalid unicode character. */
3065 if (!unicode)
3066 break;
3067
3068 ucwidth = unicode_width(unicode);
3069 width += ucwidth;
3070 if (width > max_width) {
3071 *trimmed = 1;
3072 break;
3073 }
3074
3075 /* The column offset collects the differences between the
3076 * number of bytes encoding a character and the number of
3077 * columns will be used for rendering said character.
3078 *
3079 * So if some character A is encoded in 2 bytes, but will be
3080 * represented on the screen using only 1 byte this will and up
3081 * adding 1 to the multi-byte column offset.
3082 *
3083 * Assumes that no double-width character can be encoding in
3084 * less than two bytes. */
3085 if (bytes > ucwidth)
3086 mbwidth += bytes - ucwidth;
3087
3088 string += bytes;
3089 }
3090
3091 *coloffset += mbwidth;
3092
3093 return string - start;
3094}
3095
3096
3097/*
6b161b31
JF		 3098 * Status management
3099 */
2e8488b4 3100
8855ada4 3101/* Whether or not the curses interface has been initialized. */
68b6e0eb 3102static bool cursed = FALSE;
8855ada4 3103
6b161b31
JF		 3104/* The status window is used for polling keystrokes. */
3105static WINDOW *status_win;
4a2909a7 3106
2e8488b4 3107/* Update status and title window. */
4a2909a7
JF		 3108static void
3109report(const char *msg, ...)
3110{
6706b2ba
JF		 3111 static bool empty = TRUE;
3112 struct view *view = display[current_view];
b76c2afc 3113
6706b2ba
JF		 3114 if (!empty || *msg) {
3115 va_list args;
4a2909a7 3116
6706b2ba 3117 va_start(args, msg);
4b76734f 3118
6706b2ba
JF		 3119 werase(status_win);
3120 wmove(status_win, 0, 0);
3121 if (*msg) {
3122 vwprintw(status_win, msg, args);
3123 empty = FALSE;
3124 } else {
3125 empty = TRUE;
3126 }
3127 wrefresh(status_win);
b801d8b2 3128
6706b2ba
JF		 3129 va_end(args);
3130 }
3131
3132 update_view_title(view);
2bee3bde 3133 update_display_cursor(view);
b801d8b2
JF		 3134}
3135
6b161b31
JF		 3136/* Controls when nodelay should be in effect when polling user input. */
3137static void
1ba2ae4b 3138set_nonblocking_input(bool loading)
b801d8b2 3139{
6706b2ba 3140 static unsigned int loading_views;
b801d8b2 3141
6706b2ba
JF		 3142 if ((loading == FALSE && loading_views-- == 1) ||
3143 (loading == TRUE && loading_views++ == 0))
1ba2ae4b 3144 nodelay(status_win, loading);
6b161b31
JF		 3145}
3146
3147static void
3148init_display(void)
3149{
3150 int x, y;
b76c2afc 3151
6908bdbd
JF		 3152 /* Initialize the curses library */
3153 if (isatty(STDIN_FILENO)) {
8855ada4 3154 cursed = !!initscr();
6908bdbd
JF		 3155 } else {
3156 /* Leave stdin and stdout alone when acting as a pager. */
3157 FILE *io = fopen("/dev/tty", "r+");
3158
e6f60674
JF		 3159 if (!io)
3160 die("Failed to open /dev/tty");
8855ada4 3161 cursed = !!newterm(NULL, io, io);
6908bdbd
JF		 3162 }
3163
8855ada4
JF		 3164 if (!cursed)
3165 die("Failed to initialize curses");
3166
2e8488b4
JF		 3167 nonl(); /* Tell curses not to do NL->CR/NL on output */
3168 cbreak(); /* Take input chars one at a time, no wait for \n */
3169 noecho(); /* Don't echo input */
b801d8b2 3170 leaveok(stdscr, TRUE);
b801d8b2
JF		 3171
3172 if (has_colors())
3173 init_colors();
3174
3175 getmaxyx(stdscr, y, x);
3176 status_win = newwin(1, 0, y - 1, 0);
3177 if (!status_win)
3178 die("Failed to create status window");
3179
3180 /* Enable keyboard mapping */
3181 keypad(status_win, TRUE);
78c70acd 3182 wbkgdset(status_win, get_line_attr(LINE_STATUS));
6b161b31
JF		 3183}
3184
4af34daa 3185static char *
cb9e48c1 3186read_prompt(const char *prompt)
ef5404a4
JF		 3187{
3188 enum { READING, STOP, CANCEL } status = READING;
9e21ce5c 3189 static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
ef5404a4
JF		 3190 int pos = 0;
3191
3192 while (status == READING) {
3193 struct view *view;
3194 int i, key;
3195
699ae55b 3196 foreach_view (view, i)
ef5404a4
JF		 3197 update_view(view);
3198
cb9e48c1 3199 report("%s%.*s", prompt, pos, buf);
ef5404a4
JF		 3200 /* Refresh, accept single keystroke of input */
3201 key = wgetch(status_win);
3202 switch (key) {
3203 case KEY_RETURN:
3204 case KEY_ENTER:
3205 case '\n':
3206 status = pos ? STOP : CANCEL;
3207 break;
3208
3209 case KEY_BACKSPACE:
3210 if (pos > 0)
3211 pos--;
3212 else
3213 status = CANCEL;
3214 break;
3215
3216 case KEY_ESC:
3217 status = CANCEL;
3218 break;
3219
3220 case ERR:
3221 break;
3222
3223 default:
3224 if (pos >= sizeof(buf)) {
3225 report("Input string too long");
9e21ce5c 3226 return NULL;
ef5404a4
JF		 3227 }
3228
3229 if (isprint(key))
3230 buf[pos++] = (char) key;
3231 }
3232 }
3233
3234 if (status == CANCEL) {
3235 /* Clear the status window */
3236 report("");
9e21ce5c 3237 return NULL;
ef5404a4
JF		 3238 }
3239
3240 buf[pos++] = 0;
ef5404a4 3241
9e21ce5c 3242 return buf;
ef5404a4 3243}
c34d9c9f
JF		 3244
3245/*
3246 * Repository references
3247 */
3248
3249static struct ref *refs;
3a91b75e 3250static size_t refs_size;
c34d9c9f 3251
1307df1a
JF		 3252/* Id <-> ref store */
3253static struct ref ***id_refs;
3254static size_t id_refs_size;
3255
c34d9c9f
JF		 3256static struct ref **
3257get_refs(char *id)
3258{
1307df1a
JF		 3259 struct ref ***tmp_id_refs;
3260 struct ref **ref_list = NULL;
3261 size_t ref_list_size = 0;
c34d9c9f
JF		 3262 size_t i;
3263
1307df1a
JF		 3264 for (i = 0; i < id_refs_size; i++)
3265 if (!strcmp(id, id_refs[i][0]->id))
3266 return id_refs[i];
3267
3268 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
3269 if (!tmp_id_refs)
3270 return NULL;
3271
3272 id_refs = tmp_id_refs;
3273
c34d9c9f
JF		 3274 for (i = 0; i < refs_size; i++) {
3275 struct ref **tmp;
3276
3277 if (strcmp(id, refs[i].id))
3278 continue;
3279
1307df1a 3280 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
c34d9c9f 3281 if (!tmp) {
1307df1a
JF		 3282 if (ref_list)
3283 free(ref_list);
c34d9c9f
JF		 3284 return NULL;
3285 }
3286
1307df1a
JF		 3287 ref_list = tmp;
3288 if (ref_list_size > 0)
3289 ref_list[ref_list_size - 1]->next = 1;
3290 ref_list[ref_list_size] = &refs[i];
3af8774e
JF		 3291
3292 /* XXX: The properties of the commit chains ensures that we can
3293 * safely modify the shared ref. The repo references will
3294 * always be similar for the same id. */
1307df1a
JF		 3295 ref_list[ref_list_size]->next = 0;
3296 ref_list_size++;
c34d9c9f
JF		 3297 }
3298
1307df1a
JF		 3299 if (ref_list)
3300 id_refs[id_refs_size++] = ref_list;
3301
3302 return ref_list;
c34d9c9f
JF		 3303}
3304
3305static int
d0cea5f9 3306read_ref(char *id, int idlen, char *name, int namelen)
c34d9c9f 3307{
d0cea5f9
JF		 3308 struct ref *ref;
3309 bool tag = FALSE;
d0cea5f9 3310
8b0297ae
JF		 3311 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
3312 /* Commits referenced by tags has "^{}" appended. */
3313 if (name[namelen - 1] != '}')
3314 return OK;
3315
d0cea5f9
JF		 3316 while (namelen > 0 && name[namelen] != '^')
3317 namelen--;
c34d9c9f 3318
d0cea5f9 3319 tag = TRUE;
8b0297ae
JF		 3320 namelen -= STRING_SIZE("refs/tags/");
3321 name += STRING_SIZE("refs/tags/");
c34d9c9f 3322
d0cea5f9 3323 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
8b0297ae
JF		 3324 namelen -= STRING_SIZE("refs/heads/");
3325 name += STRING_SIZE("refs/heads/");
c34d9c9f 3326
d0cea5f9
JF		 3327 } else if (!strcmp(name, "HEAD")) {
3328 return OK;
3329 }
6706b2ba 3330
d0cea5f9
JF		 3331 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
3332 if (!refs)
3333 return ERR;
c34d9c9f 3334
d0cea5f9 3335 ref = &refs[refs_size++];
8b0297ae 3336 ref->name = malloc(namelen + 1);
d0cea5f9
JF		 3337 if (!ref->name)
3338 return ERR;
3af8774e 3339
8b0297ae
JF		 3340 strncpy(ref->name, name, namelen);
3341 ref->name[namelen] = 0;
d0cea5f9
JF		 3342 ref->tag = tag;
3343 string_copy(ref->id, id);
3af8774e 3344
d0cea5f9
JF		 3345 return OK;
3346}
c34d9c9f 3347
d0cea5f9
JF		 3348static int
3349load_refs(void)
3350{
3351 const char *cmd_env = getenv("TIG_LS_REMOTE");
3352 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
c34d9c9f 3353
4a63c884 3354 return read_properties(popen(cmd, "r"), "\t", read_ref);
d0cea5f9 3355}
c34d9c9f 3356
d0cea5f9 3357static int
14c778a6 3358read_repo_config_option(char *name, int namelen, char *value, int valuelen)
d0cea5f9 3359{
22913179 3360 if (!strcmp(name, "i18n.commitencoding"))
d0cea5f9 3361 string_copy(opt_encoding, value);
c34d9c9f 3362
c34d9c9f
JF		 3363 return OK;
3364}
3365
4670cf89 3366static int
14c778a6 3367load_repo_config(void)
4670cf89 3368{
66749723 3369 return read_properties(popen("git repo-config --list", "r"),
14c778a6 3370 "=", read_repo_config_option);
d0cea5f9
JF		 3371}
3372
3373static int
4a63c884 3374read_properties(FILE *pipe, const char *separators,
d0cea5f9
JF		 3375 int (*read_property)(char *, int, char *, int))
3376{
4670cf89
JF		 3377 char buffer[BUFSIZ];
3378 char *name;
d0cea5f9 3379 int state = OK;
4670cf89
JF		 3380
3381 if (!pipe)
3382 return ERR;
3383
d0cea5f9 3384 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
4a63c884
JF		 3385 char *value;
3386 size_t namelen;
3387 size_t valuelen;
4670cf89 3388
4a63c884
JF		 3389 name = chomp_string(name);
3390 namelen = strcspn(name, separators);
3391
3392 if (name[namelen]) {
3393 name[namelen] = 0;
3394 value = chomp_string(name + namelen + 1);
d0cea5f9 3395 valuelen = strlen(value);
4670cf89 3396
d0cea5f9 3397 } else {
d0cea5f9
JF		 3398 value = "";
3399 valuelen = 0;
4670cf89 3400 }
d0cea5f9 3401
3c3801c2 3402 state = read_property(name, namelen, value, valuelen);
4670cf89
JF		 3403 }
3404
d0cea5f9
JF		 3405 if (state != ERR && ferror(pipe))
3406 state = ERR;
4670cf89
JF		 3407
3408 pclose(pipe);
3409
d0cea5f9 3410 return state;
4670cf89
JF		 3411}
3412
d0cea5f9 3413
6b161b31
JF		 3414/*
3415 * Main
3416 */
3417
b5c9e67f 3418static void __NORETURN
6b161b31
JF		 3419quit(int sig)
3420{
8855ada4
JF		 3421 /* XXX: Restore tty modes and let the OS cleanup the rest! */
3422 if (cursed)
3423 endwin();
6b161b31
JF		 3424 exit(0);
3425}
3426
c6704a4e
JF		 3427static void __NORETURN
3428die(const char *err, ...)
6b161b31
JF		 3429{
3430 va_list args;
3431
3432 endwin();
3433
3434 va_start(args, err);
3435 fputs("tig: ", stderr);
3436 vfprintf(stderr, err, args);
3437 fputs("\n", stderr);
3438 va_end(args);
3439
3440 exit(1);
3441}
3442
3443int
3444main(int argc, char *argv[])
3445{
1ba2ae4b 3446 struct view *view;
6b161b31 3447 enum request request;
1ba2ae4b 3448 size_t i;
6b161b31
JF		 3449
3450 signal(SIGINT, quit);
3451
6b68fd24
JF		 3452 if (setlocale(LC_ALL, "")) {
3453 string_copy(opt_codeset, nl_langinfo(CODESET));
3454 }
3455
660e09ad
JF		 3456 if (load_options() == ERR)
3457 die("Failed to load user config.");
3458
3459 /* Load the repo config file so options can be overwritten from
afdc35b3 3460 * the command line. */
14c778a6 3461 if (load_repo_config() == ERR)
afdc35b3
JF		 3462 die("Failed to load repo config.");
3463
8855ada4 3464 if (!parse_options(argc, argv))
6b161b31
JF		 3465 return 0;
3466
6b68fd24
JF		 3467 if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
3468 opt_iconv = iconv_open(opt_codeset, opt_encoding);
20f4b4a3 3469 if (opt_iconv == ICONV_NONE)
6b68fd24
JF		 3470 die("Failed to initialize character set conversion");
3471 }
3472
c34d9c9f
JF		 3473 if (load_refs() == ERR)
3474 die("Failed to load refs.");
3475
7bb55251
JF		 3476 /* Require a git repository unless when running in pager mode. */
3477 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
3478 die("Not a git repository");
3479
1ba2ae4b
JF		 3480 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
3481 view->cmd_env = getenv(view->cmd_env);
3482
6b161b31
JF		 3483 request = opt_request;
3484
3485 init_display();
b801d8b2
JF		 3486
3487 while (view_driver(display[current_view], request)) {
6b161b31 3488 int key;
b801d8b2
JF		 3489 int i;
3490
699ae55b 3491 foreach_view (view, i)
6b161b31 3492 update_view(view);
b801d8b2
JF		 3493
3494 /* Refresh, accept single keystroke of input */
6b161b31 3495 key = wgetch(status_win);
04e2b7b2
JF		 3496
3497 request = get_keybinding(display[current_view]->keymap, key);
03a93dbb 3498
6706b2ba 3499 /* Some low-level request handling. This keeps access to
fac7db6c
JF		 3500 * status_win restricted. */
3501 switch (request) {
3502 case REQ_PROMPT:
9e21ce5c
JF		 3503 {
3504 char *cmd = read_prompt(":");
3505
3506 if (cmd && string_format(opt_cmd, "git %s", cmd)) {
3507 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
3508 opt_request = REQ_VIEW_DIFF;
3509 } else {
3510 opt_request = REQ_VIEW_PAGER;
3511 }
3512 break;
3513 }
fac7db6c 3514
1d754561 3515 request = REQ_NONE;
9e21ce5c
JF		 3516 break;
3517 }
4af34daa
JF		 3518 case REQ_SEARCH:
3519 case REQ_SEARCH_BACK:
3520 {
3521 const char *prompt = request == REQ_SEARCH
3522 ? "/" : "?";
3523 char *search = read_prompt(prompt);
3524
3525 if (search)
3526 string_copy(opt_search, search);
3527 else
3528 request = REQ_NONE;
3529 break;
3530 }
fac7db6c
JF		 3531 case REQ_SCREEN_RESIZE:
3532 {
3533 int height, width;
3534
3535 getmaxyx(stdscr, height, width);
3536
3537 /* Resize the status view and let the view driver take
3538 * care of resizing the displayed views. */
3539 wresize(status_win, 1, width);
3540 mvwin(status_win, height - 1, 0);
3541 wrefresh(status_win);
3542 break;
3543 }
3544 default:
3545 break;
03a93dbb 3546 }
b801d8b2
JF		 3547 }
3548
3549 quit(0);
3550
3551 return 0;
3552}
Full-screen terminal Git browser.