NeoMutt  2022-04-29-249-gaae397
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:
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}
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:437
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
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 {
388 {
389 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true);
390 }
391
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] = { 0 };
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;
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 (pview->mode == PAGER_MODE_EMAIL)
549 {
550 if ((rc == FR_UNKNOWN) && priv->pview->win_index)
552#ifdef USE_SIDEBAR
553 if (rc == FR_UNKNOWN)
554 rc = sb_function_dispatcher(win_sidebar, op);
555#endif
556 }
557 if (rc == FR_UNKNOWN)
558 rc = global_function_dispatcher(NULL, op);
559
560 if ((rc == FR_UNKNOWN) &&
561 ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
562 {
563 // Some attachment functions still need to be delegated
564 priv->rc = op;
565 break;
566 }
567
568 if ((pview->mode != PAGER_MODE_EMAIL) && (rc == FR_UNKNOWN))
570
571 } while (priv->loop == PAGER_LOOP_CONTINUE);
572
573 //-------------------------------------------------------------------------
574 // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
575 //-------------------------------------------------------------------------
576
578 {
579 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true);
580 }
581 mutt_file_fclose(&priv->fp);
582 if (pview->mode == PAGER_MODE_EMAIL)
583 {
584 if (shared->mailboxview)
585 shared->mailboxview->msg_in_pager = -1;
586 }
587
589
590 for (size_t i = 0; i < priv->lines_max; i++)
591 {
592 FREE(&(priv->lines[i].syntax));
593 if (priv->search_compiled && priv->lines[i].search)
594 FREE(&(priv->lines[i].search));
595 }
596 if (priv->search_compiled)
597 {
598 regfree(&priv->search_re);
599 priv->search_compiled = false;
600 }
601 FREE(&priv->lines);
603 {
604 struct AttrColor *ac = NULL;
605 int count = 0;
606 TAILQ_FOREACH(ac, &priv->ansi_list, entries)
607 {
608 count++;
609 }
610 color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
611 }
612
613 priv->pview = NULL;
614
615 if (priv->loop == PAGER_LOOP_RELOAD)
616 return PAGER_LOOP_RELOAD;
617
618 return (priv->rc != -1) ? priv->rc : 0;
619}
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
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
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
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
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
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 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: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
void mutt_timeout_hook(void)
Execute any timeout hooks.
Definition: hook.c:888
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
@ 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_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
void msgwin_clear_text(void)
Clear the text in the Message Window.
Definition: msgwin.c:249
#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
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
@ 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: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
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 86 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 97 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 107 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 123 of file dlg_pager.c.