NeoMutt  2022-04-29-145-g9b6a0e
Teaching an old dog new tricks
DOXYGEN
dlg_pager.c File Reference

Pager Dialog. More...

#include "config.h"
#include <assert.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "lib.h"
#include "color/lib.h"
#include "index/lib.h"
#include "menu/lib.h"
#include "display.h"
#include "functions.h"
#include "hook.h"
#include "keymap.h"
#include "mutt_globals.h"
#include "mutt_logging.h"
#include "mutt_mailbox.h"
#include "mview.h"
#include "mx.h"
#include "opcodes.h"
#include "options.h"
#include "private_data.h"
#include "protos.h"
#include "status.h"
#include "sidebar/lib.h"
+ Include dependency graph for dlg_pager.c:

Go to the source code of this file.

Data Structures

struct  Resize
 Keep track of screen resizing. More...
 

Functions

void pager_queue_redraw (struct PagerPrivateData *priv, PagerRedrawFlags redraw)
 Queue a request for a redraw. More...
 
static const struct Mappingpager_resolve_help_mapping (enum PagerMode mode, enum MailboxType type)
 Determine help mapping based on pager mode and mailbox type. More...
 
static bool check_read_delay (uint64_t *timestamp)
 Is it time to mark the message read? More...
 
int mutt_pager (struct PagerView *pview)
 Display an email, attachment, or help, in a window. More...
 

Variables

int braille_row = -1
 
int braille_col = -1
 
static struct ResizeResize = NULL
 
static const struct Mapping PagerHelp []
 Help Bar for the Pager's Help Page. More...
 
static const struct Mapping PagerHelpHelp []
 Help Bar for the Help Page itself. More...
 
static const struct Mapping PagerNormalHelp []
 Help Bar for the Pager of a normal Mailbox. More...
 
static const struct Mapping PagerNewsHelp []
 Help Bar for the Pager of an NNTP Mailbox. More...
 

Detailed Description

Pager Dialog.

Authors
  • Michael R. Elkins
  • R Primus

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 dlg_pager.c.

Function Documentation

◆ pager_queue_redraw()

void pager_queue_redraw ( struct PagerPrivateData priv,
PagerRedrawFlags  redraw 
)

Queue a request for a redraw.

Parameters
privPrivate Pager data
redrawItem to redraw, e.g. PAGER_REDRAW_PAGER

Definition at line 143 of file dlg_pager.c.

144 {
145  priv->redraw |= redraw;
146  priv->pview->win_pager->actions |= WA_RECALC;
147 }
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:110
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:132
PagerRedrawFlags redraw
When to redraw the screen.
Definition: private_data.h:69
struct PagerView * pview
Object to view in the pager.
Definition: private_data.h:42
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:177
+ Here is the caller graph for this function:

◆ pager_resolve_help_mapping()

static const struct Mapping* pager_resolve_help_mapping ( enum PagerMode  mode,
enum MailboxType  type 
)
static

Determine help mapping based on pager mode and mailbox type.

Parameters
modepager mode
typemailbox type
Return values
ptrHelp Mapping

Definition at line 155 of file dlg_pager.c.

156 {
157  const struct Mapping *result;
158  switch (mode)
159  {
160  case PAGER_MODE_EMAIL:
161  case PAGER_MODE_ATTACH:
162  case PAGER_MODE_ATTACH_E:
163  if (type == MUTT_NNTP)
164  result = PagerNewsHelp;
165  else
166  result = PagerNormalHelp;
167  break;
168 
169  case PAGER_MODE_HELP:
170  result = PagerHelpHelp;
171  break;
172 
173  case PAGER_MODE_OTHER:
174  result = PagerHelp;
175  break;
176 
177  case PAGER_MODE_UNKNOWN:
178  case PAGER_MODE_MAX:
179  default:
180  assert(false); // something went really wrong
181  }
182  assert(result);
183  return result;
184 }
static const struct Mapping PagerHelpHelp[]
Help Bar for the Help Page itself.
Definition: dlg_pager.c:97
static const struct Mapping PagerNewsHelp[]
Help Bar for the Pager of an NNTP Mailbox.
Definition: dlg_pager.c:123
static const struct Mapping PagerNormalHelp[]
Help Bar for the Pager of a normal Mailbox.
Definition: dlg_pager.c:107
static const struct Mapping PagerHelp[]
Help Bar for the Pager's Help Page.
Definition: dlg_pager.c:86
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ PAGER_MODE_OTHER
Pager is invoked via 3rd path. Non-email content is likely to be shown.
Definition: lib.h:139
@ PAGER_MODE_HELP
Pager is invoked via 3rd path to show help.
Definition: lib.h:138
@ PAGER_MODE_ATTACH
Pager is invoked via 2nd path. A user-selected attachment (mime part or a nested email) will be shown...
Definition: lib.h:136
@ PAGER_MODE_EMAIL
Pager is invoked via 1st path. The mime part is selected automatically.
Definition: lib.h:135
@ PAGER_MODE_ATTACH_E
A special case of PAGER_MODE_ATTACH - attachment is a full-blown email message.
Definition: lib.h:137
@ PAGER_MODE_UNKNOWN
A default and invalid mode, should never be used.
Definition: lib.h:133
@ PAGER_MODE_MAX
Another invalid mode, should never be used.
Definition: lib.h:141
Mapping between user-readable string and a constant.
Definition: mapping.h:32
+ Here is the caller graph for this function:

◆ check_read_delay()

static bool check_read_delay ( uint64_t *  timestamp)
static

Is it time to mark the message read?

Parameters
timestampTime when message should be marked read, or 0
Return values
trueMessage should be marked read
falseNo action necessary

Definition at line 192 of file dlg_pager.c.

193 {
194  if ((*timestamp != 0) && (mutt_date_epoch_ms() > *timestamp))
195  {
196  *timestamp = 0;
197  return true;
198  }
199  return false;
200 }
uint64_t mutt_date_epoch_ms(void)
Return the number of milliseconds since the Unix epoch.
Definition: date.c:436
static const char * timestamp(time_t stamp)
Create a YYYY-MM-DD HH:MM:SS timestamp.
Definition: logging.c:77
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_pager()

int mutt_pager ( struct PagerView pview)

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

Parameters
pviewPager view settings
Return values
0Success
-1Error

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 223 of file dlg_pager.c.

224 {
225  //===========================================================================
226  // ACT 1 - Ensure sanity of the caller and determine the mode
227  //===========================================================================
228  assert(pview);
229  assert((pview->mode > PAGER_MODE_UNKNOWN) && (pview->mode < PAGER_MODE_MAX));
230  assert(pview->pdata); // view can't exist in a vacuum
231  assert(pview->win_pager);
232  assert(pview->win_pbar);
233 
234  struct MuttWindow *dlg = dialog_find(pview->win_pager);
235  struct IndexSharedData *shared = dlg->wdata;
236  struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
237 
238  switch (pview->mode)
239  {
240  case PAGER_MODE_EMAIL:
241  // This case was previously identified by IsEmail macro
242  // we expect data to contain email and not contain body
243  // We also expect email to always belong to some mailbox
244  assert(shared->mailboxview);
245  assert(shared->mailbox);
246  assert(shared->email);
247  assert(!pview->pdata->body);
248  break;
249 
250  case PAGER_MODE_ATTACH:
251  // this case was previously identified by IsAttach and IsMsgAttach
252  // macros, we expect data to contain:
253  // - body (viewing regular attachment)
254  // - fp and body->email in special case of viewing an attached email.
255  assert(pview->pdata->body);
256  if (pview->pdata->fp && pview->pdata->body->email)
257  {
258  // Special case: attachment is a full-blown email message.
259  // Yes, emails can contain other emails.
260  pview->mode = PAGER_MODE_ATTACH_E;
261  }
262  break;
263 
264  case PAGER_MODE_HELP:
265  case PAGER_MODE_OTHER:
266  assert(!shared->mailboxview);
267  assert(!shared->email);
268  assert(!pview->pdata->body);
269  break;
270 
271  case PAGER_MODE_UNKNOWN:
272  case PAGER_MODE_MAX:
273  default:
274  // Unexpected mode. Catch fire and explode.
275  // This *should* happen if mode is PAGER_MODE_ATTACH_E, since
276  // we do not expect any caller to pass it to us.
277  assert(false);
278  break;
279  }
280 
281  //===========================================================================
282  // ACT 2 - Declare, initialize local variables, read config, etc.
283  //===========================================================================
284 
285  //---------- local variables ------------------------------------------------
286  int op = 0;
287  enum MailboxType mailbox_type = shared->mailbox ? shared->mailbox->type : MUTT_UNKNOWN;
288  struct PagerPrivateData *priv = pview->win_pager->parent->wdata;
289  priv->rc = -1;
290  priv->searchctx = 0;
291  priv->first = true;
292  priv->wrapped = false;
293  priv->delay_read_timestamp = 0;
294  priv->pager_redraw = false;
295 
296  {
297  // Wipe any previous state info
298  struct Notify *notify = priv->notify;
299  int rc = priv->rc;
300  memset(priv, 0, sizeof(*priv));
301  priv->rc = rc;
302  priv->notify = notify;
303  TAILQ_INIT(&priv->ansi_list);
304  }
305 
306  //---------- setup flags ----------------------------------------------------
307  if (!(pview->flags & MUTT_SHOWCOLOR))
308  pview->flags |= MUTT_SHOWFLAT;
309 
310  if ((pview->mode == PAGER_MODE_EMAIL) && !shared->email->read)
311  {
312  if (shared->mailboxview)
313  shared->mailboxview->msg_in_pager = shared->email->msgno;
314  const short c_pager_read_delay = cs_subset_number(NeoMutt->sub, "pager_read_delay");
315  if (c_pager_read_delay == 0)
316  {
317  mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true);
318  }
319  else
320  {
321  priv->delay_read_timestamp = mutt_date_epoch_ms() + (1000 * c_pager_read_delay);
322  }
323  }
324  //---------- setup help menu ------------------------------------------------
325  pview->win_pager->help_data = pager_resolve_help_mapping(pview->mode, mailbox_type);
326  pview->win_pager->help_menu = MENU_PAGER;
327 
328  //---------- initialize redraw pdata -----------------------------------------
330  priv->lines_max = LINES; // number of lines on screen, from curses
331  priv->lines = mutt_mem_calloc(priv->lines_max, sizeof(struct Line));
332  priv->fp = fopen(pview->pdata->fname, "r");
333  priv->has_types = ((pview->mode == PAGER_MODE_EMAIL) || (pview->flags & MUTT_SHOWCOLOR)) ?
334  MUTT_TYPES :
335  0; // main message or rfc822 attachment
336 
337  for (size_t i = 0; i < priv->lines_max; i++)
338  {
339  priv->lines[i].cid = -1;
340  priv->lines[i].search_arr_size = -1;
341  priv->lines[i].syntax = mutt_mem_calloc(1, sizeof(struct TextSyntax));
342  (priv->lines[i].syntax)[0].first = -1;
343  (priv->lines[i].syntax)[0].last = -1;
344  }
345 
346  // ---------- try to open the pdata file -------------------------------------
347  if (!priv->fp)
348  {
349  mutt_perror(pview->pdata->fname);
350  return -1;
351  }
352 
353  if (stat(pview->pdata->fname, &priv->st) != 0)
354  {
355  mutt_perror(pview->pdata->fname);
356  mutt_file_fclose(&priv->fp);
357  return -1;
358  }
359  unlink(pview->pdata->fname);
360  priv->pview = pview;
361 
362  //---------- show windows, set focus and visibility --------------------------
363  window_set_visible(pview->win_pager->parent, true);
364  mutt_window_reflow(dlg);
366 
367  window_set_focus(pview->win_pager);
368 
369  //---------- jump to the bottom if requested ------------------------------
370  if (pview->flags & MUTT_PAGER_BOTTOM)
371  {
372  jump_to_bottom(priv, pview);
373  }
374 
375  //-------------------------------------------------------------------------
376  // ACT 3: Read user input and decide what to do with it
377  // ...but also do a whole lot of other things.
378  //-------------------------------------------------------------------------
379 
380  // Force an initial paint, which will populate priv->lines
382  window_redraw(NULL);
383 
384  priv->loop = PAGER_LOOP_CONTINUE;
385  do
386  {
388  {
389  mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true);
390  }
391 
393  notify_send(priv->notify, NT_PAGER, NT_PAGER_VIEW, priv);
394  window_redraw(NULL);
395 
396  const bool c_braille_friendly = cs_subset_bool(NeoMutt->sub, "braille_friendly");
397  if (c_braille_friendly)
398  {
399  if (braille_row != -1)
400  {
402  braille_row = -1;
403  }
404  }
405  else
406  mutt_window_move(priv->pview->win_pbar, priv->pview->win_pager->state.cols - 1, 0);
407 
408  // force redraw of the screen at every iteration of the event loop
409  mutt_refresh();
410 
411  //-------------------------------------------------------------------------
412  // Check if information in the status bar needs an update
413  // This is done because pager is a single-threaded application, which
414  // tries to emulate concurrency.
415  //-------------------------------------------------------------------------
416  bool do_new_mail = false;
417  if (shared->mailbox && !OptAttachMsg)
418  {
419  int oldcount = shared->mailbox->msg_count;
420  /* check for new mail */
421  enum MxStatus check = mx_mbox_check(shared->mailbox);
422  if (check == MX_STATUS_ERROR)
423  {
424  if (!shared->mailbox || mutt_buffer_is_empty(&shared->mailbox->pathbuf))
425  {
426  /* fatal error occurred */
428  break;
429  }
430  }
431  else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
432  (check == MX_STATUS_FLAGS))
433  {
434  /* notify user of newly arrived mail */
435  if (check == MX_STATUS_NEW_MAIL)
436  {
437  for (size_t i = oldcount; i < shared->mailbox->msg_count; i++)
438  {
439  struct Email *e = shared->mailbox->emails[i];
440 
441  if (e && !e->read)
442  {
443  mutt_message(_("New mail in this mailbox"));
444  do_new_mail = true;
445  break;
446  }
447  }
448  }
449 
450  if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
451  {
453  OptSearchInvalid = true;
454  }
455  }
456 
457  if (mutt_mailbox_notify(shared->mailbox) || do_new_mail)
458  {
459  const bool c_beep_new = cs_subset_bool(NeoMutt->sub, "beep_new");
460  if (c_beep_new)
461  mutt_beep(true);
462  const char *const c_new_mail_command = cs_subset_string(NeoMutt->sub, "new_mail_command");
463  if (c_new_mail_command)
464  {
465  char cmd[1024];
466  menu_status_line(cmd, sizeof(cmd), shared, NULL, sizeof(cmd),
467  NONULL(c_new_mail_command));
468  if (mutt_system(cmd) != 0)
469  mutt_error(_("Error running \"%s\""), cmd);
470  }
471  }
472  }
473  //-------------------------------------------------------------------------
474 
475  if (priv->pager_redraw)
476  {
477  priv->pager_redraw = false;
479  clearok(stdscr, true); /* force complete redraw */
481 
483  if (pview->flags & MUTT_PAGER_RETWINCH)
484  {
485  /* Store current position. */
486  priv->win_height = -1;
487  for (size_t i = 0; i <= priv->top_line; i++)
488  if (!priv->lines[i].cont_line)
489  priv->win_height++;
490 
491  Resize = mutt_mem_malloc(sizeof(struct Resize));
492 
493  Resize->line = priv->win_height;
495  Resize->search_back = priv->search_back;
496 
497  op = OP_ABORT;
498  priv->rc = OP_REFORMAT_WINCH;
499  break;
500  }
501  else
502  {
503  /* note: mutt_resize_screen() -> mutt_window_reflow() sets
504  * PAGER_REDRAW_PAGER and PAGER_REDRAW_FLOW */
505  op = OP_NULL;
506  }
507  continue;
508  }
509 
510 #ifdef USE_DEBUG_COLOR
511  dump_pager(priv);
512 #endif
513 
514  //-------------------------------------------------------------------------
515  // Finally, read user's key press
516  //-------------------------------------------------------------------------
517  // km_dokey() reads not only user's key strokes, but also a MacroBuffer
518  // MacroBuffer may contain OP codes of the operations.
519  // MacroBuffer is global
520  // OP codes inserted into the MacroBuffer by various functions.
521  // One of such functions is `mutt_enter_command()`
522  // Some OP codes are not handled by pager, they cause pager to quit returning
523  // OP code to index. Index handles the operation and then restarts pager
524  op = km_dokey(MENU_PAGER);
525  if (SigWinch)
526  priv->pager_redraw = true;
527 
528  if (op >= OP_NULL)
530 
531  mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
532 
533  if (op < OP_NULL)
534  {
535  op = OP_NULL;
537  continue;
538  }
539 
540  if (op == OP_NULL)
541  {
543  continue;
544  }
545 
546  int rc = pager_function_dispatcher(priv->pview->win_pager, op);
547 
548  if ((rc == FR_UNKNOWN) && priv->pview->win_index)
549  rc = index_function_dispatcher(priv->pview->win_index, op);
550 #ifdef USE_SIDEBAR
551  if (rc == FR_UNKNOWN)
552  rc = sb_function_dispatcher(win_sidebar, op);
553 #endif
554  if (rc == FR_UNKNOWN)
555  rc = global_function_dispatcher(NULL, op);
556 
557  if ((rc == FR_UNKNOWN) &&
558  ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
559  {
560  // Some attachment functions still need to be delegated
561  priv->rc = op;
562  break;
563  }
564  } while (priv->loop == PAGER_LOOP_CONTINUE);
565 
566  //-------------------------------------------------------------------------
567  // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
568  //-------------------------------------------------------------------------
569 
571  {
572  mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true);
573  }
574  mutt_file_fclose(&priv->fp);
575  if (pview->mode == PAGER_MODE_EMAIL)
576  {
577  if (shared->mailboxview)
578  shared->mailboxview->msg_in_pager = -1;
579  }
580 
582 
583  for (size_t i = 0; i < priv->lines_max; i++)
584  {
585  FREE(&(priv->lines[i].syntax));
586  if (priv->search_compiled && priv->lines[i].search)
587  FREE(&(priv->lines[i].search));
588  }
589  if (priv->search_compiled)
590  {
591  regfree(&priv->search_re);
592  priv->search_compiled = false;
593  }
594  FREE(&priv->lines);
596  {
597  struct AttrColor *ac = NULL;
598  int count = 0;
599  TAILQ_FOREACH(ac, &priv->ansi_list, entries)
600  {
601  count++;
602  }
603  color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
604  }
605 
606  priv->pview = NULL;
607 
608  if (priv->loop == PAGER_LOOP_RELOAD)
609  return PAGER_LOOP_RELOAD;
610 
611  return (priv->rc != -1) ? priv->rc : 0;
612 }
void attr_color_list_clear(struct AttrColorList *acl)
Free the contents of an AttrColorList.
Definition: attr.c:97
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:250
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:140
void mutt_beep(bool force)
Irritate the user.
Definition: curs_lib.c:130
void dump_pager(struct PagerPrivateData *priv)
Definition: pager.c:102
int color_debug(enum LogLevel level, const char *format,...)
Write to the log file.
Definition: debug.c:44
struct MuttWindow * dialog_find(struct MuttWindow *win)
Find the parent Dialog of a Window.
Definition: dialog.c:83
@ FR_UNKNOWN
Unknown function.
Definition: dispatcher.h:33
static const struct Mapping * pager_resolve_help_mapping(enum PagerMode mode, enum MailboxType type)
Determine help mapping based on pager mode and mailbox type.
Definition: dlg_pager.c:155
int braille_col
Definition: dlg_pager.c:81
static bool check_read_delay(uint64_t *timestamp)
Is it time to mark the message read?
Definition: dlg_pager.c:192
void pager_queue_redraw(struct PagerPrivateData *priv, PagerRedrawFlags redraw)
Queue a request for a redraw.
Definition: dlg_pager.c:143
int braille_row
Definition: dlg_pager.c:80
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
int pager_function_dispatcher(struct MuttWindow *win, int op)
Perform a Pager function - Implements function_dispatcher_t -.
Definition: functions.c:789
int sb_function_dispatcher(struct MuttWindow *win, int op)
Perform a Sidebar function - Implements function_dispatcher_t -.
Definition: functions.c:375
int global_function_dispatcher(struct MuttWindow *win, int op)
Perform a Global function - Implements function_dispatcher_t -.
Definition: global.c:164
int index_function_dispatcher(struct MuttWindow *win, int op)
Perform an Index function - Implements function_dispatcher_t -.
Definition: functions.c:2810
#define mutt_error(...)
Definition: logging.h:87
#define mutt_message(...)
Definition: logging.h:86
#define mutt_debug(LEVEL,...)
Definition: logging.h:84
#define mutt_perror(...)
Definition: logging.h:88
void mutt_timeout_hook(void)
Execute any timeout hooks.
Definition: hook.c:882
int km_dokey(enum MenuType mtype)
Determine what a keypress should do.
Definition: keymap.c:795
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: keymap.c:1059
@ LL_DEBUG5
Log at debug level 5.
Definition: logging.h:44
@ LL_DEBUG1
Log at debug level 1.
Definition: logging.h:40
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
#define FREE(x)
Definition: memory.h:43
void msgwin_clear_text(void)
Clear the text in the Message Window.
Definition: msgwin.c:247
#define _(a)
Definition: message.h:28
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:171
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:93
void mutt_resize_screen(void)
Update NeoMutt's opinion about the window size (CURSES)
Definition: resize.c:73
SIG_ATOMIC_VOLATILE_T SigWinch
true after SIGWINCH is received
Definition: mutt_globals.h:70
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
bool mutt_mailbox_notify(struct Mailbox *m_cur)
Notify the user if there's new mail.
Definition: mutt_mailbox.c:230
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:604
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:340
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:293
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:659
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:522
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:164
void window_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:742
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:101
@ MUTT_WIN_SIZE_MAXIMISE
Window wants as much space as possible.
Definition: mutt_window.h:48
enum MxStatus mx_mbox_check(struct Mailbox *m)
Check for new mail - Wrapper for MxOps::mbox_check()
Definition: mx.c:1126
MxStatus
Return values from mbox_check(), mbox_check_stats(), mbox_snc(), and mbox_close()
Definition: mxapi.h:84
@ MX_STATUS_ERROR
An error occurred.
Definition: mxapi.h:85
@ MX_STATUS_FLAGS
Nondestructive flags change (IMAP)
Definition: mxapi.h:90
@ MX_STATUS_REOPENED
Mailbox was reopened.
Definition: mxapi.h:89
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
Definition: mxapi.h:87
@ NT_PAGER
Pager data has changed, NotifyPager, PagerPrivateData.
Definition: notify_type.h:52
const char * opcodes_get_name(int op)
Get the name of an opcode.
Definition: opcodes.c:46
#define OP_ABORT
Definition: opcodes.h:33
bool OptAttachMsg
(pseudo) used by attach-message
Definition: options.h:37
bool OptSearchInvalid
(pseudo) used to invalidate the search pattern
Definition: options.h:57
bool jump_to_bottom(struct PagerPrivateData *priv, struct PagerView *pview)
Make sure the bottom line is displayed.
Definition: functions.c:105
@ PAGER_LOOP_RELOAD
Reload the Pager from scratch.
Definition: lib.h:151
@ PAGER_LOOP_CONTINUE
Stay in the Pager Event Loop.
Definition: lib.h:149
#define MUTT_PAGER_RETWINCH
Need reformatting on SIGWINCH.
Definition: lib.h:69
#define NT_PAGER_VIEW
Pager View has changed.
Definition: lib.h:184
#define MUTT_TYPES
Compute line's type.
Definition: lib.h:63
#define MUTT_SHOWCOLOR
Show characters in color otherwise don't show characters.
Definition: lib.h:60
#define PAGER_REDRAW_FLOW
Reflow the pager.
Definition: lib.h:189
#define MUTT_PAGER_BOTTOM
Start at the bottom.
Definition: lib.h:73
#define PAGER_REDRAW_PAGER
Redraw the pager.
Definition: lib.h:188
#define MUTT_SHOWFLAT
Show characters (used for displaying help)
Definition: lib.h:59
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:64
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:51
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_INIT(head)
Definition: queue.h:765
void qstyle_free_tree(struct QuoteStyle **quote_list)
Free an entire tree of QuoteStyle.
Definition: quoted.c:206
void menu_status_line(char *buf, size_t buflen, struct IndexSharedData *shared, struct Menu *menu, int cols, const char *fmt)
Create the status line.
Definition: status.c:445
#define NONULL(x)
Definition: string2.h:37
A curses colour and its attributes.
Definition: attr.h:35
struct Email * email
header information for message/rfc822
Definition: body.h:73
The envelope/body of an email.
Definition: email.h:37
bool read
Email is read.
Definition: email.h:48
int msgno
Number displayed to the user.
Definition: email.h:111
Data shared between Index, Pager and Sidebar.
Definition: shared_data.h:37
struct MailboxView * mailboxview
Current Mailbox view.
Definition: shared_data.h:39
struct Email * email
Currently selected Email.
Definition: shared_data.h:42
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
A line of text in the pager.
Definition: display.h:51
short search_arr_size
Number of items in search array.
Definition: display.h:60
struct TextSyntax * search
Array of search text in the line.
Definition: display.h:61
bool cont_line
Continuation of a previous line (wrapped by NeoMutt)
Definition: display.h:54
short cid
Default line colour, e.g. MT_COLOR_QUOTED.
Definition: display.h:53
struct TextSyntax * syntax
Array of coloured text in the line.
Definition: display.h:58
int msg_in_pager
Message currently shown in the pager.
Definition: mview.h:43
int msg_count
Total number of messages.
Definition: mailbox.h:88
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
const struct Mapping * help_data
Data for the Help Bar.
Definition: mutt_window.h:142
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
void * wdata
Private data.
Definition: mutt_window.h:145
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:141
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:135
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:131
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
Notification API.
Definition: notify.c:51
const char * fname
Name of the file to read.
Definition: lib.h:162
FILE * fp
Source stream.
Definition: lib.h:160
struct Body * body
Current attachment.
Definition: lib.h:159
Private state data for the Pager.
Definition: private_data.h:41
int rc
Return code from functions.
Definition: private_data.h:73
bool wrapped
Has the search/next wrapped around?
Definition: private_data.h:76
bool pager_redraw
Force a complete redraw.
Definition: private_data.h:78
int lines_max
Capacity of lines array (total entries)
Definition: private_data.h:50
uint64_t delay_read_timestamp
Time that email was first shown.
Definition: private_data.h:77
enum PagerLoopMode loop
What the Event Loop should do next, e.g. PAGER_LOOP_CONTINUE.
Definition: private_data.h:79
struct Line * lines
Array of text lines in pager.
Definition: private_data.h:48
int has_types
Set to MUTT_TYPES for PAGER_MODE_EMAIL or MUTT_SHOWCOLOR.
Definition: private_data.h:56
struct Notify * notify
Notifications: NotifyPager, PagerPrivateData.
Definition: private_data.h:71
int top_line
First visible line on screen.
Definition: private_data.h:55
struct stat st
Stats about Email file.
Definition: private_data.h:45
bool first
First time flag for toggle-new.
Definition: private_data.h:75
bool search_back
Search backwards.
Definition: private_data.h:66
struct QuoteStyle * quote_list
Tree of quoting levels.
Definition: private_data.h:58
struct AttrColorList ansi_list
List of ANSI colours used in the Pager.
Definition: private_data.h:70
int searchctx
Space to show around search matches.
Definition: private_data.h:74
regex_t search_re
Compiled search string.
Definition: private_data.h:65
int win_height
Number of lines in the Window.
Definition: private_data.h:54
FILE * fp
File containing decrypted/decoded/weeded Email.
Definition: private_data.h:44
bool search_compiled
Search regex is in use.
Definition: private_data.h:64
struct MuttWindow * win_index
Index Window.
Definition: lib.h:175
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:170
enum PagerMode mode
Pager mode.
Definition: lib.h:171
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:172
struct MuttWindow * win_pbar
Pager Bar Window.
Definition: lib.h:176
Keep track of screen resizing.
Definition: dlg_pager.c:74
bool search_compiled
Definition: dlg_pager.c:76
bool search_back
Definition: dlg_pager.c:77
int line
Definition: dlg_pager.c:75
Highlighting for a piece of text.
Definition: display.h:40
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:54
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ braille_row

int braille_row = -1

Definition at line 80 of file dlg_pager.c.

◆ braille_col

int braille_col = -1

Definition at line 81 of file dlg_pager.c.

◆ Resize

struct Resize* Resize = NULL
static

Definition at line 83 of file dlg_pager.c.

◆ PagerHelp

const struct Mapping PagerHelp[]
static
Initial value:
= {
{ N_("Exit"), OP_EXIT },
{ N_("PrevPg"), OP_PREV_PAGE },
{ N_("NextPg"), OP_NEXT_PAGE },
{ N_("Help"), OP_HELP },
{ NULL, 0 },
}
#define N_(a)
Definition: message.h:32

Help Bar for the Pager's Help Page.

Definition at line 83 of file dlg_pager.c.

◆ PagerHelpHelp

const struct Mapping PagerHelpHelp[]
static
Initial value:
= {
{ N_("Exit"), OP_EXIT },
{ N_("PrevPg"), OP_PREV_PAGE },
{ N_("NextPg"), OP_NEXT_PAGE },
{ NULL, 0 },
}

Help Bar for the Help Page itself.

Definition at line 83 of file dlg_pager.c.

◆ PagerNormalHelp

const struct Mapping PagerNormalHelp[]
static
Initial value:
= {
{ N_("Exit"), OP_EXIT },
{ N_("PrevPg"), OP_PREV_PAGE },
{ N_("NextPg"), OP_NEXT_PAGE },
{ N_("View Attachm."), OP_VIEW_ATTACHMENTS },
{ N_("Del"), OP_DELETE },
{ N_("Reply"), OP_REPLY },
{ N_("Next"), OP_MAIN_NEXT_UNDELETED },
{ N_("Help"), OP_HELP },
{ NULL, 0 },
}

Help Bar for the Pager of a normal Mailbox.

Definition at line 83 of file dlg_pager.c.

◆ PagerNewsHelp

const struct Mapping PagerNewsHelp[]
static
Initial value:
= {
{ N_("Exit"), OP_EXIT },
{ N_("PrevPg"), OP_PREV_PAGE },
{ N_("NextPg"), OP_NEXT_PAGE },
{ N_("Post"), OP_POST },
{ N_("Followup"), OP_FOLLOWUP },
{ N_("Del"), OP_DELETE },
{ N_("Next"), OP_MAIN_NEXT_UNDELETED },
{ N_("Help"), OP_HELP },
{ NULL, 0 },
}

Help Bar for the Pager of an NNTP Mailbox.

Definition at line 83 of file dlg_pager.c.