display.h File Reference

Pager Display. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "lib.h"
#include "color/lib.h"

Include dependency graph for display.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	TextSyntax
	Highlighting for a piece of text. More...
struct	Line
	A line of text in the pager. More...

Functions
	ARRAY_HEAD (TextSyntaxArray, struct TextSyntax)
int	display_line (FILE *fp, LOFF_T *bytes_read, struct Line **lines, int line_num, int *lines_used, int *lines_max, PagerFlags flags, struct QuoteStyle **quote_list, int *q_level, bool *force_redraw, regex_t *search_re, struct MuttWindow *win_pager, struct AttrColorList *ansi_list)
	Print a line on screen.
bool	color_is_header (enum ColorId cid)
	Colour is for an Email header.

Detailed Description

Pager Display.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file display.h.

Function Documentation

ARRAY_HEAD()

ARRAY_HEAD	(	TextSyntaxArray	,
		struct TextSyntax
	)

display_line()

int display_line	(	FILE *	fp,
		LOFF_T *	bytes_read,
		struct Line **	lines,
		int	line_num,
		int *	lines_used,
		int *	lines_max,
		PagerFlags	flags,
		struct QuoteStyle **	quote_list,
		int *	q_level,
		bool *	force_redraw,
		regex_t *	search_re,
		struct MuttWindow *	win_pager,
		struct AttrColorList *	ansi_list
	)

Print a line on screen.

Parameters

[in]	fp	File to read from
[out]	bytes_read	Offset into file
[out]	lines	Line attributes
[in]	line_num	Line number
[out]	lines_used	Last line
[out]	lines_max	Maximum number of lines
[in]	flags	Flags, see PagerFlags
[out]	quote_list	Email quoting style
[out]	q_level	Level of quoting
[out]	force_redraw	Force a repaint
[out]	search_re	Regex to highlight
[in]	win_pager	Window to draw into
[in]	ansi_list	List of ANSI colours/attributes

Return values

-1	EOF was reached
0	normal exit, line was not displayed
>0	normal exit, line was displayed

Definition at line 1052 of file display.c.

{
  unsigned char *buf = NULL, *fmt = NULL;
  size_t buflen = 0;
  unsigned char *buf_ptr = NULL;
  int ch, vch, col, cnt, b_read;
  int buf_ready = 0;
  bool change_last = false;
  int special;
  int offset;
  const struct AttrColor *def_color = NULL;
  int m;
  int rc = -1;
  struct AnsiColor ansi = { { COLOR_DEFAULT, 0, 0 }, { COLOR_DEFAULT, 0, 0 }, 0, NULL };
  regmatch_t pmatch[1] = { 0 };
 
  struct PagerPrivateData *priv = win_pager->parent->wdata;
  enum PagerMode mode = priv->pview->mode;
 
  if (line_num == *lines_used)
  {
    (*lines_used)++;
    change_last = true;
  }
 
  if (*lines_used == *lines_max)
  {
    *lines_max += LINES;
    MUTT_MEM_REALLOC(lines, *lines_max, struct Line);
    for (ch = *lines_used; ch < *lines_max; ch++)
    {
      memset(&((*lines)[ch]), 0, sizeof(struct Line));
      (*lines)[ch].cid = -1;
      (*lines)[ch].search_arr_size = -1;
      (*lines)[ch].syntax = MUTT_MEM_CALLOC(1, struct TextSyntax);
      ((*lines)[ch].syntax)[0].first = -1;
      ((*lines)[ch].syntax)[0].last = -1;
    }
  }
 
  struct Line *const cur_line = &(*lines)[line_num];
 
  if (flags & MUTT_PAGER_LOGS)
  {
    /* determine the line class */
    if (fill_buffer(fp, bytes_read, cur_line->offset, &buf, &fmt, &buflen, &buf_ready) < 0)
    {
      if (change_last)
        (*lines_used)--;
      goto out;
    }
 
    if ((cur_line->cont_line) && (line_num > 0))
    {
      struct Line *const old_line = &(*lines)[line_num - 1];
      cur_line->cid = old_line->cid;
      cur_line->syntax[0].attr_color = old_line->syntax[0].attr_color;
    }
    else
    {
      cur_line->cid = MT_COLOR_NORMAL;
      if (buf[11] == 'M')
        cur_line->syntax[0].attr_color = simple_color_get(MT_COLOR_MESSAGE);
      else if (buf[11] == 'W')
        cur_line->syntax[0].attr_color = simple_color_get(MT_COLOR_WARNING);
      else if (buf[11] == 'E')
        cur_line->syntax[0].attr_color = simple_color_get(MT_COLOR_ERROR);
      else
        cur_line->syntax[0].attr_color = simple_color_get(MT_COLOR_NORMAL);
    }
  }
 
  /* only do color highlighting if we are viewing a message */
  if (flags & (MUTT_SHOWCOLOR | MUTT_TYPES))
  {
    if (cur_line->cid == -1)
    {
      /* determine the line class */
      if (fill_buffer(fp, bytes_read, cur_line->offset, &buf, &fmt, &buflen, &buf_ready) < 0)
      {
        if (change_last)
          (*lines_used)--;
        goto out;
      }
 
      if (mode == PAGER_MODE_EMAIL)
      {
        resolve_types(win_pager, (char *) fmt, (char *) buf, *lines, line_num, *lines_used,
                      quote_list, q_level, force_redraw, flags & MUTT_SHOWCOLOR);
      }
      else
      {
        (*lines)[line_num].cid = MT_COLOR_NORMAL;
      }
 
      /* avoid race condition for continuation lines when scrolling up */
      for (m = line_num + 1;
           m < *lines_used && (*lines)[m].offset && (*lines)[m].cont_line; m++)
      {
        (*lines)[m].cid = cur_line->cid;
      }
    }
 
    /* this also prevents searching through the hidden lines */
    const short c_toggle_quoted_show_levels = cs_subset_number(NeoMutt->sub, "toggle_quoted_show_levels");
    if ((flags & MUTT_HIDE) && COLOR_QUOTED(cur_line->cid) &&
        (!cur_line->quote || (cur_line->quote->quote_n >= c_toggle_quoted_show_levels)))
    {
      flags = 0; /* MUTT_NOSHOW */
    }
  }
 
  /* At this point, (*lines[line_num]).quote may still be undefined. We
   * don't want to compute it every time MUTT_TYPES is set, since this
   * would slow down the "bottom" function unacceptably. A compromise
   * solution is hence to call regexec() again, just to find out the
   * length of the quote prefix.  */
  if ((flags & MUTT_SHOWCOLOR) && !cur_line->cont_line &&
      COLOR_QUOTED(cur_line->cid) && !cur_line->quote)
  {
    if (fill_buffer(fp, bytes_read, cur_line->offset, &buf, &fmt, &buflen, &buf_ready) < 0)
    {
      if (change_last)
        (*lines_used)--;
      goto out;
    }
 
    const struct Regex *c_quote_regex = cs_subset_regex(NeoMutt->sub, "quote_regex");
    if (mutt_regex_capture(c_quote_regex, (char *) fmt, 1, pmatch))
    {
      cur_line->quote = qstyle_classify(quote_list, (char *) fmt + pmatch[0].rm_so,
                                        pmatch[0].rm_eo - pmatch[0].rm_so,
                                        force_redraw, q_level);
    }
    else
    {
      goto out;
    }
  }
 
  if ((flags & MUTT_SEARCH) && !cur_line->cont_line && (cur_line->search_arr_size == -1))
  {
    if (fill_buffer(fp, bytes_read, cur_line->offset, &buf, &fmt, &buflen, &buf_ready) < 0)
    {
      if (change_last)
        (*lines_used)--;
      goto out;
    }
 
    offset = 0;
    cur_line->search_arr_size = 0;
    while (regexec(search_re, (char *) fmt + offset, 1, pmatch,
                   (offset ? REG_NOTBOL : 0)) == 0)
    {
      if (++(cur_line->search_arr_size) > 1)
      {
        MUTT_MEM_REALLOC(&(cur_line->search), cur_line->search_arr_size, struct TextSyntax);
        // Zero the new entry
        const int index = cur_line->search_arr_size - 1;
        struct TextSyntax *ts = &cur_line->search[index];
        memset(ts, 0, sizeof(*ts));
      }
      else
      {
        cur_line->search = MUTT_MEM_CALLOC(1, struct TextSyntax);
      }
      pmatch[0].rm_so += offset;
      pmatch[0].rm_eo += offset;
      (cur_line->search)[cur_line->search_arr_size - 1].first = pmatch[0].rm_so;
      (cur_line->search)[cur_line->search_arr_size - 1].last = pmatch[0].rm_eo;
 
      if (pmatch[0].rm_eo == pmatch[0].rm_so)
        offset++; /* avoid degenerate cases */
      else
        offset = pmatch[0].rm_eo;
      if (!fmt[offset])
        break;
    }
  }
 
  if (!(flags & MUTT_SHOW) && ((*lines)[line_num + 1].offset > 0))
  {
    /* we've already scanned this line, so just exit */
    rc = 0;
    goto out;
  }
  if ((flags & MUTT_SHOWCOLOR) && *force_redraw && ((*lines)[line_num + 1].offset > 0))
  {
    /* no need to try to display this line... */
    rc = 1;
    goto out; /* fake display */
  }
 
  b_read = fill_buffer(fp, bytes_read, cur_line->offset, &buf, &fmt, &buflen, &buf_ready);
  if (b_read < 0)
  {
    if (change_last)
      (*lines_used)--;
    goto out;
  }
 
  /* now chose a good place to break the line */
  cnt = format_line(win_pager, lines, line_num, buf, flags, NULL, b_read, &ch,
                    &vch, &col, &special, win_pager->state.cols, ansi_list);
  buf_ptr = buf + cnt;
 
  /* move the break point only if smart_wrap is set */
  const bool c_smart_wrap = cs_subset_bool(NeoMutt->sub, "smart_wrap");
  if (c_smart_wrap)
  {
    if ((cnt < b_read) && (ch != -1) && !color_is_header(cur_line->cid) &&
        !isspace(buf[cnt]))
    {
      buf_ptr = buf + ch;
      /* skip trailing blanks */
      while (ch && ((buf[ch] == ' ') || (buf[ch] == '\t') || (buf[ch] == '\r')))
        ch--;
 
      /* A folded header with a single long word shouldn't be smartwrapped.
       * So just disable smart_wrap if it would wrap at the beginning of the line. */
      if (ch == 0)
        buf_ptr = buf + cnt;
      else
        cnt = ch + 1;
    }
 
    /* skip leading blanks on the next line too */
    while ((*buf_ptr == ' ') || (*buf_ptr == '\t'))
      buf_ptr++;
  }
 
  if (*buf_ptr == '\r')
    buf_ptr++;
  if (*buf_ptr == '\n')
    buf_ptr++;
 
  if (((int) (buf_ptr - buf) < b_read) && !(*lines)[line_num + 1].cont_line)
    append_line(*lines, line_num, (int) (buf_ptr - buf));
  (*lines)[line_num + 1].offset = cur_line->offset + (long) (buf_ptr - buf);
 
  /* if we don't need to display the line we are done */
  if (!(flags & MUTT_SHOW))
  {
    rc = 0;
    goto out;
  }
 
  if (flags & MUTT_PAGER_STRIPES)
  {
    const enum ColorId cid = ((line_num % 2) == 0) ? MT_COLOR_STRIPE_ODD : MT_COLOR_STRIPE_EVEN;
    mutt_curses_set_color_by_id(cid);
  }
 
  /* display the line */
  format_line(win_pager, lines, line_num, buf, flags, &ansi, cnt, &ch, &vch,
              &col, &special, win_pager->state.cols, ansi_list);
 
  /* avoid a bug in ncurses... */
  if (col == 0)
  {
    if (flags & MUTT_PAGER_STRIPES)
    {
      const enum ColorId cid = ((line_num % 2) == 0) ? MT_COLOR_STRIPE_ODD : MT_COLOR_STRIPE_EVEN;
      mutt_curses_set_normal_backed_color_by_id(cid);
    }
    else
    {
      mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    }
 
    mutt_window_addch(win_pager, ' ');
  }
 
  /* Fill the blank space at the end of the line with the prevailing color.
   * ncurses does an implicit clrtoeol() when you do mutt_window_addch('\n') so we have
   * to make sure to reset the color *after* that */
  if (flags & MUTT_SHOWCOLOR)
  {
    m = (cur_line->cont_line) ? (cur_line->syntax)[0].first : line_num;
    if ((*lines)[m].cid == MT_COLOR_HEADER)
    {
      def_color = ((*lines)[m].syntax)[0].attr_color;
    }
    else
    {
      def_color = simple_color_get((*lines)[m].cid);
    }
    const struct AttrColor *ac_normal = simple_color_get(MT_COLOR_NORMAL);
    const struct AttrColor *ac_eol = NULL;
    if (def_color)
      ac_eol = merged_color_overlay(ac_normal, def_color);
    else
      ac_eol = ac_normal;
    mutt_curses_set_color(ac_eol);
  }
 
  if (col < win_pager->state.cols)
  {
    if (flags & MUTT_PAGER_STRIPES)
    {
      const enum ColorId cid = ((line_num % 2) == 0) ? MT_COLOR_STRIPE_ODD : MT_COLOR_STRIPE_EVEN;
      const struct AttrColor *ac_normal = simple_color_get(MT_COLOR_NORMAL);
      const struct AttrColor *stripe_color = simple_color_get(cid);
      const struct AttrColor *ac_eol = merged_color_overlay(ac_normal, stripe_color);
      mutt_curses_set_color(ac_eol);
    }
    else
    {
      // Colours may be disabled, but we may still need to end the "search" colour
      if (!(flags & MUTT_SHOWCOLOR))
        mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    }
    mutt_window_clrtoeol(win_pager);
  }
 
  /* reset the color back to normal.  This *must* come after the
   * clrtoeol, otherwise the color for this line will not be
   * filled to the right margin.  */
  if (flags & MUTT_SHOWCOLOR)
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  /* build a return code */
  if (!(flags & MUTT_SHOW))
    flags = 0;
 
  rc = flags;
 
out:
  FREE(&buf);
  FREE(&fmt);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

color_is_header()

bool color_is_header

(

enum ColorId

cid

)

Colour is for an Email header.

Parameters

cid	Colour ID, e.g. MT_COLOR_HEADER

Return values

true	Colour is for an Email header

Definition at line 487 of file display.c.

{
  return (cid == MT_COLOR_HEADER) || (cid == MT_COLOR_HDRDEFAULT);
}

Here is the caller graph for this function: