src/draw.c

   1 /* Copyright (c) 2006-2014 Jonas Fonseca <jonas.fonseca@gmail.com>
   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 #include "tig/tig.h"
  15 #include "tig/graph.h"
  16 #include "tig/draw.h"
  17 #include "tig/options.h"
  18
  19 /*
  20  * View drawing.
  21  */
  22
  23 static inline void
  24 set_view_attr(struct view *view, enum line_type type)
  25 {
  26         if (!view->curline->selected && view->curtype != type) {
  27                 (void) wattrset(view->win, get_view_attr(view, type));
  28                 wchgat(view->win, -1, 0, get_view_color(view, type), NULL);
  29                 view->curtype = type;
  30         }
  31 }
  32
  33 #define VIEW_MAX_LEN(view) ((view)->width + (view)->pos.col - (view)->col)
  34
  35 static bool
  36 draw_chars(struct view *view, enum line_type type, const char *string,
  37            int max_len, bool use_tilde)
  38 {
  39         int len = 0;
  40         int col = 0;
  41         int trimmed = FALSE;
  42         size_t skip = view->pos.col > view->col ? view->pos.col - view->col : 0;
  43
  44         if (max_len <= 0)
  45                 return VIEW_MAX_LEN(view) <= 0;
  46
  47         len = utf8_length(&string, skip, &col, max_len, &trimmed, use_tilde, opt_tab_size);
  48
  49         if (opt_iconv_out != ICONV_NONE) {
  50                 string = encoding_iconv(opt_iconv_out, string, len);
  51                 if (!string)
  52                         return VIEW_MAX_LEN(view) <= 0;
  53         }
  54
  55         set_view_attr(view, type);
  56         if (len > 0) {
  57                 waddnstr(view->win, string, len);
  58
  59                 if (trimmed && use_tilde) {
  60                         set_view_attr(view, LINE_DELIMITER);
  61                         waddch(view->win, '~');
  62                         col++;
  63                 }
  64         }
  65
  66         view->col += col;
  67         return VIEW_MAX_LEN(view) <= 0;
  68 }
  69
  70 static bool
  71 draw_space(struct view *view, enum line_type type, int max, int spaces)
  72 {
  73         static char space[] = "                    ";
  74
  75         spaces = MIN(max, spaces);
  76
  77         while (spaces > 0) {
  78                 int len = MIN(spaces, sizeof(space) - 1);
  79
  80                 if (draw_chars(view, type, space, len, FALSE))
  81                         return TRUE;
  82                 spaces -= len;
  83         }
  84
  85         return VIEW_MAX_LEN(view) <= 0;
  86 }
  87
  88 static bool
  89 draw_text_expanded(struct view *view, enum line_type type, const char *string, int max_len, bool use_tilde)
  90 {
  91         static char text[SIZEOF_STR];
  92
  93         do {
  94                 size_t pos = string_expand(text, sizeof(text), string, opt_tab_size);
  95
  96                 if (draw_chars(view, type, text, max_len, use_tilde))
  97                         return TRUE;
  98                 string += pos;
  99         } while (*string);
 100
 101         return VIEW_MAX_LEN(view) <= 0;
 102 }
 103
 104 bool
 105 draw_text(struct view *view, enum line_type type, const char *string)
 106 {
 107         return draw_text_expanded(view, type, string, VIEW_MAX_LEN(view), FALSE);
 108 }
 109
 110 static bool
 111 draw_text_overflow(struct view *view, const char *text, enum line_type type,
 112                    int overflow_length, int offset)
 113 {
 114         bool on = overflow_length > 0;
 115
 116         if (on) {
 117                 int overflow = overflow_length + offset;
 118                 int max = MIN(VIEW_MAX_LEN(view), overflow);
 119                 int len = strlen(text);
 120
 121                 if (draw_text_expanded(view, type, text, max, max < overflow))
 122                         return TRUE;
 123
 124                 text = len > overflow ? text + overflow : "";
 125                 type = LINE_OVERFLOW;
 126         }
 127
 128         if (*text && draw_text(view, type, text))
 129                 return TRUE;
 130
 131         return VIEW_MAX_LEN(view) <= 0;
 132 }
 133
 134 bool PRINTF_LIKE(3, 4)
 135 draw_formatted(struct view *view, enum line_type type, const char *format, ...)
 136 {
 137         char text[SIZEOF_STR];
 138         int retval;
 139
 140         FORMAT_BUFFER(text, sizeof(text), format, retval, TRUE);
 141         return retval >= 0 ? draw_text(view, type, text) : VIEW_MAX_LEN(view) <= 0;
 142 }
 143
 144 bool
 145 draw_graphic(struct view *view, enum line_type type, const chtype graphic[], size_t size, bool separator)
 146 {
 147         size_t skip = view->pos.col > view->col ? view->pos.col - view->col : 0;
 148         int max = VIEW_MAX_LEN(view);
 149         int i;
 150
 151         if (max < size)
 152                 size = max;
 153
 154         set_view_attr(view, type);
 155         /* Using waddch() instead of waddnstr() ensures that
 156          * they'll be rendered correctly for the cursor line. */
 157         for (i = skip; i < size; i++)
 158                 waddch(view->win, graphic[i]);
 159
 160         view->col += size;
 161         if (separator) {
 162                 if (size < max && skip <= size)
 163                         waddch(view->win, ' ');
 164                 view->col++;
 165         }
 166
 167         return VIEW_MAX_LEN(view) <= 0;
 168 }
 169
 170 bool
 171 draw_field(struct view *view, enum line_type type, const char *text, int width, enum align align, bool trim)
 172 {
 173         int max = MIN(VIEW_MAX_LEN(view), width + 1);
 174         int col = view->col;
 175
 176         if (!text)
 177                 return draw_space(view, type, max, max);
 178
 179         if (align == ALIGN_RIGHT) {
 180                 int textlen = utf8_width_max(text, max);
 181                 int leftpad = max - textlen - 1;
 182
 183                 if (leftpad > 0) {
 184                         if (draw_space(view, type, leftpad, leftpad))
 185                                 return TRUE;
 186                         max -= leftpad;
 187                         col += leftpad;;
 188                 }
 189         }
 190
 191         return draw_chars(view, type, text, max - 1, trim)
 192             || draw_space(view, LINE_DEFAULT, max - (view->col - col), max);
 193 }
 194
 195 static bool
 196 draw_date(struct view *view, struct view_column *column, const struct time *time)
 197 {
 198         enum date date = column->opt.date.display;
 199         const char *text = mkdate(time, date);
 200         enum align align = date == DATE_RELATIVE ? ALIGN_RIGHT : ALIGN_LEFT;
 201
 202         if (date == DATE_NO)
 203                 return FALSE;
 204
 205         return draw_field(view, LINE_DATE, text, column->width, align, FALSE);
 206 }
 207
 208 static bool
 209 draw_author(struct view *view, struct view_column *column, const struct ident *author)
 210 {
 211         bool trim = author_trim(column->width);
 212         const char *text = mkauthor(author, column->opt.author.width, column->opt.author.display);
 213
 214         if (column->opt.author.display == AUTHOR_NO)
 215                 return FALSE;
 216
 217         return draw_field(view, LINE_AUTHOR, text, column->width, ALIGN_LEFT, trim);
 218 }
 219
 220 static bool
 221 draw_id(struct view *view, struct view_column *column, const char *id)
 222 {
 223         static const enum line_type colors[] = {
 224                 LINE_PALETTE_0,
 225                 LINE_PALETTE_1,
 226                 LINE_PALETTE_2,
 227                 LINE_PALETTE_3,
 228                 LINE_PALETTE_4,
 229                 LINE_PALETTE_5,
 230                 LINE_PALETTE_6,
 231                 LINE_PALETTE_7,
 232                 LINE_PALETTE_8,
 233                 LINE_PALETTE_9,
 234                 LINE_PALETTE_10,
 235                 LINE_PALETTE_11,
 236                 LINE_PALETTE_12,
 237                 LINE_PALETTE_13,
 238         };
 239         enum line_type type = LINE_ID;
 240
 241         if (!column->opt.id.display)
 242                 return FALSE;
 243
 244         if (column->opt.id.color && id) {
 245                 hashval_t color = iterative_hash(id, SIZEOF_REV - 1, 0);
 246
 247                 type = colors[color % ARRAY_SIZE(colors)];
 248         }
 249
 250         return draw_field(view, type, id, column->width, ALIGN_LEFT, FALSE);
 251 }
 252
 253 static bool
 254 draw_filename(struct view *view, struct view_column *column, const char *filename, mode_t mode)
 255 {
 256         size_t width = filename ? utf8_width(filename) : 0;
 257         bool trim = width >= column->width;
 258         enum line_type type = S_ISDIR(mode) ? LINE_DIRECTORY : LINE_FILE;
 259         int column_width = column->width ? column->width : width;
 260
 261         if (column->opt.file_name.display == FILENAME_NO)
 262                 return FALSE;
 263
 264         return draw_field(view, type, filename, column_width, ALIGN_LEFT, trim);
 265 }
 266
 267 static bool
 268 draw_file_size(struct view *view, struct view_column *column, unsigned long size, mode_t mode)
 269 {
 270         const char *str = S_ISDIR(mode) ? NULL : mkfilesize(size, column->opt.file_size.display);
 271
 272         if (!column->width || column->opt.file_size.display == FILE_SIZE_NO)
 273                 return FALSE;
 274
 275         return draw_field(view, LINE_FILE_SIZE, str, column->width, ALIGN_RIGHT, FALSE);
 276 }
 277
 278 static bool
 279 draw_mode(struct view *view, struct view_column *column, mode_t mode)
 280 {
 281         const char *str = mkmode(mode);
 282
 283         if (!column->width || !column->opt.mode.display)
 284                 return FALSE;
 285
 286         return draw_field(view, LINE_MODE, str, column->width, ALIGN_LEFT, FALSE);
 287 }
 288
 289 static bool
 290 draw_lineno_custom(struct view *view, struct view_column *column, unsigned int lineno)
 291 {
 292         char number[10];
 293         unsigned long digits3 = column->width < 3 ? 3 : column->width;
 294         int max = MIN(VIEW_MAX_LEN(view), digits3);
 295         char *text = NULL;
 296         chtype separator = opt_line_graphics ? ACS_VLINE : '|';
 297
 298         if (!column->opt.line_number.display)
 299                 return FALSE;
 300
 301         if (lineno == 1 || (lineno % column->opt.line_number.interval) == 0) {
 302                 static char fmt[] = "%ld";
 303
 304                 fmt[1] = '0' + (digits3 <= 9 ? digits3 : 1);
 305                 if (string_format(number, fmt, lineno))
 306                         text = number;
 307         }
 308         if (text)
 309                 draw_chars(view, LINE_LINE_NUMBER, text, max, TRUE);
 310         else
 311                 draw_space(view, LINE_LINE_NUMBER, max, digits3);
 312         return draw_graphic(view, LINE_DEFAULT, &separator, 1, TRUE);
 313 }
 314
 315 bool
 316 draw_lineno(struct view *view, struct view_column *column, unsigned int lineno)
 317 {
 318         lineno += view->pos.offset + 1;
 319         return draw_lineno_custom(view, column, lineno);
 320 }
 321
 322 static bool
 323 draw_ref(struct view *view, struct view_column *column, const struct ref *ref)
 324 {
 325         enum line_type type = !ref || !ref->valid ? LINE_DEFAULT : get_line_type_from_ref(ref);
 326         const char *name = ref ? ref->name : NULL;
 327
 328         return draw_field(view, type, name, column->width, ALIGN_LEFT, FALSE);
 329 }
 330
 331 static bool
 332 draw_refs(struct view *view, struct view_column *column, const struct ref_list *refs)
 333 {
 334         size_t i;
 335
 336         if (!column->opt.commit_title.refs || !refs)
 337                 return FALSE;
 338
 339         for (i = 0; i < refs->size; i++) {
 340                 struct ref *ref = refs->refs[i];
 341                 enum line_type type = get_line_type_from_ref(ref);
 342                 const struct ref_format *format = get_ref_format(ref);
 343
 344                 if (!strcmp(format->start, "hide:") && !*format->end)
 345                         continue;
 346
 347                 if (draw_formatted(view, type, "%s%s%s", format->start, ref->name, format->end))
 348                         return TRUE;
 349
 350                 if (draw_text(view, LINE_DEFAULT, " "))
 351                         return TRUE;
 352         }
 353
 354         return FALSE;
 355 }
 356
 357 static bool
 358 draw_status(struct view *view, struct view_column *column,
 359             enum line_type type, const char *status)
 360 {
 361         const char *label = mkstatus(status ? *status : 0, column->opt.status.display);
 362
 363         return draw_field(view, type, label, column->width, ALIGN_LEFT, FALSE);
 364 }
 365
 366 /*
 367  * Revision graph
 368  */
 369
 370 static const enum line_type graph_colors[] = {
 371         LINE_PALETTE_0,
 372         LINE_PALETTE_1,
 373         LINE_PALETTE_2,
 374         LINE_PALETTE_3,
 375         LINE_PALETTE_4,
 376         LINE_PALETTE_5,
 377         LINE_PALETTE_6,
 378 };
 379
 380 static enum line_type get_graph_color(struct graph_symbol *symbol)
 381 {
 382         if (symbol->commit)
 383                 return LINE_GRAPH_COMMIT;
 384         assert(symbol->color < ARRAY_SIZE(graph_colors));
 385         return graph_colors[symbol->color];
 386 }
 387
 388 static bool
 389 draw_graph_utf8(struct view *view, struct graph_symbol *symbol, enum line_type color, bool first)
 390 {
 391         const char *chars = graph_symbol_to_utf8(symbol);
 392
 393         return draw_text(view, color, chars + !!first);
 394 }
 395
 396 static bool
 397 draw_graph_ascii(struct view *view, struct graph_symbol *symbol, enum line_type color, bool first)
 398 {
 399         const char *chars = graph_symbol_to_ascii(symbol);
 400
 401         return draw_text(view, color, chars + !!first);
 402 }
 403
 404 static bool
 405 draw_graph_chtype(struct view *view, struct graph_symbol *symbol, enum line_type color, bool first)
 406 {
 407         const chtype *chars = graph_symbol_to_chtype(symbol);
 408
 409         return draw_graphic(view, color, chars + !!first, 2 - !!first, FALSE);
 410 }
 411
 412 typedef bool (*draw_graph_fn)(struct view *, struct graph_symbol *, enum line_type, bool);
 413
 414 static bool
 415 draw_graph(struct view *view, const struct graph_canvas *canvas)
 416 {
 417         static const draw_graph_fn fns[] = {
 418                 draw_graph_ascii,
 419                 draw_graph_chtype,
 420                 draw_graph_utf8
 421         };
 422         draw_graph_fn fn = fns[opt_line_graphics];
 423         int i;
 424
 425         for (i = 0; i < canvas->size; i++) {
 426                 struct graph_symbol *symbol = &canvas->symbols[i];
 427                 enum line_type color = get_graph_color(symbol);
 428
 429                 if (fn(view, symbol, color, i == 0))
 430                         return TRUE;
 431         }
 432
 433         return draw_text(view, LINE_DEFAULT, " ");
 434 }
 435
 436 static bool
 437 draw_commit_title(struct view *view, struct view_column *column,
 438                   const struct graph_canvas *graph, const struct ref_list *refs,
 439                   const char *commit_title)
 440 {
 441         if (graph && column->opt.commit_title.graph &&
 442             draw_graph(view, graph))
 443                 return TRUE;
 444         if (draw_refs(view, column, refs))
 445                 return TRUE;
 446         return draw_text_overflow(view, commit_title, LINE_DEFAULT,
 447                         column->opt.commit_title.overflow, 0);
 448 }
 449
 450 static bool
 451 draw_diff_stat_part(struct view *view, enum line_type *type, const char **text, char c, enum line_type next_type)
 452 {
 453         const char *sep = c == '|' ? strrchr(*text, c) : strchr(*text, c);
 454
 455         if (sep != NULL) {
 456                 draw_text_expanded(view, *type, *text, sep - *text, FALSE);
 457                 *text = sep;
 458                 *type = next_type;
 459         }
 460
 461         return sep != NULL;
 462 }
 463
 464 static void
 465 draw_diff_stat(struct view *view, enum line_type *type, const char **text)
 466 {
 467         draw_diff_stat_part(view, type, text, '|', LINE_DEFAULT);
 468         if (draw_diff_stat_part(view, type, text, 'B', LINE_DEFAULT)) {
 469                 /* Handle binary diffstat: Bin <deleted> -> <added> bytes */
 470                 draw_diff_stat_part(view, type, text, ' ', LINE_DIFF_DEL);
 471                 draw_diff_stat_part(view, type, text, '-', LINE_DEFAULT);
 472                 draw_diff_stat_part(view, type, text, ' ', LINE_DIFF_ADD);
 473                 draw_diff_stat_part(view, type, text, 'b', LINE_DEFAULT);
 474
 475         } else {
 476                 draw_diff_stat_part(view, type, text, '+', LINE_DIFF_ADD);
 477                 draw_diff_stat_part(view, type, text, '-', LINE_DIFF_DEL);
 478         }
 479 }
 480
 481 bool
 482 view_column_draw(struct view *view, struct line *line, unsigned int lineno)
 483 {
 484         struct view_column *column = view->columns;
 485         struct view_column_data column_data = {};
 486
 487         if (!view->ops->get_column_data(view, line, &column_data))
 488                 return TRUE;
 489
 490         if (column_data.section)
 491                 column = column_data.section;
 492
 493         for (; column; column = column->next) {
 494                 mode_t mode = column_data.mode ? *column_data.mode : 0;
 495
 496                 if (column->hidden)
 497                         continue;
 498
 499                 switch (column->type) {
 500                 case VIEW_COLUMN_DATE:
 501                         if (draw_date(view, column, column_data.date))
 502                                 return TRUE;
 503                         continue;
 504
 505                 case VIEW_COLUMN_AUTHOR:
 506                         if (draw_author(view, column, column_data.author))
 507                                 return TRUE;
 508                         continue;
 509
 510                 case VIEW_COLUMN_REF:
 511                         if (draw_ref(view, column, column_data.ref))
 512                                 return TRUE;
 513                         continue;
 514
 515                 case VIEW_COLUMN_ID:
 516                         if (draw_id(view, column, column_data.reflog ? column_data.reflog : column_data.id))
 517                                 return TRUE;
 518                         continue;
 519
 520                 case VIEW_COLUMN_LINE_NUMBER:
 521                         if (draw_lineno(view, column, column_data.line_number ? *column_data.line_number : lineno))
 522                                 return TRUE;
 523                         continue;
 524
 525                 case VIEW_COLUMN_MODE:
 526                         if (draw_mode(view, column, mode))
 527                                 return TRUE;
 528                         continue;
 529
 530                 case VIEW_COLUMN_FILE_SIZE:
 531                         if (draw_file_size(view, column, column_data.file_size ? *column_data.file_size : 0, mode))
 532                                 return TRUE;
 533                         continue;
 534
 535                 case VIEW_COLUMN_COMMIT_TITLE:
 536                         if (draw_commit_title(view, column, column_data.graph,
 537                                               column_data.refs, column_data.commit_title))
 538                                 return TRUE;
 539                         continue;
 540
 541                 case VIEW_COLUMN_FILE_NAME:
 542                         if (draw_filename(view, column, column_data.file_name, mode))
 543                                 return TRUE;
 544                         continue;
 545
 546                 case VIEW_COLUMN_SECTION:
 547                         if (draw_text(view, column->opt.section.type, column->opt.section.text))
 548                                 return TRUE;
 549                         continue;
 550
 551                 case VIEW_COLUMN_STATUS:
 552                         if (draw_status(view, column, line->type, column_data.status))
 553                                 return TRUE;
 554                         continue;
 555
 556                 case VIEW_COLUMN_TEXT:
 557                 {
 558                         enum line_type type = line->type;
 559                         const char *text = column_data.text;
 560
 561                         if (line->wrapped && draw_text(view, LINE_DELIMITER, "+"))
 562                                 return TRUE;
 563
 564                         if (line->graph_indent) {
 565                                 size_t indent = get_graph_indent(text);
 566
 567                                 if (draw_text_expanded(view, LINE_DEFAULT, text, indent, FALSE))
 568                                         return TRUE;
 569                                 text += indent;
 570                         }
 571                         if (type == LINE_DIFF_STAT)
 572                                 draw_diff_stat(view, &type, &text);
 573                         if (line->commit_title) {
 574                                 if (draw_text_overflow(view, text, LINE_DEFAULT,
 575                                                        column->opt.text.commit_title_overflow, 4))
 576                                         return TRUE;
 577                         } else if (draw_text(view, type, text)) {
 578                                 return TRUE;
 579                         }
 580                 }
 581                         continue;
 582                 }
 583         }
 584
 585         return TRUE;
 586 }
 587
 588 bool
 589 draw_view_line(struct view *view, unsigned int lineno)
 590 {
 591         struct line *line;
 592         bool selected = (view->pos.offset + lineno == view->pos.lineno);
 593
 594         /* FIXME: Disabled during code split.
 595         assert(view_is_displayed(view));
 596         */
 597
 598         if (view->pos.offset + lineno >= view->lines)
 599                 return FALSE;
 600
 601         line = &view->line[view->pos.offset + lineno];
 602
 603         wmove(view->win, lineno, 0);
 604         if (line->cleareol)
 605                 wclrtoeol(view->win);
 606         view->col = 0;
 607         view->curline = line;
 608         view->curtype = LINE_NONE;
 609         line->selected = FALSE;
 610         line->dirty = line->cleareol = 0;
 611
 612         if (selected) {
 613                 set_view_attr(view, LINE_CURSOR);
 614                 line->selected = TRUE;
 615                 view->ops->select(view, line);
 616         }
 617
 618         return view->ops->draw(view, line, lineno);
 619 }
 620
 621 void
 622 redraw_view_dirty(struct view *view)
 623 {
 624         bool dirty = FALSE;
 625         int lineno;
 626
 627         for (lineno = 0; lineno < view->height; lineno++) {
 628                 if (view->pos.offset + lineno >= view->lines)
 629                         break;
 630                 if (!view->line[view->pos.offset + lineno].dirty)
 631                         continue;
 632                 dirty = TRUE;
 633                 if (!draw_view_line(view, lineno))
 634                         break;
 635         }
 636
 637         if (!dirty)
 638                 return;
 639         wnoutrefresh(view->win);
 640 }
 641
 642 void
 643 redraw_view_from(struct view *view, int lineno)
 644 {
 645         assert(0 <= lineno && lineno < view->height);
 646
 647         if (view->columns && view_column_info_changed(view, FALSE)) {
 648                 int i;
 649
 650                 view_column_reset(view);
 651                 for (i = 0; i < view->lines; i++) {
 652                         view_column_info_update(view, &view->line[i]);
 653                 }
 654         }
 655
 656         for (; lineno < view->height; lineno++) {
 657                 if (!draw_view_line(view, lineno))
 658                         break;
 659         }
 660
 661         wnoutrefresh(view->win);
 662 }
 663
 664 void
 665 redraw_view(struct view *view)
 666 {
 667         werase(view->win);
 668         redraw_view_from(view, 0);
 669 }
 670
 671 /* vim: set ts=8 sw=8 noexpandtab: */