NeoMutt  2022-04-29-323-g5fcc6c
Teaching an old dog new tricks
DOXYGEN
dlg_pager.c
Go to the documentation of this file.
1
34#include "config.h"
35#include <assert.h>
36#include <inttypes.h> // IWYU pragma: keep
37#include <stdbool.h>
38#include <stdio.h>
39#include <string.h>
40#include <sys/stat.h>
41#include <unistd.h>
42#include "mutt/lib.h"
43#include "config/lib.h"
44#include "email/lib.h"
45#include "core/lib.h"
46#include "gui/lib.h"
47#include "mutt.h"
48#include "lib.h"
49#include "color/lib.h"
50#include "index/lib.h"
51#include "menu/lib.h"
52#include "display.h"
53#include "functions.h"
54#include "hook.h"
55#include "keymap.h"
56#include "mutt_globals.h"
57#include "mutt_logging.h"
58#include "mutt_mailbox.h"
59#include "mview.h"
60#include "mx.h"
61#include "opcodes.h"
62#include "options.h"
63#include "private_data.h"
64#include "protos.h"
65#include "status.h"
66#ifdef USE_SIDEBAR
67#include "sidebar/lib.h"
68#endif
69
73struct Resize
74{
75 int line;
78};
79
80int braille_row = -1;
81int braille_col = -1;
82
83static struct Resize *Resize = NULL;
84
86static const struct Mapping PagerHelp[] = {
87 // clang-format off
88 { N_("Exit"), OP_EXIT },
89 { N_("PrevPg"), OP_PREV_PAGE },
90 { N_("NextPg"), OP_NEXT_PAGE },
91 { N_("Help"), OP_HELP },
92 { NULL, 0 },
93 // clang-format on
94};
95
97static const struct Mapping PagerHelpHelp[] = {
98 // clang-format off
99 { N_("Exit"), OP_EXIT },
100 { N_("PrevPg"), OP_PREV_PAGE },
101 { N_("NextPg"), OP_NEXT_PAGE },
102 { NULL, 0 },
103 // clang-format on
104};
105
107static const struct Mapping PagerNormalHelp[] = {
108 // clang-format off
109 { N_("Exit"), OP_EXIT },
110 { N_("PrevPg"), OP_PREV_PAGE },
111 { N_("NextPg"), OP_NEXT_PAGE },
112 { N_("View Attachm."), OP_VIEW_ATTACHMENTS },
113 { N_("Del"), OP_DELETE },
114 { N_("Reply"), OP_REPLY },
115 { N_("Next"), OP_MAIN_NEXT_UNDELETED },
116 { N_("Help"), OP_HELP },
117 { NULL, 0 },
118 // clang-format on
119};
120
121#ifdef USE_NNTP
123static const struct Mapping PagerNewsHelp[] = {
124 // clang-format off
125 { N_("Exit"), OP_EXIT },
126 { N_("PrevPg"), OP_PREV_PAGE },
127 { N_("NextPg"), OP_NEXT_PAGE },
128 { N_("Post"), OP_POST },
129 { N_("Followup"), OP_FOLLOWUP },
130 { N_("Del"), OP_DELETE },
131 { N_("Next"), OP_MAIN_NEXT_UNDELETED },
132 { N_("Help"), OP_HELP },
133 { NULL, 0 },
134 // clang-format on
135};
136#endif
137
144{
145 priv->redraw |= redraw;
146 priv->pview->win_pager->actions |= WA_RECALC;
147}
148
155static const struct Mapping *pager_resolve_help_mapping(enum PagerMode mode, enum MailboxType type)
156{
157 const struct Mapping *result;
158 switch (mode)
159 {
160 case PAGER_MODE_EMAIL:
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
178 case PAGER_MODE_MAX:
179 default:
180 assert(false); // something went really wrong
181 }
182 assert(result);
183 return result;
184}
185
192static bool check_read_delay(uint64_t *timestamp)
193{
194 if ((*timestamp != 0) && (mutt_date_epoch_ms() > *timestamp))
195 {
196 *timestamp = 0;
197 return true;
198 }
199 return false;
200}
201
223int mutt_pager(struct PagerView *pview)
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
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
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);
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);
366
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
385 do
386 {
389 window_redraw(NULL);
390
391 const bool c_braille_friendly = cs_subset_bool(NeoMutt->sub, "braille_friendly");
392 if (c_braille_friendly)
393 {
394 if (braille_row != -1)
395 {
397 braille_row = -1;
398 }
399 }
400 else
401 mutt_window_move(priv->pview->win_pbar, priv->pview->win_pager->state.cols - 1, 0);
402
403 // force redraw of the screen at every iteration of the event loop
404 mutt_refresh();
405
406 //-------------------------------------------------------------------------
407 // Check if information in the status bar needs an update
408 // This is done because pager is a single-threaded application, which
409 // tries to emulate concurrency.
410 //-------------------------------------------------------------------------
411 bool do_new_mail = false;
412 if (shared->mailbox && !OptAttachMsg)
413 {
414 int oldcount = shared->mailbox->msg_count;
415 /* check for new mail */
416 enum MxStatus check = mx_mbox_check(shared->mailbox);
417 if (check == MX_STATUS_ERROR)
418 {
419 if (!shared->mailbox || mutt_buffer_is_empty(&shared->mailbox->pathbuf))
420 {
421 /* fatal error occurred */
423 break;
424 }
425 }
426 else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
427 (check == MX_STATUS_FLAGS))
428 {
429 /* notify user of newly arrived mail */
430 if (check == MX_STATUS_NEW_MAIL)
431 {
432 for (size_t i = oldcount; i < shared->mailbox->msg_count; i++)
433 {
434 struct Email *e = shared->mailbox->emails[i];
435
436 if (e && !e->read)
437 {
438 mutt_message(_("New mail in this mailbox"));
439 do_new_mail = true;
440 break;
441 }
442 }
443 }
444
445 if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
446 {
448 OptSearchInvalid = true;
449 }
450 }
451
452 if (mutt_mailbox_notify(shared->mailbox) || do_new_mail)
453 {
454 const bool c_beep_new = cs_subset_bool(NeoMutt->sub, "beep_new");
455 if (c_beep_new)
456 mutt_beep(true);
457 const char *const c_new_mail_command = cs_subset_string(NeoMutt->sub, "new_mail_command");
458 if (c_new_mail_command)
459 {
460 char cmd[1024] = { 0 };
461 menu_status_line(cmd, sizeof(cmd), shared, NULL, sizeof(cmd),
462 NONULL(c_new_mail_command));
463 if (mutt_system(cmd) != 0)
464 mutt_error(_("Error running \"%s\""), cmd);
465 }
466 }
467 }
468 //-------------------------------------------------------------------------
469
470 if (priv->pager_redraw)
471 {
472 priv->pager_redraw = false;
474 clearok(stdscr, true); /* force complete redraw */
476
478 if (pview->flags & MUTT_PAGER_RETWINCH)
479 {
480 /* Store current position. */
481 priv->win_height = -1;
482 for (size_t i = 0; i <= priv->top_line; i++)
483 if (!priv->lines[i].cont_line)
484 priv->win_height++;
485
486 Resize = mutt_mem_malloc(sizeof(struct Resize));
487
488 Resize->line = priv->win_height;
491
492 op = OP_ABORT;
493 priv->rc = OP_REFORMAT_WINCH;
494 break;
495 }
496 else
497 {
498 /* note: mutt_resize_screen() -> mutt_window_reflow() sets
499 * PAGER_REDRAW_PAGER and PAGER_REDRAW_FLOW */
500 op = OP_NULL;
501 }
502 continue;
503 }
504
505#ifdef USE_DEBUG_COLOR
506 dump_pager(priv);
507#endif
508
509 //-------------------------------------------------------------------------
510 // Finally, read user's key press
511 //-------------------------------------------------------------------------
512 // km_dokey() reads not only user's key strokes, but also a MacroBuffer
513 // MacroBuffer may contain OP codes of the operations.
514 // MacroBuffer is global
515 // OP codes inserted into the MacroBuffer by various functions.
516 // One of such functions is `mutt_enter_command()`
517 // Some OP codes are not handled by pager, they cause pager to quit returning
518 // OP code to index. Index handles the operation and then restarts pager
519 op = km_dokey(MENU_PAGER);
520
521 // km_dokey() can block, so recheck the timer.
522 // Note: This check must occur before handling the operations of the index
523 // as those can change the currently selected message/entry yielding to
524 // marking the wrong message as read.
526 {
527 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true);
528 }
529
530 if (SigWinch)
531 priv->pager_redraw = true;
532
533 if (op >= OP_NULL)
535
536 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
537
538 if (op < OP_NULL)
539 {
540 op = OP_NULL;
542 continue;
543 }
544
545 if (op == OP_NULL)
546 {
548 continue;
549 }
550
551 int rc = pager_function_dispatcher(priv->pview->win_pager, op);
552
553 if (pview->mode == PAGER_MODE_EMAIL)
554 {
555 if ((rc == FR_UNKNOWN) && priv->pview->win_index)
557#ifdef USE_SIDEBAR
558 if (rc == FR_UNKNOWN)
559 rc = sb_function_dispatcher(win_sidebar, op);
560#endif
561 }
562 if (rc == FR_UNKNOWN)
563 rc = global_function_dispatcher(NULL, op);
564
565 if ((rc == FR_UNKNOWN) &&
566 ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
567 {
568 // Some attachment functions still need to be delegated
569 priv->rc = op;
570 break;
571 }
572
573 if ((pview->mode != PAGER_MODE_EMAIL) && (rc == FR_UNKNOWN))
575
576 } while (priv->loop == PAGER_LOOP_CONTINUE);
577
578 //-------------------------------------------------------------------------
579 // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
580 //-------------------------------------------------------------------------
581
582 mutt_file_fclose(&priv->fp);
583 if (pview->mode == PAGER_MODE_EMAIL)
584 {
585 if (shared->mailboxview)
586 shared->mailboxview->msg_in_pager = -1;
587 }
588
590
591 for (size_t i = 0; i < priv->lines_max; i++)
592 {
593 FREE(&(priv->lines[i].syntax));
594 if (priv->search_compiled && priv->lines[i].search)
595 FREE(&(priv->lines[i].search));
596 }
597 if (priv->search_compiled)
598 {
599 regfree(&priv->search_re);
600 priv->search_compiled = false;
601 }
602 FREE(&priv->lines);
604 {
605 struct AttrColor *ac = NULL;
606 int count = 0;
607 TAILQ_FOREACH(ac, &priv->ansi_list, entries)
608 {
609 count++;
610 }
611 color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
612 }
613
614 priv->pview = NULL;
615
616 if (priv->loop == PAGER_LOOP_RELOAD)
617 return PAGER_LOOP_RELOAD;
618
619 return (priv->rc != -1) ? priv->rc : 0;
620}
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:260
Color and attribute parsing.
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: curs_lib.c:592
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
uint64_t mutt_date_epoch_ms(void)
Return the number of milliseconds since the Unix epoch.
Definition: date.c:437
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
Pager Display.
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
int mutt_pager(struct PagerView *pview)
Display an email, attachment, or help, in a window.
Definition: dlg_pager.c:223
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
void pager_queue_redraw(struct PagerPrivateData *priv, PagerRedrawFlags redraw)
Queue a request for a redraw.
Definition: dlg_pager.c:143
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
int braille_row
Definition: dlg_pager.c:80
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
Structs that make up an email.
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:151
int pager_function_dispatcher(struct MuttWindow *win, int op)
Perform a Pager function - Implements function_dispatcher_t -.
Definition: functions.c:786
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:2831
#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
Convenience wrapper for the gui headers.
void mutt_timeout_hook(void)
Execute any timeout hooks.
Definition: hook.c:888
Parse and execute user-defined hooks.
GUI manage the main index (list of emails)
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:1061
Manage keymappings.
static const char * timestamp(time_t stamp)
Create a YYYY-MM-DD HH:MM:SS timestamp.
Definition: logging.c:77
@ 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_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
#define FREE(x)
Definition: memory.h:43
GUI present the user with a selectable list.
void msgwin_clear_text(void)
Clear the text in the Message Window.
Definition: msgwin.c:249
Convenience wrapper for the library headers.
#define N_(a)
Definition: message.h:32
#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
Many unsorted constants and some structs.
@ 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:72
Hundreds of global variables to back the user variables.
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
NeoMutt Logging.
bool mutt_mailbox_notify(struct Mailbox *m_cur)
Notify the user if there's new mail.
Definition: mutt_mailbox.c:230
Mailbox helper functions.
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
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:164
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_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:742
#define WA_RECALC
Recalculate the contents of the Window.
Definition: mutt_window.h:110
@ 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
The "currently-open" mailbox.
enum MxStatus mx_mbox_check(struct Mailbox *m)
Check for new mail - Wrapper for MxOps::mbox_check()
Definition: mx.c:1126
API for mailboxes.
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
All user-callable functions.
#define OP_ABORT
Definition: opcodes.h:33
Handling of global boolean variables.
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:102
@ 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
PagerMode
Determine the behaviour of the Pager.
Definition: lib.h:132
@ 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
#define PAGER_REDRAW_PAGER
Redraw the pager.
Definition: lib.h:188
#define MUTT_SHOWFLAT
Show characters (used for displaying help)
Definition: lib.h:59
uint8_t PagerRedrawFlags
Flags, e.g. PAGER_REDRAW_PAGER.
Definition: lib.h:186
Private state data for the Pager.
Prototypes for many functions.
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:63
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
Sidebar functions.
GUI display the mailboxes in a side panel.
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
GUI display a user-configurable status line.
Key value store.
#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
Mapping between user-readable string and a constant.
Definition: mapping.h:32
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
WindowActionFlags actions
Actions to be performed, e.g. WA_RECALC.
Definition: mutt_window.h:132
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
PagerRedrawFlags redraw
When to redraw the screen.
Definition: private_data.h:69
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 PagerView * pview
Object to view in the pager.
Definition: private_data.h:42
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
Paged view into some data.
Definition: lib.h:169
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
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:177
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