Pager Function API

Prototype for a Pager Function. More...

Collaboration diagram for Pager Function API:

Functions
static int	op_first_entry (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Move to the first entry - Implements pager_function_t -.
static int	op_last_entry (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Move to the last entry - Implements pager_function_t -.
static int	op_pager_half_down (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Scroll down 1/2 page - Implements pager_function_t -.
static int	op_pager_half_up (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Scroll up 1/2 page - Implements pager_function_t -.
static int	op_pager_hide_quoted (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Toggle display of quoted text - Implements pager_function_t -.
static int	op_pager_next_line (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Scroll down one line - Implements pager_function_t -.
static int	op_pager_next_page (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Move to the next page - Implements pager_function_t -.
static int	op_pager_prev_line (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Scroll up one line - Implements pager_function_t -.
static int	op_pager_prev_page (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Move to the previous page - Implements pager_function_t -.
static int	op_pager_search (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Search for a regular expression - Implements pager_function_t -.
static int	op_pager_search_next (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Search for next match - Implements pager_function_t -.
static int	op_pager_skip_headers (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Jump to first line after headers - Implements pager_function_t -.
static int	op_pager_skip_quoted (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Skip beyond quoted text - Implements pager_function_t -.
static int	op_exit (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Exit this menu - Implements pager_function_t -.
static int	op_quit (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Save changes to mailbox and quit - Implements pager_function_t -.
static int	op_help (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Help screen - Implements pager_function_t -.
static int	op_save (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Save the Pager text - Implements pager_function_t -.
static int	op_search_toggle (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Toggle search pattern coloring - Implements pager_function_t -.
static int	op_view_attachments (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Show MIME attachments - Implements pager_function_t -.
static int	op_ignore (struct PagerFunctionData *fdata, const struct KeyEvent *event)
	Ignore this function - Implements pager_function_t -.

Detailed Description

Prototype for a Pager Function.

Parameters

fdata	Pager Function context data
event	Event to process

Return values

enum	FunctionRetval

Precondition

fdata is not NULL

event is not NULL

Function Documentation

op_first_entry()

int op_first_entry ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Move to the first entry - Implements pager_function_t -.

Definition at line 225 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->top_line == 0)
  {
    mutt_message(_("Top of message is shown"));
    return FR_ERROR;
  }
  else
  {
    priv->top_line = 0;
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_last_entry()

int op_last_entry ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Move to the last entry - Implements pager_function_t -.

Definition at line 245 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (!jump_to_bottom(priv, priv->pview))
  {
    mutt_message(_("Bottom of message is shown"));
    return FR_ERROR;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_half_down()

int op_pager_half_down ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Scroll down 1/2 page - Implements pager_function_t -.

Definition at line 260 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  const bool c_pager_stop = cs_subset_bool(fdata->n->sub, "pager_stop");
  if (priv->lines[priv->cur_line].offset < (priv->st.st_size - 1))
  {
    int rows = priv->pview->win_pager->state.rows;
    if (event->count > 0)
    {
      int advance = event->count * (rows / 2);
      priv->top_line = down_n_lines(advance, priv->lines, priv->top_line,
                                    priv->lines_used, priv->hide_quoted);
    }
    else
    {
      priv->top_line = up_n_lines(rows / 2, priv->lines, priv->cur_line, priv->hide_quoted);
    }
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
  else if (c_pager_stop)
  {
    /* emulate "less -q" and don't go on to the next message. */
    if (event->count == 0)
    {
      mutt_message(_("Bottom of message is shown"));
      return FR_ERROR;
    }
  }
  else
  {
    /* end of the current message, so display the next message. */
    index_next_undeleted(priv->pview->win_index);
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_half_up()

int op_pager_half_up ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Scroll up 1/2 page - Implements pager_function_t -.

Definition at line 299 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  const int old_top_line = priv->top_line;
  if (priv->top_line)
  {
    int rows = priv->pview->win_pager->state.rows;
    int n = MAX(event->count, 1) * (rows / 2 + rows % 2);
    priv->top_line = up_n_lines(n, priv->lines, priv->top_line, priv->hide_quoted);
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
  else if (event->count == 0)
  {
    mutt_message(_("Top of message is shown"));
  }
  return (old_top_line == 0) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_hide_quoted()

int op_pager_hide_quoted ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Toggle display of quoted text - Implements pager_function_t -.

Definition at line 320 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (!priv->has_types)
    return FR_NO_ACTION;
 
  priv->hide_quoted ^= MUTT_HIDE;
  if (priv->hide_quoted && COLOR_QUOTED(priv->lines[priv->top_line].cid))
  {
    priv->top_line = up_n_lines(1, priv->lines, priv->top_line, priv->hide_quoted);
  }
  else
  {
    pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  }
  notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_next_line()

int op_pager_next_line ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Scroll down one line - Implements pager_function_t -.

Definition at line 342 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->lines[priv->cur_line].offset < (priv->st.st_size - 1))
  {
    int n = MAX(event->count, 1);
    priv->top_line = down_n_lines(n, priv->lines, priv->top_line,
                                  priv->lines_used, priv->hide_quoted);
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
  else if (event->count == 0)
  {
    mutt_message(_("Bottom of message is shown"));
    return FR_ERROR;
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_next_page()

int op_pager_next_page ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Move to the next page - Implements pager_function_t -.

Definition at line 363 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  const bool c_pager_stop = cs_subset_bool(fdata->n->sub, "pager_stop");
  if (priv->lines[priv->cur_line].offset < (priv->st.st_size - 1))
  {
    const short c_pager_context = cs_subset_number(fdata->n->sub, "pager_context");
    if (event->count > 0)
    {
      int advance = event->count * (priv->pview->win_pager->state.rows - c_pager_context);
      priv->top_line = down_n_lines(advance, priv->lines, priv->top_line,
                                    priv->lines_used, priv->hide_quoted);
    }
    else
    {
      priv->top_line = up_n_lines(c_pager_context, priv->lines, priv->cur_line,
                                  priv->hide_quoted);
    }
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
  else if (c_pager_stop)
  {
    /* emulate "less -q" and don't go on to the next message. */
    if (event->count == 0)
    {
      mutt_message(_("Bottom of message is shown"));
      return FR_ERROR;
    }
  }
  else
  {
    /* end of the current message, so display the next message. */
    index_next_undeleted(priv->pview->win_index);
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_prev_line()

int op_pager_prev_line ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Scroll up one line - Implements pager_function_t -.

Definition at line 403 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->top_line)
  {
    int n = MAX(event->count, 1);
    priv->top_line = up_n_lines(n, priv->lines, priv->top_line, priv->hide_quoted);
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
  else if (event->count == 0)
  {
    mutt_message(_("Top of message is shown"));
    return FR_ERROR;
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_prev_page()

int op_pager_prev_page ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Move to the previous page - Implements pager_function_t -.

Definition at line 423 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->top_line == 0)
  {
    if (event->count == 0)
    {
      mutt_message(_("Top of message is shown"));
      return FR_ERROR;
    }
  }
  else
  {
    const short c_pager_context = cs_subset_number(fdata->n->sub, "pager_context");
    int n = MAX(event->count, 1) * (priv->pview->win_pager->state.rows - c_pager_context);
    priv->top_line = up_n_lines(n, priv->lines, priv->top_line, priv->hide_quoted);
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_search()

int op_pager_search ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Search for a regular expression - Implements pager_function_t -.

This function handles:

• OP_SEARCH
• OP_SEARCH_REVERSE

Definition at line 451 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  struct PagerView *pview = priv->pview;
 
  int rc = FR_NO_ACTION;
  struct Buffer *buf = buf_pool_get();
 
  buf_strcpy(buf, priv->search_str);
  const int op = event->op;
  if (mw_get_field(((op == OP_SEARCH) || (op == OP_SEARCH_NEXT)) ? _("Search for: ") : _("Reverse search for: "),
                   buf, MUTT_COMP_CLEAR, HC_PATTERN, &CompletePatternOps, NULL) != 0)
  {
    goto done;
  }
 
  if (mutt_str_equal(buf_string(buf), priv->search_str))
  {
    if (priv->search_compiled)
    {
      struct KeyEvent event_s = { 0, OP_NULL };
 
      /* do an implicit search-next */
      if (op == OP_SEARCH)
        event_s.op = OP_SEARCH_NEXT;
      else
        event_s.op = OP_SEARCH_OPPOSITE;
 
      priv->wrapped = false;
      op_pager_search_next(fdata, &event_s);
    }
  }
 
  if (buf_is_empty(buf))
    goto done;
 
  mutt_str_copy(priv->search_str, buf_string(buf), sizeof(priv->search_str));
 
  /* leave search_back alone if op == OP_SEARCH_NEXT */
  if (op == OP_SEARCH)
    priv->search_back = false;
  else if (op == OP_SEARCH_REVERSE)
    priv->search_back = true;
 
  if (priv->search_compiled)
  {
    regfree(&priv->search_re);
    for (size_t i = 0; i < priv->lines_used; i++)
    {
      FREE(&(priv->lines[i].search));
      priv->lines[i].search_arr_size = -1;
    }
  }
 
  uint16_t rflags = mutt_mb_is_lower(priv->search_str) ? REG_ICASE : 0;
  int err = REG_COMP(&priv->search_re, priv->search_str, REG_NEWLINE | rflags);
  if (err != 0)
  {
    regerror(err, &priv->search_re, buf->data, buf->dsize);
    mutt_error("%s", buf_string(buf));
    for (size_t i = 0; i < priv->lines_max; i++)
    {
      /* cleanup */
      FREE(&(priv->lines[i].search));
      priv->lines[i].search_arr_size = -1;
    }
    priv->search_flag = 0;
    priv->search_compiled = false;
    rc = FR_ERROR;
  }
  else
  {
    priv->search_compiled = true;
    /* update the search pointers */
    int line_num = 0;
    while (display_line(priv->fp, &priv->bytes_read, &priv->lines, line_num,
                        &priv->lines_used, &priv->lines_max,
                        MUTT_SEARCH | (pview->flags & MUTT_PAGER_NOWRAP) | priv->has_types,
                        &priv->quote_list, &priv->q_level, &priv->force_redraw,
                        &priv->search_re, priv->pview->win_pager, &priv->ansi_list) == 0)
    {
      line_num++;
    }
 
    if (priv->search_back)
    {
      /* searching backward */
      int i;
      for (i = priv->top_line; i >= 0; i--)
      {
        if ((!priv->hide_quoted || !COLOR_QUOTED(priv->lines[i].cid)) &&
            !priv->lines[i].cont_line && (priv->lines[i].search_arr_size > 0))
        {
          break;
        }
      }
 
      if (i >= 0)
        priv->top_line = i;
    }
    else
    {
      /* searching forward */
      int i;
      for (i = priv->top_line; i < priv->lines_used; i++)
      {
        if ((!priv->hide_quoted || !COLOR_QUOTED(priv->lines[i].cid)) &&
            !priv->lines[i].cont_line && (priv->lines[i].search_arr_size > 0))
        {
          break;
        }
      }
 
      if (i < priv->lines_used)
        priv->top_line = i;
    }
 
    if (priv->lines[priv->top_line].search_arr_size == 0)
    {
      priv->search_flag = 0;
      mutt_error(_("Not found"));
      rc = FR_ERROR;
    }
    else
    {
      const short c_search_context = cs_subset_number(fdata->n->sub, "search_context");
      priv->search_flag = MUTT_SEARCH;
      /* give some context for search results */
      if (c_search_context < priv->pview->win_pager->state.rows)
        priv->searchctx = c_search_context;
      else
        priv->searchctx = 0;
      if (priv->top_line - priv->searchctx > 0)
        priv->top_line -= priv->searchctx;
      rc = FR_SUCCESS;
    }
  }
  pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
 
done:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_pager_search_next()

int op_pager_search_next ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Search for next match - Implements pager_function_t -.

This function handles:

• OP_SEARCH_NEXT
• OP_SEARCH_OPPOSITE

Definition at line 603 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->search_compiled)
  {
    const short c_search_context = cs_subset_number(fdata->n->sub, "search_context");
    bool found = false;
    priv->wrapped = false;
 
    if (c_search_context < priv->pview->win_pager->state.rows)
      priv->searchctx = c_search_context;
    else
      priv->searchctx = 0;
 
    const int op = event->op;
 
  search_next:
    if ((!priv->search_back && (op == OP_SEARCH_NEXT)) ||
        (priv->search_back && (op == OP_SEARCH_OPPOSITE)))
    {
      /* searching forward */
      int i;
      for (i = priv->wrapped ? 0 : priv->top_line + priv->searchctx + 1;
           i < priv->lines_used; i++)
      {
        if ((!priv->hide_quoted || !COLOR_QUOTED(priv->lines[i].cid)) &&
            !priv->lines[i].cont_line && (priv->lines[i].search_arr_size > 0))
        {
          break;
        }
      }
 
      const bool c_wrap_search = cs_subset_bool(fdata->n->sub, "wrap_search");
      if (i < priv->lines_used)
      {
        priv->top_line = i;
        found = true;
      }
      else if (priv->wrapped || !c_wrap_search)
      {
        mutt_error(_("Not found"));
      }
      else
      {
        mutt_message(_("Search wrapped to top"));
        priv->wrapped = true;
        goto search_next;
      }
    }
    else
    {
      /* searching backward */
      int i;
      for (i = priv->wrapped ? priv->lines_used : priv->top_line + priv->searchctx - 1;
           i >= 0; i--)
      {
        if ((!priv->hide_quoted ||
             (priv->has_types && !COLOR_QUOTED(priv->lines[i].cid))) &&
            !priv->lines[i].cont_line && (priv->lines[i].search_arr_size > 0))
        {
          break;
        }
      }
 
      const bool c_wrap_search = cs_subset_bool(fdata->n->sub, "wrap_search");
      if (i >= 0)
      {
        priv->top_line = i;
        found = true;
      }
      else if (priv->wrapped || !c_wrap_search)
      {
        mutt_error(_("Not found"));
      }
      else
      {
        mutt_message(_("Search wrapped to bottom"));
        priv->wrapped = true;
        goto search_next;
      }
    }
 
    if (!found)
      return FR_ERROR;
 
    if (priv->lines[priv->top_line].search_arr_size > 0)
    {
      priv->search_flag = MUTT_SEARCH;
      /* give some context for search results */
      if (priv->top_line - priv->searchctx > 0)
        priv->top_line -= priv->searchctx;
    }
 
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
    return FR_SUCCESS;
  }
 
  /* no previous search pattern */
  return op_pager_search(fdata, event);
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_pager_skip_headers()

int op_pager_skip_headers ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Jump to first line after headers - Implements pager_function_t -.

Definition at line 707 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  struct PagerView *pview = priv->pview;
 
  if (!priv->has_types)
    return FR_NO_ACTION;
 
  int rc = 0;
  int new_topline = 0;
 
  while (((new_topline < priv->lines_used) ||
          (0 == (rc = display_line(priv->fp, &priv->bytes_read, &priv->lines,
                                   new_topline, &priv->lines_used, &priv->lines_max,
                                   MUTT_TYPES | (pview->flags & MUTT_PAGER_NOWRAP), &priv->quote_list,
                                   &priv->q_level, &priv->force_redraw, &priv->search_re,
                                   priv->pview->win_pager, &priv->ansi_list)))) &&
         color_is_header(priv->lines[new_topline].cid))
  {
    new_topline++;
  }
 
  if (rc < 0)
  {
    /* L10N: Displayed if <skip-headers> is invoked in the pager, but
       there is no text past the headers.
       (I don't think this is actually possible in Mutt's code, but
       display some kind of message in case it somehow occurs.) */
    mutt_warning(_("No text past headers"));
    return FR_ERROR;
  }
  priv->top_line = new_topline;
  notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pager_skip_quoted()

int op_pager_skip_quoted ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Skip beyond quoted text - Implements pager_function_t -.

With a count prefix, skip N quoted blocks instead of 1.

Definition at line 838 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
 
  if (!priv->has_types)
    return FR_NO_ACTION;
 
  const int count = MAX(event->count, 1);
 
  for (int i = 0; i < count; i++)
  {
    if (pager_skip_quoted_once(priv, fdata) < 0)
      return FR_NO_ACTION;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_exit()

int op_exit ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Exit this menu - Implements pager_function_t -.

Definition at line 861 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  priv->rc = -1;
  priv->loop = PAGER_LOOP_QUIT;
  return FR_DONE;
}

op_quit()

int op_quit ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Save changes to mailbox and quit - Implements pager_function_t -.

Close the Pager and ask the Index to quit NeoMutt. The Index will save any changes to the Mailbox and close it.

Definition at line 875 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->pview->mode != PAGER_MODE_EMAIL)
    return FR_UNKNOWN;
 
  priv->rc = -1;
  priv->loop = PAGER_LOOP_QUIT;
 
  // Close the Pager, then let the Index handle the quit
  mutt_push_macro_event(0, OP_QUIT);
 
  return FR_DONE;
}

Here is the call graph for this function:

op_help()

int op_help ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Help screen - Implements pager_function_t -.

Definition at line 893 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->pview->mode == PAGER_MODE_HELP)
  {
    /* don't let the user enter the help-menu from the help screen! */
    mutt_error(_("Help is currently being shown"));
    return FR_ERROR;
  }
  mutt_help(fdata->mod_data->md_pager);
  pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_save()

int op_save ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Save the Pager text - Implements pager_function_t -.

Definition at line 910 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  struct PagerView *pview = priv->pview;
  if (pview->mode != PAGER_MODE_OTHER)
    return FR_UNKNOWN;
 
  if (!priv->fp)
    return FR_UNKNOWN;
 
  int rc = FR_ERROR;
  FILE *fp_save = NULL;
  struct Buffer *buf = buf_pool_get();
 
  // Save the current read position
  long pos = ftell(priv->fp);
  fseek(priv->fp, 0, SEEK_SET);
  clearerr(priv->fp);
 
  struct FileCompletionData cdata = { false, NULL, NULL, NULL, NULL };
  if ((mw_get_field(_("Save to file: "), buf, MUTT_COMP_CLEAR, HC_FILE,
                    &CompleteFileOps, &cdata) != 0) ||
      buf_is_empty(buf))
  {
    rc = FR_SUCCESS;
    goto done;
  }
 
  expand_path(buf, false);
  fp_save = mutt_file_fopen(buf_string(buf), "a+");
  if (!fp_save)
  {
    mutt_perror("%s", buf_string(buf));
    goto done;
  }
 
  int bytes = mutt_file_copy_stream(priv->fp, fp_save);
  if (bytes == -1)
  {
    mutt_perror("%s", buf_string(buf));
    goto done;
  }
 
  mutt_message(_("Saved to: %s"), buf_string(buf));
  rc = FR_SUCCESS;
 
done:
  // Restore the read position (rewound at start of function)
  if (pos >= 0)
    (void) mutt_file_seek(priv->fp, pos, SEEK_SET);
 
  mutt_file_fclose(&fp_save);
  buf_pool_release(&buf);
 
  return rc;
}

Here is the call graph for this function:

op_search_toggle()

int op_search_toggle ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Toggle search pattern coloring - Implements pager_function_t -.

Definition at line 970 of file functions.c.

{
  struct PagerPrivateData *priv = fdata->priv;
  if (priv->search_compiled)
  {
    priv->search_flag ^= MUTT_SEARCH;
    pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_view_attachments()

int op_view_attachments ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Show MIME attachments - Implements pager_function_t -.

Definition at line 984 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct PagerPrivateData *priv = fdata->priv;
  struct PagerView *pview = priv->pview;
 
  // This needs to be delegated
  if (pview->flags & MUTT_PAGER_ATTACHMENT)
    return FR_UNKNOWN;
 
  if (!assert_pager_mode(pview->mode == PAGER_MODE_EMAIL))
    return FR_NOT_IMPL;
  dlg_attach(fdata->n->sub, shared->mailbox_view, shared->email,
             pview->pdata->fp, shared->attach_msg);
  if (shared->email->attach_del)
    shared->mailbox->changed = true;
  pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_ignore()

int op_ignore ( struct PagerFunctionData * fdata, const struct KeyEvent * event )

static

Ignore this function - Implements pager_function_t -.

Definition at line 1007 of file functions.c.

{
  return FR_NO_ACTION;
}