NeoMutt  2024-02-01-23-g345d7b
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
message.c File Reference

Process a message for display in the pager. More...

#include "config.h"
#include <errno.h>
#include <stdbool.h>
#include <stdio.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 "attach/lib.h"
#include "index/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "question/lib.h"
#include "copy.h"
#include "format_flags.h"
#include "globals.h"
#include "hdrline.h"
#include "hook.h"
#include "mview.h"
#include "mx.h"
#include "protos.h"
#include "autocrypt/lib.h"
+ Include dependency graph for message.c:

Go to the source code of this file.

Functions

static void process_protected_headers (struct Mailbox *m, struct Email *e)
 Get the protected header and update the index.
 
static int email_to_file (struct Message *msg, struct Buffer *tempfile, struct Mailbox *m, struct Email *e, const char *header, int wrap_len, CopyMessageFlags *cmflags)
 Decrypt, decode and weed an Email into a file.
 
int external_pager (struct MailboxView *mv, struct Email *e, const char *command)
 Display a message in an external program.
 
static void notify_crypto (struct Email *e, struct Message *msg, CopyMessageFlags cmflags)
 Notify the user about the crypto status of the Email.
 
static void squash_index_panel (struct Mailbox *m, struct MuttWindow *win_index, struct MuttWindow *win_pager)
 Shrink or hide the Index Panel.
 
static void expand_index_panel (struct MuttWindow *win_index, struct MuttWindow *win_pager)
 Restore the Index Panel.
 
int mutt_display_message (struct MuttWindow *win_index, struct IndexSharedData *shared)
 Display a message in the pager.
 

Variables

static const char * ExtPagerProgress = N_("all")
 Status bar message when entire message is visible in the Pager.
 

Detailed Description

Process a message for display in the pager.

Authors
  • Richard Russon
  • Pietro Cerutti

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

Function Documentation

◆ process_protected_headers()

static void process_protected_headers ( struct Mailbox m,
struct Email e 
)
static

Get the protected header and update the index.

Parameters
mMailbox
eEmail to update

Definition at line 68 of file message.c.

69{
70 struct Envelope *prot_headers = NULL;
71
72 const bool c_crypt_protected_headers_read = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_read");
73#ifdef USE_AUTOCRYPT
74 const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
75 if (!c_crypt_protected_headers_read && !c_autocrypt)
76 return;
77#else
78 if (!c_crypt_protected_headers_read)
79 return;
80#endif
81
82 /* Grab protected headers to update in the index */
83 if (e->security & SEC_SIGN)
84 {
85 /* Don't update on a bad signature.
86 *
87 * This is a simplification. It's possible the headers are in the
88 * encrypted part of a nested encrypt/signed. But properly handling that
89 * case would require more complexity in the decryption handlers, which
90 * I'm not sure is worth it. */
91 if (!(e->security & SEC_GOODSIGN))
92 return;
93
95 {
96 prot_headers = e->body->parts->mime_headers;
97 }
99 {
100 prot_headers = e->body->mime_headers;
101 }
102 }
103 if (!prot_headers && (e->security & SEC_ENCRYPT))
104 {
105 if (((WithCrypto & APPLICATION_PGP) != 0) &&
108 {
109 prot_headers = e->body->mime_headers;
110 }
112 {
113 prot_headers = e->body->mime_headers;
114 }
115 }
116
117 /* Update protected headers in the index and header cache. */
118 if (c_crypt_protected_headers_read && prot_headers && prot_headers->subject &&
119 !mutt_str_equal(e->env->subject, prot_headers->subject))
120 {
121 if (m->subj_hash && e->env->real_subj)
123
124 mutt_env_set_subject(e->env, prot_headers->subject);
125 FREE(&e->env->disp_subj);
126
127 if (m->subj_hash)
129
130 mx_save_hcache(m, e);
131
132 /* Also persist back to the message headers if this is set */
133 const bool c_crypt_protected_headers_save = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_save");
134 if (c_crypt_protected_headers_save)
135 {
137 e->changed = true;
138 m->changed = true;
139 }
140 }
141
142#ifdef USE_AUTOCRYPT
143 if (c_autocrypt && (e->security & SEC_ENCRYPT) && prot_headers && prot_headers->autocrypt_gossip)
144 {
146 }
147#endif
148}
int mutt_autocrypt_process_gossip_header(struct Email *e, struct Envelope *prot_headers)
Parse an Autocrypt email gossip header.
Definition: autocrypt.c:406
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:394
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
Definition: crypt.c:595
int mutt_is_valid_multipart_pgp_encrypted(struct Body *b)
Is this a valid multi-part encrypted message?
Definition: crypt.c:453
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Definition: crypt.c:490
void mutt_env_set_subject(struct Envelope *env, const char *subj)
Set both subject and real_subj to subj.
Definition: envelope.c:69
#define MUTT_ENV_CHANGED_SUBJECT
Protected header update.
Definition: envelope.h:37
struct HashElem * mutt_hash_insert(struct HashTable *table, const char *strkey, void *data)
Add a new element to the Hash Table (with string keys)
Definition: hash.c:335
void mutt_hash_delete(struct HashTable *table, const char *strkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:427
#define FREE(x)
Definition: memory.h:45
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:709
int mx_save_hcache(struct Mailbox *m, struct Email *e)
Save message to the header cache - Wrapper for MxOps::msg_save_hcache()
Definition: mx.c:1781
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:80
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define WithCrypto
Definition: lib.h:116
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:75
struct Envelope * env
Envelope information.
Definition: email.h:68
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:43
struct Body * body
List of MIME parts.
Definition: email.h:69
bool changed
Email has been edited.
Definition: email.h:77
The header of an Email.
Definition: envelope.h:57
char *const subject
Email's subject.
Definition: envelope.h:70
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:90
struct AutocryptHeader * autocrypt_gossip
Autocrypt Gossip header.
Definition: envelope.h:88
char *const real_subj
Offset of the real subject.
Definition: envelope.h:71
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:72
bool changed
Mailbox has been modified.
Definition: mailbox.h:110
struct HashTable * subj_hash
Hash Table: "subject" -> Email.
Definition: mailbox.h:124
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ email_to_file()

static int email_to_file ( struct Message msg,
struct Buffer tempfile,
struct Mailbox m,
struct Email e,
const char *  header,
int  wrap_len,
CopyMessageFlags cmflags 
)
static

Decrypt, decode and weed an Email into a file.

Parameters
msgRaw Email
tempfileTemporary filename for result
mMailbox
eEmail to display
headerHeader to prefix output (OPTIONAL)
wrap_lenWidth to wrap lines
cmflagsMessage flags, e.g. MUTT_CM_DECODE
Return values
0Success
-1Error
Note
Flags may be added to cmflags

Definition at line 164 of file message.c.

167{
168 int rc = 0;
169 pid_t filterpid = -1;
170
173
174 char columns[16] = { 0 };
175 // win_pager might not be visible and have a size yet, so use win_index
176 snprintf(columns, sizeof(columns), "%d", wrap_len);
177 envlist_set(&EnvList, "COLUMNS", columns, true);
178
179 /* see if crypto is needed for this message. if so, we should exit curses */
180 if ((WithCrypto != 0) && e->security)
181 {
182 if (e->security & SEC_ENCRYPT)
183 {
187 goto cleanup;
188
189 *cmflags |= MUTT_CM_VERIFY;
190 }
191 else if (e->security & SEC_SIGN)
192 {
193 /* find out whether or not the verify signature */
194 /* L10N: Used for the $crypt_verify_sig prompt */
195 if (query_quadoption(_("Verify signature?"), NeoMutt->sub, "crypt_verify_sig") == MUTT_YES)
196 {
197 *cmflags |= MUTT_CM_VERIFY;
198 }
199 }
200 }
201
202 if (*cmflags & MUTT_CM_VERIFY || e->security & SEC_ENCRYPT)
203 {
204 if (e->security & APPLICATION_PGP)
205 {
206 if (!TAILQ_EMPTY(&e->env->from))
208
210 }
211
214 }
215
216 FILE *fp_filter_out = NULL;
217 buf_mktemp(tempfile);
218 FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
219 if (!fp_out)
220 {
221 mutt_error(_("Could not create temporary file"));
222 goto cleanup;
223 }
224
225 const char *const c_display_filter = cs_subset_string(NeoMutt->sub, "display_filter");
226 if (c_display_filter)
227 {
228 fp_filter_out = fp_out;
229 fp_out = NULL;
230 filterpid = filter_create_fd(c_display_filter, &fp_out, NULL, NULL, -1,
231 fileno(fp_filter_out), -1, EnvList);
232 if (filterpid < 0)
233 {
234 mutt_error(_("Can't create display filter"));
235 mutt_file_fclose(&fp_filter_out);
236 unlink(buf_string(tempfile));
237 goto cleanup;
238 }
239 }
240
241 if (header)
242 {
243 fputs(header, fp_out);
244 fputs("\n\n", fp_out);
245 }
246
247 const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
248 CopyHeaderFlags chflags = (c_weed ? (CH_WEED | CH_REORDER) : CH_NO_FLAGS) |
250#ifdef USE_NOTMUCH
251 if (m->type == MUTT_NOTMUCH)
252 chflags |= CH_VIRTUAL;
253#endif
254 rc = mutt_copy_message(fp_out, e, msg, *cmflags, chflags, wrap_len);
255
256 if (((mutt_file_fclose(&fp_out) != 0) && (errno != EPIPE)) || (rc < 0))
257 {
258 mutt_error(_("Could not copy message"));
259 if (fp_filter_out)
260 {
261 filter_wait(filterpid);
262 mutt_file_fclose(&fp_filter_out);
263 }
264 mutt_file_unlink(buf_string(tempfile));
265 goto cleanup;
266 }
267
268 if (fp_filter_out && (filter_wait(filterpid) != 0))
270
271 mutt_file_fclose(&fp_filter_out); /* XXX - check result? */
272
273 if (WithCrypto)
274 {
275 /* update crypto information for this message */
277 e->security |= crypt_query(e->body);
278
279 /* Remove color cache for this message, in case there
280 * are color patterns for both ~g and ~V */
281 e->attr_color = NULL;
282
283 /* Process protected headers and autocrypt gossip headers */
285 }
286
287cleanup:
288 envlist_unset(&EnvList, "COLUMNS");
289 return rc;
290}
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:597
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:97
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
int mutt_copy_message(FILE *fp_out, struct Email *e, struct Message *msg, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:908
#define CH_DECODE
Do RFC2047 header decoding.
Definition: copy.h:56
#define MUTT_CM_VERIFY
Do signature verification.
Definition: copy.h:49
#define CH_FROM
Retain the "From " message separator?
Definition: copy.h:58
#define CH_WEED
Weed the headers?
Definition: copy.h:55
#define CH_REORDER
Re-order output of headers (specified by 'hdr_order')
Definition: copy.h:61
#define CH_DISPLAY
Display result to user.
Definition: copy.h:72
uint32_t CopyHeaderFlags
Flags for mutt_copy_header(), e.g. CH_UPDATE.
Definition: copy.h:52
#define CH_VIRTUAL
Write virtual header lines too.
Definition: copy.h:75
#define CH_NO_FLAGS
No flags are set.
Definition: copy.h:53
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:132
SecurityFlags crypt_query(struct Body *b)
Check out the type of encryption used.
Definition: crypt.c:673
void crypt_invoke_message(SecurityFlags type)
Display an informative message.
Definition: cryptglue.c:156
void crypt_smime_getkeys(struct Envelope *env)
Wrapper for CryptModuleSpecs::smime_getkeys()
Definition: cryptglue.c:454
void crypt_pgp_invoke_getkeys(struct Address *addr)
Wrapper for CryptModuleSpecs::pgp_invoke_getkeys()
Definition: cryptglue.c:273
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:175
bool envlist_set(char ***envp, const char *name, const char *value, bool overwrite)
Set an environment variable.
Definition: envlist.c:88
bool envlist_unset(char ***envp, const char *name)
Unset an environment variable.
Definition: envlist.c:136
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:216
#define mutt_file_fclose(FP)
Definition: file.h:148
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:147
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:219
pid_t filter_create_fd(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, int fdin, int fdout, int fderr, char **envlist)
Run a command on a pipe (optionally connect stdin/stdout)
Definition: filter.c:62
char ** EnvList
Private copy of the environment variables.
Definition: globals.c:78
#define mutt_error(...)
Definition: logging2.h:92
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:671
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:44
#define _(a)
Definition: message.h:28
#define SEC_BADSIGN
Email has a bad signature.
Definition: lib.h:81
static void process_protected_headers(struct Mailbox *m, struct Email *e)
Get the protected header and update the index.
Definition: message.c:68
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition: question.c:373
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_EMPTY(head)
Definition: queue.h:721
const struct AttrColor * attr_color
Color-pair to use when displaying in the index.
Definition: email.h:115
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
FILE * fp
pointer to the message data
Definition: message.h:35
#define buf_mktemp(buf)
Definition: tmp.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ external_pager()

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

Display a message in an external program.

Parameters
mvMailbox view
eEmail to display
commandExternal command to run
Return values
0Success
-1Error

Definition at line 300 of file message.c.

301{
302 if (!mv || !mv->mailbox)
303 return -1;
304
305 struct Mailbox *m = mv->mailbox;
306 struct Message *msg = mx_msg_open(m, e);
307 if (!msg)
308 return -1;
309
310 struct Buffer *buf = buf_pool_get();
311 const char *const c_pager_format = cs_subset_string(NeoMutt->sub, "pager_format");
312 const int screen_width = RootWindow->state.cols;
313 mutt_make_string(buf, screen_width, NONULL(c_pager_format), m, -1, e,
315
316 struct Buffer *tempfile = buf_pool_get();
317
319 int rc = email_to_file(msg, tempfile, m, e, buf_string(buf), screen_width, &cmflags);
320 if (rc < 0)
321 goto cleanup;
322
323 mutt_endwin();
324
325 struct Buffer *cmd = buf_pool_get();
326 buf_printf(cmd, "%s %s", command, buf_string(tempfile));
327 int r = mutt_system(buf_string(cmd));
328 if (r == -1)
329 mutt_error(_("Error running \"%s\""), buf_string(cmd));
330 unlink(buf_string(tempfile));
331 buf_pool_release(&cmd);
332
333 if (!OptNoCurses)
334 keypad(stdscr, true);
335 if (r != -1)
336 mutt_set_flag(m, e, MUTT_READ, true, true);
337 const bool c_prompt_after = cs_subset_bool(NeoMutt->sub, "prompt_after");
338 if ((r != -1) && c_prompt_after)
339 {
342 }
343 else
344 {
345 rc = 0;
346 }
347
348cleanup:
349 buf_pool_release(&buf);
350 mx_msg_close(m, &msg);
351 buf_pool_release(&tempfile);
352 return rc;
353}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:178
#define MUTT_CM_DECODE
Decode the message body into text/plain.
Definition: copy.h:40
#define MUTT_CM_CHARCONV
Perform character set conversions.
Definition: copy.h:44
uint16_t CopyMessageFlags
Flags for mutt_copy_message(), e.g. MUTT_CM_NOHEADER.
Definition: copy.h:36
#define MUTT_CM_DISPLAY
Output is displayed to the user.
Definition: copy.h:41
void mutt_endwin(void)
Shutdown curses.
Definition: curs_lib.c:153
void mutt_unget_ch(int ch)
Return a keystroke to the input buffer.
Definition: get.c:114
void mutt_set_flag(struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
Set a flag on an email.
Definition: flags.c:57
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
int km_dokey(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:463
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: globals.c:72
void mutt_make_string(struct Buffer *buf, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1438
#define GETCH_NO_FLAGS
No flags are set.
Definition: lib.h:51
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:73
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1178
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
Definition: mx.c:1132
static int email_to_file(struct Message *msg, struct Buffer *tempfile, struct Mailbox *m, struct Email *e, const char *header, int wrap_len, CopyMessageFlags *cmflags)
Decrypt, decode and weed an Email into a file.
Definition: message.c:164
static const char * ExtPagerProgress
Status bar message when entire message is visible in the Pager.
Definition: message.c:61
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:51
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: rootwin.c:106
#define NONULL(x)
Definition: string2.h:37
String manipulation buffer.
Definition: buffer.h:36
struct Mailbox * mailbox
Current Mailbox.
Definition: mview.h:51
A mailbox.
Definition: mailbox.h:79
A local copy of an email.
Definition: message.h:34
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
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:55
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ notify_crypto()

static void notify_crypto ( struct Email e,
struct Message msg,
CopyMessageFlags  cmflags 
)
static

Notify the user about the crypto status of the Email.

Parameters
eEmail to display
msgRaw Email
cmflagsMessage flags, e.g. MUTT_CM_DECODE

Definition at line 361 of file message.c.

362{
363 if ((WithCrypto != 0) && (e->security & APPLICATION_SMIME) && (cmflags & MUTT_CM_VERIFY))
364 {
365 if (e->security & SEC_GOODSIGN)
366 {
367 if (crypt_smime_verify_sender(e, msg) == 0)
368 mutt_message(_("S/MIME signature successfully verified"));
369 else
370 mutt_error(_("S/MIME certificate owner does not match sender"));
371 }
372 else if (e->security & SEC_PARTSIGN)
373 {
374 mutt_message(_("Warning: Part of this message has not been signed"));
375 }
376 else if (e->security & SEC_SIGN || e->security & SEC_BADSIGN)
377 {
378 mutt_error(_("S/MIME signature could NOT be verified"));
379 }
380 }
381
382 if ((WithCrypto != 0) && (e->security & APPLICATION_PGP) && (cmflags & MUTT_CM_VERIFY))
383 {
384 if (e->security & SEC_GOODSIGN)
385 mutt_message(_("PGP signature successfully verified"));
386 else if (e->security & SEC_PARTSIGN)
387 mutt_message(_("Warning: Part of this message has not been signed"));
388 else if (e->security & SEC_SIGN)
389 mutt_message(_("PGP signature could NOT be verified"));
390 }
391}
int crypt_smime_verify_sender(struct Email *e, struct Message *msg)
Wrapper for CryptModuleSpecs::smime_verify_sender()
Definition: cryptglue.c:463
#define mutt_message(...)
Definition: logging2.h:91
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:82
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ squash_index_panel()

static void squash_index_panel ( struct Mailbox m,
struct MuttWindow win_index,
struct MuttWindow win_pager 
)
static

Shrink or hide the Index Panel.

Parameters
mMailbox
win_indexIndex Window
win_pagerPager Window

Definition at line 399 of file message.c.

401{
402 const short c_pager_index_lines = cs_subset_number(NeoMutt->sub, "pager_index_lines");
403 if (c_pager_index_lines > 0)
404 {
405 win_index->size = MUTT_WIN_SIZE_FIXED;
406 win_index->req_rows = c_pager_index_lines;
407 win_index->parent->size = MUTT_WIN_SIZE_MINIMISE;
408 }
409 window_set_visible(win_index->parent, (c_pager_index_lines > 0));
410
411 window_set_visible(win_pager->parent, true);
412
413 struct MuttWindow *dlg = dialog_find(win_index);
415
416 // Force the menu to reframe itself
417 struct Menu *menu = win_index->wdata;
418 menu_set_index(menu, menu_get_index(menu));
419}
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:144
struct MuttWindow * dialog_find(struct MuttWindow *win)
Find the parent Dialog of a Window.
Definition: dialog.c:89
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:159
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:173
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:344
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:165
@ MUTT_WIN_SIZE_FIXED
Window has a fixed size.
Definition: mutt_window.h:47
@ MUTT_WIN_SIZE_MINIMISE
Window size depends on its children.
Definition: mutt_window.h:49
Definition: lib.h:69
void * wdata
Private data.
Definition: mutt_window.h:145
short req_rows
Number of rows required.
Definition: mutt_window.h:125
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
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ expand_index_panel()

static void expand_index_panel ( struct MuttWindow win_index,
struct MuttWindow win_pager 
)
static

Restore the Index Panel.

Parameters
win_indexIndex Window
win_pagerPager Window

Definition at line 426 of file message.c.

427{
428 win_index->size = MUTT_WIN_SIZE_MAXIMISE;
430 win_index->parent->size = MUTT_WIN_SIZE_MAXIMISE;
432 window_set_visible(win_index->parent, true);
433
434 window_set_visible(win_pager->parent, false);
435
436 struct MuttWindow *dlg = dialog_find(win_index);
438}
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:52
@ MUTT_WIN_SIZE_MAXIMISE
Window wants as much space as possible.
Definition: mutt_window.h:48
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_display_message()

int mutt_display_message ( struct MuttWindow win_index,
struct IndexSharedData shared 
)

Display a message in the pager.

Parameters
win_indexIndex Window
sharedShared Index data
Return values
0Success
-1Error

Definition at line 447 of file message.c.

448{
449 struct MuttWindow *dlg = dialog_find(win_index);
450 struct MuttWindow *win_pager = window_find_child(dlg, WT_CUSTOM);
451 struct MuttWindow *win_pbar = window_find_child(dlg, WT_STATUS_BAR);
452 struct Buffer *tempfile = buf_pool_get();
453 struct Message *msg = NULL;
454
455 squash_index_panel(shared->mailbox, win_index, win_pager);
456
457 int rc = PAGER_LOOP_QUIT;
458 do
459 {
460 msg = mx_msg_open(shared->mailbox, shared->email);
461 if (!msg)
462 break;
463
465
466 buf_reset(tempfile);
467 // win_pager might not be visible and have a size yet, so use win_index
468 rc = email_to_file(msg, tempfile, shared->mailbox, shared->email, NULL,
469 win_index->state.cols, &cmflags);
470 if (rc < 0)
471 break;
472
473 notify_crypto(shared->email, msg, cmflags);
474
475 /* Invoke the builtin pager */
476 struct PagerData pdata = { 0 };
477 struct PagerView pview = { &pdata };
478
479 pdata.fp = msg->fp;
480 pdata.fname = buf_string(tempfile);
481
482 pview.mode = PAGER_MODE_EMAIL;
483 pview.banner = NULL;
484 pview.flags = MUTT_PAGER_MESSAGE |
485 (shared->email->body->nowrap ? MUTT_PAGER_NOWRAP : 0);
486 pview.win_index = win_index;
487 pview.win_pbar = win_pbar;
488 pview.win_pager = win_pager;
489
490 rc = dlg_pager(&pview);
491 mx_msg_close(shared->mailbox, &msg);
492 } while (rc == PAGER_LOOP_RELOAD);
493
495
496 mx_msg_close(shared->mailbox, &msg);
497 buf_pool_release(&tempfile);
498 return rc;
499}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:93
int dlg_pager(struct PagerView *pview)
Display an email, attachment, or help, in a window -.
Definition: dlg_pager.c:216
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:533
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:95
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
@ PAGER_LOOP_RELOAD
Reload the Pager from scratch.
Definition: lib.h:154
@ PAGER_LOOP_QUIT
Quit the Pager.
Definition: lib.h:153
#define MUTT_PAGER_NOWRAP
Format for term width, ignore $wrap.
Definition: lib.h:73
@ PAGER_MODE_EMAIL
Pager is invoked via 1st path. The mime part is selected automatically.
Definition: lib.h:138
#define MUTT_PAGER_MESSAGE
Definition: lib.h:77
static void expand_index_panel(struct MuttWindow *win_index, struct MuttWindow *win_pager)
Restore the Index Panel.
Definition: message.c:426
static void notify_crypto(struct Email *e, struct Message *msg, CopyMessageFlags cmflags)
Notify the user about the crypto status of the Email.
Definition: message.c:361
static void squash_index_panel(struct Mailbox *m, struct MuttWindow *win_index, struct MuttWindow *win_pager)
Shrink or hide the Index Panel.
Definition: message.c:399
bool nowrap
Do not wrap the output in the pager.
Definition: body.h:88
struct Email * email
Currently selected Email.
Definition: shared_data.h:42
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
Data to be displayed by PagerView.
Definition: lib.h:161
const char * fname
Name of the file to read.
Definition: lib.h:165
FILE * fp
Source stream.
Definition: lib.h:163
Paged view into some data.
Definition: lib.h:172
struct MuttWindow * win_index
Index Window.
Definition: lib.h:178
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:173
enum PagerMode mode
Pager mode.
Definition: lib.h:174
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:175
const char * banner
Title to display in status bar.
Definition: lib.h:176
struct MuttWindow * win_pbar
Pager Bar Window.
Definition: lib.h:179
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:180
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ ExtPagerProgress

const char* ExtPagerProgress = N_("all")
static

Status bar message when entire message is visible in the Pager.

Definition at line 61 of file message.c.