git.oblomov.eu Git - tig/blob - tig.c

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