lib.h File Reference

GUI display a file/email/help in a viewport with paging. More...

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

Include dependency graph for lib.h:

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

Go to the source code of this file.

Data Structures
struct	PagerData
	Data to be displayed by PagerView. More...
struct	PagerView
	Paged view into some data. More...

Macros
#define	MUTT_PAGER_NO_FLAGS   0
	No flags are set. More...
#define	MUTT_SHOWFLAT   (1 << 0)
	Show characters (used for displaying help) More...
#define	MUTT_SHOWCOLOR   (1 << 1)
	Show characters in color otherwise don't show characters. More...
#define	MUTT_HIDE   (1 << 2)
	Don't show quoted text. More...
#define	MUTT_SEARCH   (1 << 3)
	Resolve search patterns. More...
#define	MUTT_TYPES   (1 << 4)
	Compute line's type. More...
#define	MUTT_SHOW   (MUTT_SHOWCOLOR | MUTT_SHOWFLAT)
#define	MUTT_PAGER_NSKIP   (1 << 5)
	Preserve whitespace with smartwrap. More...
#define	MUTT_PAGER_MARKER   (1 << 6)
	Use markers if option is set. More...
#define	MUTT_PAGER_RETWINCH   (1 << 7)
	Need reformatting on SIGWINCH. More...
#define	MUTT_PAGER_ATTACHMENT   (1 << 8)
	Attachments may exist. More...
#define	MUTT_PAGER_NOWRAP   (1 << 9)
	Format for term width, ignore $wrap. More...
#define	MUTT_PAGER_LOGS   (1 << 10)
	Logview mode. More...
#define	MUTT_PAGER_BOTTOM   (1 << 11)
	Start at the bottom. More...
#define	MUTT_PAGER_MESSAGE   (MUTT_SHOWCOLOR | MUTT_PAGER_MARKER)
#define	MUTT_DISPLAYFLAGS   (MUTT_SHOW | MUTT_PAGER_NSKIP | MUTT_PAGER_MARKER | MUTT_PAGER_LOGS)
#define	NT_PAGER_NO_FLAGS   0
	No flags are set. More...
#define	NT_PAGER_DELETE   (1 << 0)
	Pager Private Data is about to be freed. More...
#define	NT_PAGER_VIEW   (1 << 1)
	Pager View has changed. More...
#define	PAGER_REDRAW_NO_FLAGS   0
	No flags are set. More...
#define	PAGER_REDRAW_PAGER   (1 << 1)
	Redraw the pager. More...
#define	PAGER_REDRAW_FLOW   (1 << 2)
	Reflow the pager. More...

Typedefs
typedef uint16_t	PagerFlags
	Flags for mutt_pager(), e.g. MUTT_SHOWFLAT. More...
typedef uint8_t	NotifyPager
	Flags, e.g. NT_PAGER_DELETE. More...
typedef uint8_t	PagerRedrawFlags
	Flags, e.g. PAGER_REDRAW_PAGER. More...

Enumerations
enum	PagerMode {   PAGER_MODE_UNKNOWN = 0 , PAGER_MODE_EMAIL , PAGER_MODE_ATTACH , PAGER_MODE_ATTACH_E ,   PAGER_MODE_HELP , PAGER_MODE_OTHER , PAGER_MODE_MAX }
	Determine the behaviour of the Pager. More...
enum	PagerLoopMode { PAGER_LOOP_CONTINUE = -7 , PAGER_LOOP_QUIT = -6 , PAGER_LOOP_RELOAD = -5 }
	What the Pager Event Loop should do next. More...

Functions
int	mutt_pager (struct PagerView *pview)
	Display an email, attachment, or help, in a window. More...
int	mutt_do_pager (struct PagerView *pview, struct Email *e)
	Display some page-able text to the user (help or attachment) More...
void	buf_strip_formatting (struct Buffer *dest, const char *src, bool strip_markers)
	Removes ANSI and backspace formatting. More...
struct MuttWindow *	ppanel_new (bool status_on_top, struct IndexSharedData *shared)
	Create the Windows for the Pager panel. More...
struct MuttWindow *	pager_window_new (struct IndexSharedData *shared, struct PagerPrivateData *priv)
	Create a new Pager Window (list of Emails) More...
int	mutt_display_message (struct MuttWindow *win_index, struct IndexSharedData *shared)
	Display a message in the pager. More...
int	external_pager (struct MailboxView *mv, struct Email *e, const char *command)
	Display a message in an external program. More...
void	pager_queue_redraw (struct PagerPrivateData *priv, PagerRedrawFlags redraw)
	Queue a request for a redraw. More...
bool	mutt_is_quote_line (char *buf, regmatch_t *pmatch)
	Is a line of message text a quote? More...
const char *	pager_get_pager (struct ConfigSubset *sub)
	Get the value of $pager. More...
void	mutt_clear_pager_position (void)
void	dump_text_syntax (struct TextSyntax *ts, int num)
void	dump_line (int i, struct Line *line)
void	dump_pager (struct PagerPrivateData *priv)

Variables
int	BrailleRow
	Braille display: row to leave the cursor. More...
int	BrailleCol
	Braille display: column to leave the cursor. More...

Detailed Description

GUI display a file/email/help in a viewport with paging.

Authors

• Michael R. Elkins

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 lib.h.

Macro Definition Documentation

MUTT_PAGER_NO_FLAGS

#define MUTT_PAGER_NO_FLAGS   0

No flags are set.

Definition at line 59 of file lib.h.

MUTT_SHOWFLAT

#define MUTT_SHOWFLAT   (1 << 0)

Show characters (used for displaying help)

Definition at line 60 of file lib.h.

MUTT_SHOWCOLOR

#define MUTT_SHOWCOLOR   (1 << 1)

Show characters in color otherwise don't show characters.

Definition at line 61 of file lib.h.

MUTT_HIDE

#define MUTT_HIDE   (1 << 2)

Don't show quoted text.

Definition at line 62 of file lib.h.

MUTT_SEARCH

#define MUTT_SEARCH   (1 << 3)

Resolve search patterns.

Definition at line 63 of file lib.h.

MUTT_TYPES

#define MUTT_TYPES   (1 << 4)

Compute line's type.

Definition at line 64 of file lib.h.

MUTT_SHOW

#define MUTT_SHOW   (MUTT_SHOWCOLOR | MUTT_SHOWFLAT)

Definition at line 65 of file lib.h.

MUTT_PAGER_NSKIP

#define MUTT_PAGER_NSKIP   (1 << 5)

Preserve whitespace with smartwrap.

Definition at line 68 of file lib.h.

MUTT_PAGER_MARKER

#define MUTT_PAGER_MARKER   (1 << 6)

Use markers if option is set.

Definition at line 69 of file lib.h.

MUTT_PAGER_RETWINCH

#define MUTT_PAGER_RETWINCH   (1 << 7)

Need reformatting on SIGWINCH.

Definition at line 70 of file lib.h.

MUTT_PAGER_ATTACHMENT

#define MUTT_PAGER_ATTACHMENT   (1 << 8)

Attachments may exist.

Definition at line 71 of file lib.h.

MUTT_PAGER_NOWRAP

#define MUTT_PAGER_NOWRAP   (1 << 9)

Format for term width, ignore $wrap.

Definition at line 72 of file lib.h.

MUTT_PAGER_LOGS

#define MUTT_PAGER_LOGS   (1 << 10)

Logview mode.

Definition at line 73 of file lib.h.

MUTT_PAGER_BOTTOM

#define MUTT_PAGER_BOTTOM   (1 << 11)

Start at the bottom.

Definition at line 74 of file lib.h.

MUTT_PAGER_MESSAGE

#define MUTT_PAGER_MESSAGE   (MUTT_SHOWCOLOR | MUTT_PAGER_MARKER)

Definition at line 75 of file lib.h.

MUTT_DISPLAYFLAGS

#define MUTT_DISPLAYFLAGS   (MUTT_SHOW | MUTT_PAGER_NSKIP | MUTT_PAGER_MARKER | MUTT_PAGER_LOGS)

Definition at line 77 of file lib.h.

NT_PAGER_NO_FLAGS

#define NT_PAGER_NO_FLAGS   0

No flags are set.

Definition at line 183 of file lib.h.

NT_PAGER_DELETE

#define NT_PAGER_DELETE   (1 << 0)

Pager Private Data is about to be freed.

Definition at line 184 of file lib.h.

NT_PAGER_VIEW

#define NT_PAGER_VIEW   (1 << 1)

Pager View has changed.

Definition at line 185 of file lib.h.

PAGER_REDRAW_NO_FLAGS

#define PAGER_REDRAW_NO_FLAGS   0

No flags are set.

Definition at line 188 of file lib.h.

PAGER_REDRAW_PAGER

#define PAGER_REDRAW_PAGER   (1 << 1)

Redraw the pager.

Definition at line 189 of file lib.h.

PAGER_REDRAW_FLOW

#define PAGER_REDRAW_FLOW   (1 << 2)

Reflow the pager.

Definition at line 190 of file lib.h.

Typedef Documentation

PagerFlags

typedef uint16_t PagerFlags

Flags for mutt_pager(), e.g. MUTT_SHOWFLAT.

Definition at line 58 of file lib.h.

NotifyPager

typedef uint8_t NotifyPager

Flags, e.g. NT_PAGER_DELETE.

Definition at line 182 of file lib.h.

PagerRedrawFlags

typedef uint8_t PagerRedrawFlags

Flags, e.g. PAGER_REDRAW_PAGER.

Definition at line 187 of file lib.h.

Enumeration Type Documentation

PagerMode

enum PagerMode

Determine the behaviour of the Pager.

Enumerator
PAGER_MODE_UNKNOWN	A default and invalid mode, should never be used.
PAGER_MODE_EMAIL	Pager is invoked via 1st path. The mime part is selected automatically.
PAGER_MODE_ATTACH	Pager is invoked via 2nd path. A user-selected attachment (mime part or a nested email) will be shown.
PAGER_MODE_ATTACH_E	A special case of PAGER_MODE_ATTACH - attachment is a full-blown email message.
PAGER_MODE_HELP	Pager is invoked via 3rd path to show help.
PAGER_MODE_OTHER	Pager is invoked via 3rd path. Non-email content is likely to be shown.
PAGER_MODE_MAX	Another invalid mode, should never be used.

Definition at line 132 of file lib.h.

{
  PAGER_MODE_UNKNOWN = 0, 
 
  PAGER_MODE_EMAIL,       
  PAGER_MODE_ATTACH,      
  PAGER_MODE_ATTACH_E,    
  PAGER_MODE_HELP,        
  PAGER_MODE_OTHER,       
 
  PAGER_MODE_MAX,         
};

PagerLoopMode

enum PagerLoopMode

What the Pager Event Loop should do next.

Enumerator
PAGER_LOOP_CONTINUE	Stay in the Pager Event Loop.
PAGER_LOOP_QUIT	Quit the Pager.
PAGER_LOOP_RELOAD	Reload the Pager from scratch.

Definition at line 148 of file lib.h.

{
  PAGER_LOOP_CONTINUE = -7,  
  PAGER_LOOP_QUIT     = -6,  
  PAGER_LOOP_RELOAD   = -5,  
};

Function Documentation

mutt_pager()

int mutt_pager

(

struct PagerView *

pview

)

Display an email, attachment, or help, in a window.

Parameters

pview

Pager view settings

Return values

0	Success
-1	Error

This pager is actually not so simple as it once was. But it will be again. Currently it operates in 3 modes:

• viewing messages. (PAGER_MODE_EMAIL)
• viewing attachments. (PAGER_MODE_ATTACH)
• viewing other stuff (e.g. help). (PAGER_MODE_OTHER) These can be distinguished by PagerMode in PagerView. Data is not yet polymorphic and is fused into a single struct (PagerData). Different elements of PagerData are expected to be present depending on the mode:
• PAGER_MODE_EMAIL expects data->email and not expects data->body
• PAGER_MODE_ATTACH expects data->email and data->body special sub-case of this mode is viewing attached email message it is recognized by presence of data->fp and data->body->email
• PAGER_MODE_OTHER does not expect data->email or data->body

Definition at line 225 of file dlg_pager.c.

{
  //===========================================================================
  // ACT 1 - Ensure sanity of the caller and determine the mode
  //===========================================================================
  assert(pview);
  assert((pview->mode > PAGER_MODE_UNKNOWN) && (pview->mode < PAGER_MODE_MAX));
  assert(pview->pdata); // view can't exist in a vacuum
  assert(pview->win_pager);
  assert(pview->win_pbar);
 
  struct MuttWindow *dlg = dialog_find(pview->win_pager);
  struct IndexSharedData *shared = dlg->wdata;
  struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
 
  switch (pview->mode)
  {
    case PAGER_MODE_EMAIL:
      // This case was previously identified by IsEmail macro
      // we expect data to contain email and not contain body
      // We also expect email to always belong to some mailbox
      assert(shared->mailbox_view);
      assert(shared->mailbox);
      assert(shared->email);
      assert(!pview->pdata->body);
      break;
 
    case PAGER_MODE_ATTACH:
      // this case was previously identified by IsAttach and IsMsgAttach
      // macros, we expect data to contain:
      //  - body (viewing regular attachment)
      //  - fp and body->email in special case of viewing an attached email.
      assert(pview->pdata->body);
      if (pview->pdata->fp && pview->pdata->body->email)
      {
        // Special case: attachment is a full-blown email message.
        // Yes, emails can contain other emails.
        pview->mode = PAGER_MODE_ATTACH_E;
      }
      break;
 
    case PAGER_MODE_HELP:
    case PAGER_MODE_OTHER:
      assert(!shared->mailbox_view);
      assert(!shared->email);
      assert(!pview->pdata->body);
      break;
 
    case PAGER_MODE_UNKNOWN:
    case PAGER_MODE_MAX:
    default:
      // Unexpected mode. Catch fire and explode.
      // This *should* happen if mode is PAGER_MODE_ATTACH_E, since
      // we do not expect any caller to pass it to us.
      assert(false);
      break;
  }
 
  //===========================================================================
  // ACT 2 - Declare, initialize local variables, read config, etc.
  //===========================================================================
 
  //---------- local variables ------------------------------------------------
  int op = 0;
  enum MailboxType mailbox_type = shared->mailbox ? shared->mailbox->type : MUTT_UNKNOWN;
  struct PagerPrivateData *priv = pview->win_pager->parent->wdata;
  priv->rc = -1;
  priv->searchctx = 0;
  priv->first = true;
  priv->wrapped = false;
  priv->delay_read_timestamp = 0;
  priv->pager_redraw = false;
 
  // Wipe any previous state info
  struct Notify *notify = priv->notify;
  int prc = priv->rc;
  memset(priv, 0, sizeof(*priv));
  priv->rc = prc;
  priv->notify = notify;
  TAILQ_INIT(&priv->ansi_list);
 
  //---------- setup flags ----------------------------------------------------
  if (!(pview->flags & MUTT_SHOWCOLOR))
    pview->flags |= MUTT_SHOWFLAT;
 
  if ((pview->mode == PAGER_MODE_EMAIL) && !shared->email->read)
  {
    if (shared->mailbox_view)
      shared->mailbox_view->msg_in_pager = shared->email->msgno;
    const short c_pager_read_delay = cs_subset_number(NeoMutt->sub, "pager_read_delay");
    if (c_pager_read_delay == 0)
    {
      mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
    }
    else
    {
      priv->delay_read_timestamp = mutt_date_now_ms() + (1000 * c_pager_read_delay);
    }
  }
  //---------- setup help menu ------------------------------------------------
  pview->win_pager->help_data = pager_resolve_help_mapping(pview->mode, mailbox_type);
  pview->win_pager->help_menu = MENU_PAGER;
 
  //---------- initialize redraw pdata  -----------------------------------------
  pview->win_pager->size = MUTT_WIN_SIZE_MAXIMISE;
  priv->lines_max = LINES; // number of lines on screen, from curses
  priv->lines = mutt_mem_calloc(priv->lines_max, sizeof(struct Line));
  priv->fp = fopen(pview->pdata->fname, "r");
  priv->has_types = ((pview->mode == PAGER_MODE_EMAIL) || (pview->flags & MUTT_SHOWCOLOR)) ?
                        MUTT_TYPES :
                        0; // main message or rfc822 attachment
 
  for (size_t i = 0; i < priv->lines_max; i++)
  {
    priv->lines[i].cid = -1;
    priv->lines[i].search_arr_size = -1;
    priv->lines[i].syntax = mutt_mem_calloc(1, sizeof(struct TextSyntax));
    (priv->lines[i].syntax)[0].first = -1;
    (priv->lines[i].syntax)[0].last = -1;
  }
 
  // ---------- try to open the pdata file -------------------------------------
  if (!priv->fp)
  {
    mutt_perror(pview->pdata->fname);
    return -1;
  }
 
  if (stat(pview->pdata->fname, &priv->st) != 0)
  {
    mutt_perror(pview->pdata->fname);
    mutt_file_fclose(&priv->fp);
    return -1;
  }
  unlink(pview->pdata->fname);
  priv->pview = pview;
 
  //---------- show windows, set focus and visibility --------------------------
  window_set_visible(pview->win_pager->parent, true);
  mutt_window_reflow(dlg);
  window_invalidate_all();
 
  window_set_focus(pview->win_pager);
 
  //---------- jump to the bottom if requested ------------------------------
  if (pview->flags & MUTT_PAGER_BOTTOM)
  {
    jump_to_bottom(priv, pview);
  }
 
  //-------------------------------------------------------------------------
  // ACT 3: Read user input and decide what to do with it
  //        ...but also do a whole lot of other things.
  //-------------------------------------------------------------------------
 
  // Force an initial paint, which will populate priv->lines
  pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  window_redraw(NULL);
 
  priv->loop = PAGER_LOOP_CONTINUE;
  do
  {
    pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
    notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
    window_redraw(NULL);
 
    const bool c_braille_friendly = cs_subset_bool(NeoMutt->sub, "braille_friendly");
    if (c_braille_friendly)
    {
      if (BrailleRow != -1)
      {
        mutt_window_move(priv->pview->win_pager, BrailleCol, BrailleRow + 1);
        BrailleRow = -1;
      }
    }
    else
    {
      mutt_window_move(priv->pview->win_pbar, priv->pview->win_pager->state.cols - 1, 0);
    }
 
    // force redraw of the screen at every iteration of the event loop
    mutt_refresh();
 
    //-------------------------------------------------------------------------
    // Check if information in the status bar needs an update
    // This is done because pager is a single-threaded application, which
    // tries to emulate concurrency.
    //-------------------------------------------------------------------------
    bool do_new_mail = false;
    if (shared->mailbox && !OptAttachMsg)
    {
      int oldcount = shared->mailbox->msg_count;
      /* check for new mail */
      enum MxStatus check = mx_mbox_check(shared->mailbox);
      if (check == MX_STATUS_ERROR)
      {
        if (!shared->mailbox || buf_is_empty(&shared->mailbox->pathbuf))
        {
          /* fatal error occurred */
          pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
          break;
        }
      }
      else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
               (check == MX_STATUS_FLAGS))
      {
        /* notify user of newly arrived mail */
        if (check == MX_STATUS_NEW_MAIL)
        {
          for (size_t i = oldcount; i < shared->mailbox->msg_count; i++)
          {
            struct Email *e = shared->mailbox->emails[i];
 
            if (e && !e->read)
            {
              mutt_message(_("New mail in this mailbox"));
              do_new_mail = true;
              break;
            }
          }
        }
 
        if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
        {
          pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
          OptSearchInvalid = true;
        }
      }
 
      if (mutt_mailbox_notify(shared->mailbox) || do_new_mail)
      {
        const bool c_beep_new = cs_subset_bool(NeoMutt->sub, "beep_new");
        if (c_beep_new)
          mutt_beep(true);
        const char *const c_new_mail_command = cs_subset_string(NeoMutt->sub, "new_mail_command");
        if (c_new_mail_command)
        {
          char cmd[1024] = { 0 };
          menu_status_line(cmd, sizeof(cmd), shared, NULL, sizeof(cmd),
                           NONULL(c_new_mail_command));
          if (mutt_system(cmd) != 0)
            mutt_error(_("Error running \"%s\""), cmd);
        }
      }
    }
    //-------------------------------------------------------------------------
 
    if (priv->pager_redraw)
    {
      priv->pager_redraw = false;
      mutt_resize_screen();
      clearok(stdscr, true); /* force complete redraw */
      msgwin_clear_text();
 
      pager_queue_redraw(priv, PAGER_REDRAW_FLOW);
      if (pview->flags & MUTT_PAGER_RETWINCH)
      {
        /* Store current position. */
        priv->win_height = -1;
        for (size_t i = 0; i <= priv->top_line; i++)
          if (!priv->lines[i].cont_line)
            priv->win_height++;
 
        Resize = mutt_mem_malloc(sizeof(struct Resize));
 
        Resize->line = priv->win_height;
        Resize->search_compiled = priv->search_compiled;
        Resize->search_back = priv->search_back;
 
        op = OP_ABORT;
        priv->rc = OP_REFORMAT_WINCH;
        break;
      }
      else
      {
        /* note: mutt_resize_screen() -> mutt_window_reflow() sets
         * PAGER_REDRAW_PAGER and PAGER_REDRAW_FLOW */
        op = OP_NULL;
      }
      continue;
    }
 
#ifdef USE_DEBUG_COLOR
    dump_pager(priv);
#endif
 
    //-------------------------------------------------------------------------
    // Finally, read user's key press
    //-------------------------------------------------------------------------
    // km_dokey() reads not only user's key strokes, but also a MacroBuffer
    // MacroBuffer may contain OP codes of the operations.
    // MacroBuffer is global
    // OP codes inserted into the MacroBuffer by various functions.
    // One of such functions is `mutt_enter_command()`
    // Some OP codes are not handled by pager, they cause pager to quit returning
    // OP code to index. Index handles the operation and then restarts pager
    op = km_dokey(MENU_PAGER);
 
    // km_dokey() can block, so recheck the timer.
    // Note: This check must occur before handling the operations of the index
    // as those can change the currently selected message/entry yielding to
    // marking the wrong message as read.
    if (check_read_delay(&priv->delay_read_timestamp))
    {
      mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
    }
 
    if (SigWinch)
      priv->pager_redraw = true;
 
    if (op >= OP_NULL)
      mutt_clear_error();
 
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
 
    if (op < OP_NULL)
    {
      op = OP_NULL;
      mutt_timeout_hook();
      continue;
    }
 
    if (op == OP_NULL)
    {
      km_error_key(MENU_PAGER);
      continue;
    }
 
    int rc = pager_function_dispatcher(priv->pview->win_pager, op);
 
    if (pview->mode == PAGER_MODE_EMAIL)
    {
      if ((rc == FR_UNKNOWN) && priv->pview->win_index)
        rc = index_function_dispatcher(priv->pview->win_index, op);
#ifdef USE_SIDEBAR
      if (rc == FR_UNKNOWN)
        rc = sb_function_dispatcher(win_sidebar, op);
#endif
    }
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(NULL, op);
 
    if ((rc == FR_UNKNOWN) &&
        ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
    {
      // Some attachment functions still need to be delegated
      priv->rc = op;
      break;
    }
 
    if ((pview->mode != PAGER_MODE_EMAIL) && (rc == FR_UNKNOWN))
      mutt_flushinp();
 
  } while (priv->loop == PAGER_LOOP_CONTINUE);
 
  //-------------------------------------------------------------------------
  // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
  //-------------------------------------------------------------------------
 
  mutt_file_fclose(&priv->fp);
  if (pview->mode == PAGER_MODE_EMAIL)
  {
    if (shared->mailbox_view)
      shared->mailbox_view->msg_in_pager = -1;
  }
 
  qstyle_free_tree(&priv->quote_list);
 
  for (size_t i = 0; i < priv->lines_max; i++)
  {
    FREE(&(priv->lines[i].syntax));
    if (priv->search_compiled && priv->lines[i].search)
      FREE(&(priv->lines[i].search));
  }
  if (priv->search_compiled)
  {
    regfree(&priv->search_re);
    priv->search_compiled = false;
  }
  FREE(&priv->lines);
  attr_color_list_clear(&priv->ansi_list);
  {
    struct AttrColor *ac = NULL;
    int count = 0;
    TAILQ_FOREACH(ac, &priv->ansi_list, entries)
    {
      count++;
    }
    color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
  }
 
  priv->pview = NULL;
 
  if (priv->loop == PAGER_LOOP_RELOAD)
    return PAGER_LOOP_RELOAD;
 
  return (priv->rc != -1) ? priv->rc : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_do_pager()

int mutt_do_pager	(	struct PagerView *	pview,
		struct Email *	e
	)

Display some page-able text to the user (help or attachment)

Parameters

pview	PagerView to construct Pager object
e	Email to use

Return values

0	Success
-1	Error

Definition at line 123 of file do_pager.c.

{
  assert(pview);
  assert(pview->pdata);
  assert(pview->pdata->fname);
  assert((pview->mode == PAGER_MODE_ATTACH) ||
         (pview->mode == PAGER_MODE_HELP) || (pview->mode == PAGER_MODE_OTHER));
 
  struct MuttWindow *dlg = mutt_window_new(WT_DLG_DO_PAGER, MUTT_WIN_ORIENT_VERTICAL,
                                           MUTT_WIN_SIZE_MAXIMISE, MUTT_WIN_SIZE_UNLIMITED,
                                           MUTT_WIN_SIZE_UNLIMITED);
 
  struct IndexSharedData *shared = index_shared_data_new();
  shared->email = e;
 
  notify_set_parent(shared->notify, dlg->notify);
 
  dlg->wdata = shared;
  dlg->wdata_free = index_shared_data_free;
 
  const bool c_status_on_top = cs_subset_bool(NeoMutt->sub, "status_on_top");
  struct MuttWindow *panel_pager = ppanel_new(c_status_on_top, shared);
  dlg->focus = panel_pager;
  mutt_window_add_child(dlg, panel_pager);
 
  notify_observer_add(NeoMutt->notify, NT_CONFIG, dopager_config_observer, dlg);
  notify_observer_add(dlg->notify, NT_WINDOW, dopager_window_observer, dlg);
  dialog_push(dlg);
 
  pview->win_index = NULL;
  pview->win_pbar = window_find_child(panel_pager, WT_STATUS_BAR);
  pview->win_pager = window_find_child(panel_pager, WT_CUSTOM);
 
  int rc;
 
  const char *const c_pager = pager_get_pager(NeoMutt->sub);
  if (c_pager)
  {
    struct Buffer *cmd = buf_pool_get();
 
    mutt_endwin();
    buf_file_expand_fmt_quote(cmd, c_pager, pview->pdata->fname);
    if (mutt_system(buf_string(cmd)) == -1)
    {
      mutt_error(_("Error running \"%s\""), buf_string(cmd));
      rc = -1;
    }
    else
    {
      rc = 0;
    }
    mutt_file_unlink(pview->pdata->fname);
    buf_pool_release(&cmd);
  }
  else
  {
    rc = mutt_pager(pview);
  }
 
  dialog_pop();
  mutt_window_free(&dlg);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buf_strip_formatting()

void buf_strip_formatting	(	struct Buffer *	dest,
		const char *	src,
		bool	strip_markers
	)

Removes ANSI and backspace formatting.

Parameters

dest	Buffer for the result
src	String to strip
strip_markers	Remove

Removes ANSI and backspace formatting, and optionally markers. This is separated out so that it can be used both by the pager and the autoview handler.

This logic is pulled from the pager fill_buffer() function, for use in stripping reply-quoted autoview output of ansi sequences.

Definition at line 688 of file display.c.

{
  const char *s = src;
 
  buf_reset(dest);
 
  if (!s)
    return;
 
  while (s[0] != '\0')
  {
    if ((s[0] == '\010') && (s > src))
    {
      if (s[1] == '_') /* underline */
      {
        s += 2;
      }
      else if (s[1] && buf_len(dest)) /* bold or overstrike */
      {
        dest->dptr--;
        buf_addch(dest, s[1]);
        s += 2;
      }
      else /* ^H */
      {
        buf_addch(dest, *s++);
      }
      continue;
    }
 
    int len = ansi_color_seq_length(s);
    if (len > 0)
    {
      s += len;
    }
    else if (strip_markers && (s[0] == '\033') && (s[1] == ']') &&
             ((check_attachment_marker(s) == 0) || (check_protected_header_marker(s) == 0)))
    {
      mutt_debug(LL_DEBUG2, "Seen attachment marker\n");
      while (*s++ != '\a')
        ; /* skip pseudo-ANSI sequence */
    }
    else
    {
      buf_addch(dest, *s++);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ppanel_new()

struct MuttWindow * ppanel_new	(	bool	status_on_top,
		struct IndexSharedData *	shared
	)

Create the Windows for the Pager panel.

Parameters

status_on_top	true, if the Pager bar should be on top
shared	Shared Index data

Return values

ptr	New Pager Panel

Definition at line 122 of file ppanel.c.

{
  struct MuttWindow *panel_pager = mutt_window_new(WT_PAGER, MUTT_WIN_ORIENT_VERTICAL,
                                                   MUTT_WIN_SIZE_MAXIMISE, MUTT_WIN_SIZE_UNLIMITED,
                                                   MUTT_WIN_SIZE_UNLIMITED);
  panel_pager->state.visible = false; // The Pager and Pager Bar are initially hidden
 
  struct PagerPrivateData *priv = pager_private_data_new();
  panel_pager->wdata = priv;
  panel_pager->wdata_free = pager_private_data_free;
 
  struct MuttWindow *win_pager = pager_window_new(shared, priv);
  panel_pager->focus = win_pager;
 
  struct MuttWindow *win_pbar = pbar_new(shared, priv);
  if (status_on_top)
  {
    mutt_window_add_child(panel_pager, win_pbar);
    mutt_window_add_child(panel_pager, win_pager);
  }
  else
  {
    mutt_window_add_child(panel_pager, win_pager);
    mutt_window_add_child(panel_pager, win_pbar);
  }
 
  notify_observer_add(NeoMutt->notify, NT_CONFIG, ppanel_config_observer, panel_pager);
  notify_observer_add(panel_pager->notify, NT_WINDOW, ppanel_window_observer, panel_pager);
 
  return panel_pager;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_window_new()

struct MuttWindow * pager_window_new	(	struct IndexSharedData *	shared,
		struct PagerPrivateData *	priv
	)

Create a new Pager Window (list of Emails)

Parameters

shared	Shared Index Data
priv	Private Pager Data

Return values

ptr	New Window

Definition at line 414 of file pager.c.

{
  struct MuttWindow *win = mutt_window_new(WT_CUSTOM, MUTT_WIN_ORIENT_VERTICAL,
                                           MUTT_WIN_SIZE_MAXIMISE, MUTT_WIN_SIZE_UNLIMITED,
                                           MUTT_WIN_SIZE_UNLIMITED);
  win->wdata = priv;
  win->recalc = pager_recalc;
  win->repaint = pager_repaint;
 
  notify_observer_add(NeoMutt->notify, NT_COLOR, pager_color_observer, win);
  notify_observer_add(NeoMutt->notify, NT_CONFIG, pager_config_observer, win);
  notify_observer_add(NeoMutt->notify, NT_GLOBAL, pager_global_observer, win);
  notify_observer_add(shared->notify, NT_ALL, pager_index_observer, win);
  notify_observer_add(shared->notify, NT_PAGER, pager_pager_observer, win);
  notify_observer_add(win->notify, NT_WINDOW, pager_window_observer, win);
 
  return win;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_display_message()

int mutt_display_message	(	struct MuttWindow *	win_index,
		struct IndexSharedData *	shared
	)

Display a message in the pager.

Parameters

win_index	Index Window
shared	Shared Index data

Return values

0	Success
-1	Error

Definition at line 458 of file message.c.

{
  struct MuttWindow *dlg = dialog_find(win_index);
  struct MuttWindow *win_pager = window_find_child(dlg, WT_CUSTOM);
  struct MuttWindow *win_pbar = window_find_child(dlg, WT_STATUS_BAR);
  struct Buffer *tempfile = buf_pool_get();
  struct Message *msg = NULL;
 
  squash_index_panel(shared->mailbox, win_index, win_pager);
 
  int rc = PAGER_LOOP_QUIT;
  do
  {
    msg = mx_msg_open(shared->mailbox, shared->email);
    if (!msg)
      break;
 
    CopyMessageFlags cmflags = MUTT_CM_DECODE | MUTT_CM_DISPLAY | MUTT_CM_CHARCONV;
 
    buf_reset(tempfile);
    // win_pager might not be visible and have a size yet, so use win_index
    rc = email_to_file(msg, tempfile, shared->mailbox, shared->email, NULL,
                       win_index->state.cols, &cmflags);
    if (rc < 0)
      break;
 
    notify_crypto(shared->email, msg, cmflags);
 
    /* Invoke the builtin pager */
    struct PagerData pdata = { 0 };
    struct PagerView pview = { &pdata };
 
    pdata.fp = msg->fp;
    pdata.fname = buf_string(tempfile);
 
    pview.mode = PAGER_MODE_EMAIL;
    pview.banner = NULL;
    pview.flags = MUTT_PAGER_MESSAGE |
                  (shared->email->body->nowrap ? MUTT_PAGER_NOWRAP : 0);
    pview.win_index = win_index;
    pview.win_pbar = win_pbar;
    pview.win_pager = win_pager;
 
    rc = mutt_pager(&pview);
    mx_msg_close(shared->mailbox, &msg);
  } while (rc == PAGER_LOOP_RELOAD);
 
  expand_index_panel(win_index, win_pager);
 
  mx_msg_close(shared->mailbox, &msg);
  buf_pool_release(&tempfile);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

external_pager()

int external_pager	(	struct MailboxView *	mv,
		struct Email *	e,
		const char *	command
	)

Display a message in an external program.

Parameters

mv	Mailbox view
e	Email to display
command	External command to run

Return values

0	Success
-1	Error

Definition at line 312 of file message.c.

{
  if (!mv || !mv->mailbox)
    return -1;
 
  struct Mailbox *m = mv->mailbox;
  struct Message *msg = mx_msg_open(m, e);
  if (!msg)
    return -1;
 
  char buf[1024] = { 0 };
  const char *const c_pager_format = cs_subset_string(NeoMutt->sub, "pager_format");
  const int screen_width = RootWindow->state.cols;
  mutt_make_string(buf, sizeof(buf), screen_width, NONULL(c_pager_format), m,
                   -1, e, MUTT_FORMAT_NO_FLAGS, _(ExtPagerProgress));
 
  struct Buffer *tempfile = buf_pool_get();
 
  CopyMessageFlags cmflags = MUTT_CM_DECODE | MUTT_CM_DISPLAY | MUTT_CM_CHARCONV;
  int rc = email_to_file(msg, tempfile, m, e, buf, screen_width, &cmflags);
  if (rc < 0)
    goto cleanup;
 
  mutt_endwin();
 
  struct Buffer *cmd = buf_pool_get();
  buf_printf(cmd, "%s %s", command, buf_string(tempfile));
  int r = mutt_system(buf_string(cmd));
  if (r == -1)
    mutt_error(_("Error running \"%s\""), buf_string(cmd));
  unlink(buf_string(tempfile));
  buf_pool_release(&cmd);
 
  if (!OptNoCurses)
    keypad(stdscr, true);
  if (r != -1)
    mutt_set_flag(m, e, MUTT_READ, true, true);
  const bool c_prompt_after = cs_subset_bool(NeoMutt->sub, "prompt_after");
  if ((r != -1) && c_prompt_after)
  {
    mutt_unget_ch(mutt_any_key_to_continue(_("Command: ")));
    rc = km_dokey(MENU_PAGER);
  }
  else
  {
    rc = 0;
  }
 
cleanup:
  mx_msg_close(m, &msg);
  buf_pool_release(&tempfile);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_queue_redraw()

void pager_queue_redraw	(	struct PagerPrivateData *	priv,
		PagerRedrawFlags	redraw
	)

Queue a request for a redraw.

Parameters

priv	Private Pager data
redraw	Item to redraw, e.g. PAGER_REDRAW_PAGER

Definition at line 145 of file dlg_pager.c.

{
  priv->redraw |= redraw;
  priv->pview->win_pager->actions |= WA_RECALC;
}

Here is the caller graph for this function:

mutt_is_quote_line()

bool mutt_is_quote_line	(	char *	line,
		regmatch_t *	pmatch
	)

Is a line of message text a quote?

Parameters

[in]	line	Line to test
[out]	pmatch	Regex sub-matches

Return values

true	Line is quoted

Checks if line matches the $quote_regex and doesn't match $smileys. This is used by the pager for calling qstyle_classify.

Definition at line 312 of file display.c.

{
  bool is_quote = false;
  const struct Regex *c_smileys = cs_subset_regex(NeoMutt->sub, "smileys");
  regmatch_t pmatch_internal[1];
 
  if (!pmatch)
    pmatch = pmatch_internal;
 
  const struct Regex *c_quote_regex = cs_subset_regex(NeoMutt->sub, "quote_regex");
  if (mutt_regex_capture(c_quote_regex, line, 1, pmatch))
  {
    regmatch_t smatch[1];
    if (mutt_regex_capture(c_smileys, line, 1, smatch))
    {
      if (smatch[0].rm_so > 0)
      {
        char c = line[smatch[0].rm_so];
        line[smatch[0].rm_so] = 0;
 
        if (mutt_regex_capture(c_quote_regex, line, 1, pmatch))
          is_quote = true;
 
        line[smatch[0].rm_so] = c;
      }
    }
    else
    {
      is_quote = true;
    }
  }
 
  return is_quote;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pager_get_pager()

const char * pager_get_pager

(

struct ConfigSubset *

sub

)

Get the value of $pager.

Parameters

sub	Config Subset

Return values

str	External command to use
NULL	The internal pager will be used

Note

If $pager has the magic value of "builtin", NULL will be returned

Definition at line 103 of file config.c.

{
  const char *c_pager = cs_subset_string(sub, "pager");
  if (!c_pager || mutt_str_equal(c_pager, "builtin"))
    return NULL;
 
  return c_pager;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_clear_pager_position()

void mutt_clear_pager_position

(

void

)

dump_text_syntax()

void dump_text_syntax	(	struct TextSyntax *	ts,
		int	num
	)

Definition at line 37 of file pager.c.

{
  if (!ts || (num == 0))
    return;
 
  for (int i = 0; i < num; i++)
  {
    int index = -1;
    const char *swatch = "";
    if (!ts[i].attr_color)
      continue;
    struct CursesColor *cc = ts[i].attr_color->curses_color;
    if (cc)
    {
      index = cc->index;
      swatch = color_debug_log_color(cc->fg, cc->bg);
    }
    mutt_debug(LL_DEBUG1, "\t\t%3d %4d %4d %s\n", index, ts[i].first, ts[i].last, swatch);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_line()

void dump_line	(	int	i,
		struct Line *	line
	)

Definition at line 58 of file pager.c.

{
  mutt_debug(LL_DEBUG1, "Line: %d (offset: %ld)\n", i, line->offset);
  // mutt_debug(LL_DEBUG1, "\toffset: %ld\n", line->offset);
  if ((line->cid > 0) && (line->cid != MT_COLOR_NORMAL))
  {
    struct Buffer *buf = buf_pool_get();
    get_colorid_name(line->cid, buf);
 
    const char *swatch = "";
    struct AttrColor *ac = simple_color_get(line->cid);
    if (ac && ac->curses_color)
    {
      struct CursesColor *cc = ac->curses_color;
      swatch = color_debug_log_color(cc->fg, cc->bg);
    }
 
    mutt_debug(LL_DEBUG1, "\tcolor: %d %s (%s)\n", line->cid, swatch, buf_string(buf));
    buf_pool_release(&buf);
  }
  if (line->cont_line)
  {
    mutt_debug(LL_DEBUG1, "\tcont_line: %s\n",
               line->cont_line ? "\033[1;32myes\033[0m" : "\033[31mno\033[0m");
  }
  if (line->cont_header)
  {
    mutt_debug(LL_DEBUG1, "\tcont_header: %s\n",
               line->cont_header ? "\033[1;32myes\033[0m" : "\033[31mno\033[0m");
  }
 
  if (line->syntax_arr_size > 0)
  {
    mutt_debug(LL_DEBUG1, "\tsyntax: %d\n", line->syntax_arr_size);
    dump_text_syntax(line->syntax, line->syntax_arr_size);
  }
  if (line->search_arr_size > 0)
  {
    mutt_debug(LL_DEBUG1, "\t\033[1;36msearch\033[0m: %d\n", line->search_arr_size);
    dump_text_syntax(line->search, line->search_arr_size);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_pager()

void dump_pager

(

struct PagerPrivateData *

priv

)

Definition at line 101 of file pager.c.

{
  if (!priv)
    return;
 
  mutt_debug(LL_DEBUG1, "----------------------------------------------\n");
  mutt_debug(LL_DEBUG1, "Pager: %d lines (fd %d)\n", priv->lines_used, fileno(priv->fp));
  for (int i = 0; i < priv->lines_used; i++)
  {
    dump_line(i, &priv->lines[i]);
  }
}

Here is the caller graph for this function:

Variable Documentation

BrailleRow

int BrailleRow

extern

Braille display: row to leave the cursor.

Definition at line 80 of file dlg_pager.c.

BrailleCol

int BrailleCol

extern

Braille display: column to leave the cursor.

Definition at line 82 of file dlg_pager.c.