NeoMutt  2024-04-25-127-g771158
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
GUI: Dialog Windows

A Dialog is an interactive set of windows allowing the user to perform some task. More...

Functions

static bool dlg_alias (struct Buffer *buf, struct AliasMenuData *mdata)
 Display a menu of Aliases -.
 
static bool dlg_query (struct Buffer *buf, struct AliasMenuData *mdata)
 Get the user to enter an Address Query -.
 
void dlg_attachment (struct ConfigSubset *sub, struct MailboxView *mv, struct Email *e, FILE *fp, bool attach_msg)
 Show the attachments in a Menu -.
 
void dlg_autocrypt (void)
 Display the Autocrypt account Menu -.
 
void dlg_browser (struct Buffer *file, SelectFileFlags flags, struct Mailbox *m, char ***files, int *numfiles)
 Let the user select a file -.
 
int dlg_compose (struct Email *e, struct Buffer *fcc, uint8_t flags, struct ConfigSubset *sub)
 Allow the user to edit the message envelope -.
 
int dlg_certificate (const char *title, struct CertArray *carr, bool allow_always, bool allow_skip)
 Ask the user to validate the certificate -.
 
void dlg_history (char *buf, size_t buflen, char **matches, int match_count)
 Select an item from a history list -.
 
struct Mailboxdlg_index (struct MuttWindow *dlg, struct Mailbox *m_init)
 Display a list of emails -.
 
struct CryptKeyInfodlg_gpgme (struct CryptKeyInfo *keys, struct Address *p, const char *s, unsigned int app, bool *forced_valid)
 Get the user to select a key -.
 
struct PgpKeyInfodlg_pgp (struct PgpKeyInfo *keys, struct Address *p, const char *s)
 Let the user select a key to use -.
 
struct SmimeKeydlg_smime (struct SmimeKey *keys, const char *query)
 Get the user to select a key -.
 
int dlg_pager (struct PagerView *pview)
 Display an email, attachment, or help, in a window -.
 
bool dlg_pattern (char *buf, size_t buflen)
 Show menu to select a Pattern -.
 
struct Emaildlg_postponed (struct Mailbox *m)
 Create a Menu to select a postponed message -.
 

Detailed Description

A Dialog is an interactive set of windows allowing the user to perform some task.

The All Dialogs window is a container window and not visible. All active dialogs will be children of this window, though only one will be active at a time.

Windows

Name Type Constructor
All Dialogs WT_ALL_DIALOGS alldialogs_new()

Parent

Children

The All Dialogs window has many possible children, e.g.

Data

The All Dialogs window has no data.

Events

Once constructed, it is controlled by the following events:

Event Type Handler
NT_WINDOW alldialogs_window_observer()

The All Dialogs window does not implement MuttWindow::recalc() or MuttWindow::repaint().

Function Documentation

◆ dlg_alias()

static bool dlg_alias ( struct Buffer buf,
struct AliasMenuData mdata 
)
static

Display a menu of Aliases -.

Parameters
bufBuffer for expanded aliases
mdataMenu data holding Aliases
Return values
trueSelection was made

The Alias Dialog is an Address Book. The user can select addresses to add to an Email.

Definition at line 371 of file dlg_alias.c.

372{
373 if (ARRAY_EMPTY(&mdata->ava))
374 {
375 mutt_warning(_("You have no aliases"));
376 return false;
377 }
378
379 mdata->query = buf;
380 mdata->title = mutt_str_dup(_("Aliases"));
381
382 struct MuttWindow *dlg = alias_dialog_new(mdata);
383 struct Menu *menu = dlg->wdata;
384 struct MuttWindow *win_sbar = window_find_child(dlg, WT_STATUS_BAR);
385 mdata->menu = menu;
386 mdata->sbar = win_sbar;
387
388 alias_array_sort(&mdata->ava, mdata->sub);
389
390 struct AliasView *avp = NULL;
391 ARRAY_FOREACH(avp, &mdata->ava)
392 {
393 avp->num = ARRAY_FOREACH_IDX;
394 }
395
396 struct MuttWindow *old_focus = window_set_focus(menu->win);
397 // ---------------------------------------------------------------------------
398 // Event Loop
399 int rc = 0;
400 int op = OP_NULL;
401 do
402 {
403 menu_tagging_dispatcher(menu->win, op);
404 window_redraw(NULL);
405
407 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
408 if (op < 0)
409 continue;
410 if (op == OP_NULL)
411 {
413 continue;
414 }
416
417 rc = alias_function_dispatcher(dlg, op);
418 if (rc == FR_UNKNOWN)
419 rc = menu_function_dispatcher(menu->win, op);
420 if (rc == FR_UNKNOWN)
421 rc = global_function_dispatcher(NULL, op);
422 } while ((rc != FR_DONE) && (rc != FR_CONTINUE));
423 // ---------------------------------------------------------------------------
424
425 window_set_focus(old_focus);
426 simple_dialog_free(&dlg);
427 window_redraw(NULL);
428 return (rc == FR_CONTINUE); // Was a selection made?
429}
void alias_array_sort(struct AliasViewArray *ava, const struct ConfigSubset *sub)
Sort and reindex an AliasViewArray.
Definition: sort.c:168
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:212
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
@ FR_DONE
Exit the Dialog.
Definition: dispatcher.h:35
@ FR_UNKNOWN
Unknown function.
Definition: dispatcher.h:33
@ FR_CONTINUE
Remain in the Dialog.
Definition: dispatcher.h:34
static struct MuttWindow * alias_dialog_new(struct AliasMenuData *mdata)
Create an Alias Selection Dialog.
Definition: dlg_alias.c:334
int km_dokey(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:464
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: get.c:294
int menu_tagging_dispatcher(struct MuttWindow *win, int op)
Perform tagging operations on the Menu - Implements function_dispatcher_t -.
Definition: tagging.c:230
int global_function_dispatcher(struct MuttWindow *win, int op)
Perform a Global function - Implements function_dispatcher_t -.
Definition: global.c:171
int menu_function_dispatcher(struct MuttWindow *win, int op)
Perform a Menu function - Implements function_dispatcher_t -.
Definition: functions.c:318
int alias_function_dispatcher(struct MuttWindow *win, int op)
Perform a Alias function - Implements function_dispatcher_t -.
Definition: functions.c:418
#define mutt_warning(...)
Definition: logging2.h:90
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
void simple_dialog_free(struct MuttWindow **ptr)
Destroy a simple index Dialog.
Definition: simple.c:168
#define GETCH_NO_FLAGS
No flags are set.
Definition: lib.h:51
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
#define _(a)
Definition: message.h:28
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
void window_redraw(struct MuttWindow *win)
Reflow, recalc and repaint a tree of Windows.
Definition: mutt_window.c:633
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:683
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:532
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:101
const char * opcodes_get_name(int op)
Get the name of an opcode.
Definition: opcodes.c:48
struct AliasViewArray ava
All Aliases/Queries.
Definition: gui.h:55
struct MuttWindow * sbar
Status Bar.
Definition: gui.h:61
struct Menu * menu
Menu.
Definition: gui.h:58
struct Buffer * query
Query string.
Definition: gui.h:59
char * title
Title for the status bar.
Definition: gui.h:62
struct ConfigSubset * sub
Config items.
Definition: gui.h:57
GUI data wrapping an Alias.
Definition: gui.h:38
int num
Index number in list.
Definition: gui.h:39
Definition: lib.h:79
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:86
void * wdata
Private data.
Definition: mutt_window.h:144
@ MENU_ALIAS
Select an email address by its alias.
Definition: type.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_query()

static bool dlg_query ( struct Buffer buf,
struct AliasMenuData mdata 
)
static

Get the user to enter an Address Query -.

Parameters
bufBuffer for the query
mdataMenu data holding Aliases
Return values
trueSelection was made

The Select Query Dialog is an Address Book. It is dynamically created from an external source using $query_command.

The user can select addresses to add to an Email.

Definition at line 421 of file dlg_query.c.

422{
423 struct MuttWindow *dlg = query_dialog_new(mdata, buf_string(buf));
424 struct Menu *menu = dlg->wdata;
425 struct MuttWindow *win_sbar = window_find_child(dlg, WT_STATUS_BAR);
426 struct MuttWindow *win_menu = window_find_child(dlg, WT_MENU);
427 mdata->menu = menu;
428 mdata->sbar = win_sbar;
429 mdata->query = buf;
430
431 alias_array_sort(&mdata->ava, mdata->sub);
432
433 struct AliasView *avp = NULL;
434 ARRAY_FOREACH(avp, &mdata->ava)
435 {
436 avp->num = ARRAY_FOREACH_IDX;
437 }
438
439 struct MuttWindow *old_focus = window_set_focus(menu->win);
440 // ---------------------------------------------------------------------------
441 // Event Loop
442 int rc = 0;
443 int op = OP_NULL;
444 do
445 {
446 menu_tagging_dispatcher(menu->win, op);
447 window_redraw(NULL);
448
450 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
451 if (op < 0)
452 continue;
453 if (op == OP_NULL)
454 {
456 continue;
457 }
459
460 rc = alias_function_dispatcher(dlg, op);
461 if (rc == FR_UNKNOWN)
462 rc = menu_function_dispatcher(win_menu, op);
463 if (rc == FR_UNKNOWN)
464 rc = global_function_dispatcher(NULL, op);
465 } while ((rc != FR_DONE) && (rc != FR_CONTINUE));
466 // ---------------------------------------------------------------------------
467
468 window_set_focus(old_focus);
469 simple_dialog_free(&dlg);
470 window_redraw(NULL);
471 return (rc == FR_CONTINUE); // Was a selection made?
472}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
static struct MuttWindow * query_dialog_new(struct AliasMenuData *mdata, const char *query)
Create an Query Selection Dialog.
Definition: dlg_query.c:380
@ WT_MENU
An Window containing a Menu.
Definition: mutt_window.h:97
@ MENU_QUERY
Select from results of external query.
Definition: type.h:55
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_attachment()

void dlg_attachment ( struct ConfigSubset sub,
struct MailboxView mv,
struct Email e,
FILE *  fp,
bool  attach_msg 
)

Show the attachments in a Menu -.

Parameters
subConfig Subset
mvMailbox view
eEmail
fpFile with the content of the email, or NULL
attach_msgAre we in "attach message" mode?

The Select Attachment dialog shows an Email's attachments. They can be viewed using the Pager or Mailcap programs. They can also be saved, printed, deleted, etc.

Definition at line 539 of file dlg_attach.c.

541{
542 if (!mv || !mv->mailbox || !e || !fp)
543 return;
544
545 struct Mailbox *m = mv->mailbox;
546
547 /* make sure we have parsed this message */
550
552 struct Menu *menu = dlg->wdata;
554 menu->tag = attach_tag;
555
556 struct AttachCtx *actx = mutt_actx_new();
557 actx->email = e;
558 actx->fp_root = fp;
559 mutt_update_recvattach_menu(actx, menu, true);
560
562 priv->menu = menu;
563 priv->actx = actx;
564 priv->sub = sub;
565 priv->mailbox = m;
566 priv->attach_msg = attach_msg;
567 menu->mdata = priv;
569
570 // NT_COLOR is handled by the SimpleDialog
573
574 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
575 sbar_set_title(sbar, _("Attachments"));
576
577 struct MuttWindow *old_focus = window_set_focus(menu->win);
578 // ---------------------------------------------------------------------------
579 // Event Loop
580 int rc = 0;
581 int op = OP_NULL;
582 do
583 {
584 menu_tagging_dispatcher(menu->win, op);
585 window_redraw(NULL);
586
588 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
589 if (op < 0)
590 continue;
591 if (op == OP_NULL)
592 {
594 continue;
595 }
597
598 rc = attach_function_dispatcher(dlg, op);
599 if (rc == FR_UNKNOWN)
600 rc = menu_function_dispatcher(menu->win, op);
601 if (rc == FR_UNKNOWN)
602 rc = global_function_dispatcher(NULL, op);
603
604 if (rc == FR_CONTINUE)
605 {
606 op = priv->op;
607 }
608
609 } while (rc != FR_DONE);
610 // ---------------------------------------------------------------------------
611
612 window_set_focus(old_focus);
613 simple_dialog_free(&dlg);
614}
struct AttachCtx * mutt_actx_new(void)
Create a new Attachment Context.
Definition: attach.c:189
struct AttachPrivateData * attach_private_data_new(void)
Create new Attach Data.
Definition: private_data.c:50
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:597
static const struct Mapping AttachmentHelp[]
Help Bar for the Attachment selection dialog.
Definition: dlg_attach.c:98
int attach_function_dispatcher(struct MuttWindow *win, int op)
Perform a Attach function - Implements function_dispatcher_t -.
Definition: functions.c:713
static int attach_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an Attachment for the Menu - Implements Menu::make_entry() -.
Definition: dlg_attach.c:465
void attach_private_data_free(struct Menu *menu, void **ptr)
Free the Attach Data - Implements Menu::mdata_free() -.
Definition: private_data.c:38
static int attach_tag(struct Menu *menu, int sel, int act)
Tag an attachment - Implements Menu::tag() -.
Definition: dlg_attach.c:485
static int attach_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_attach.c:114
static int attach_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_attach.c:504
struct MuttWindow * simple_dialog_new(enum MenuType mtype, enum WindowType wtype, const struct Mapping *help_data)
Create a simple index Dialog.
Definition: simple.c:132
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:692
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:44
bool notify_observer_add(struct Notify *notify, enum NotifyType type, observer_t callback, void *global_data)
Add an observer to an object.
Definition: notify.c:191
@ WT_DLG_ATTACHMENT
Attachment Dialog, dlg_attachment()
Definition: mutt_window.h:78
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:57
@ NT_CONFIG
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:43
void mutt_update_recvattach_menu(struct AttachCtx *actx, struct Menu *menu, bool init)
Update the Attachment Menu.
Definition: recvattach.c:1214
void sbar_set_title(struct MuttWindow *win, const char *title)
Set the title for the Simple Bar.
Definition: sbar.c:227
A set of attachments.
Definition: attach.h:65
FILE * fp_root
Used by recvattach for updating.
Definition: attach.h:67
struct Email * email
Used by recvattach for updating.
Definition: attach.h:66
Private state data for Attachments.
Definition: private_data.h:36
int op
Op returned from the Pager, e.g. OP_NEXT_ENTRY.
Definition: private_data.h:41
struct Menu * menu
Current Menu.
Definition: private_data.h:37
struct ConfigSubset * sub
Config subset.
Definition: private_data.h:39
struct AttachCtx * actx
List of all Attachments.
Definition: private_data.h:38
bool attach_msg
Are we in "attach message" mode?
Definition: private_data.h:42
struct Mailbox * mailbox
Current Mailbox.
Definition: private_data.h:40
struct Notify * notify
Notifications: NotifyConfig, EventConfig.
Definition: subset.h:52
struct Mailbox * mailbox
Current Mailbox.
Definition: mview.h:51
A mailbox.
Definition: mailbox.h:79
void(* mdata_free)(struct Menu *menu, void **ptr)
Definition: lib.h:161
int(* tag)(struct Menu *menu, int sel, int act)
Definition: lib.h:131
int(* make_entry)(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Definition: lib.h:106
void * mdata
Private data.
Definition: lib.h:147
struct Notify * notify
Notifications: NotifyWindow, EventWindow.
Definition: mutt_window.h:137
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
@ MENU_ATTACHMENT
Select an attachment.
Definition: type.h:38
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_autocrypt()

void dlg_autocrypt ( void  )

Display the Autocrypt account Menu -.

The Autocrypt Dialog lets the user select an Autocrypt Account to use.

Definition at line 328 of file dlg_autocrypt.c.

329{
330 const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
331 if (!c_autocrypt)
332 return;
333
334 if (mutt_autocrypt_init(false))
335 return;
336
338
339 struct Menu *menu = dlg->wdata;
341
342 populate_menu(menu);
343
344 struct AutocryptData ad = { false, menu };
345 dlg->wdata = &ad;
346
347 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
348 // L10N: Autocrypt Account Management Menu title
349 sbar_set_title(sbar, _("Autocrypt Accounts"));
350
351 // NT_COLOR is handled by the SimpleDialog
354
355 struct MuttWindow *old_focus = window_set_focus(menu->win);
356 // ---------------------------------------------------------------------------
357 // Event Loop
358 int op = OP_NULL;
359 do
360 {
361 menu_tagging_dispatcher(menu->win, op);
362 window_redraw(NULL);
363
365 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
366 if (op < 0)
367 continue;
368 if (op == OP_NULL)
369 {
371 continue;
372 }
374
375 int rc = autocrypt_function_dispatcher(dlg, op);
376
377 if (rc == FR_UNKNOWN)
378 rc = menu_function_dispatcher(menu->win, op);
379 if (rc == FR_UNKNOWN)
380 rc = global_function_dispatcher(NULL, op);
381 } while (!ad.done);
382 // ---------------------------------------------------------------------------
383
384 window_set_focus(old_focus);
385 simple_dialog_free(&dlg);
386}
int mutt_autocrypt_init(bool can_create)
Initialise Autocrypt.
Definition: autocrypt.c:99
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
static const struct Mapping AutocryptHelp[]
Help Bar for the Autocrypt Account selection dialog.
Definition: dlg_autocrypt.c:88
bool populate_menu(struct Menu *menu)
Add the Autocrypt data to a Menu.
int autocrypt_function_dispatcher(struct MuttWindow *win, int op)
Perform a Autocrypt function - Implements function_dispatcher_t -.
Definition: functions.c:203
static int autocrypt_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an Autocrypt Account for the Menu - Implements Menu::make_entry() -.
static int autocrypt_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
static int autocrypt_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
@ WT_DLG_AUTOCRYPT
Autocrypt Dialog, dlg_autocrypt()
Definition: mutt_window.h:79
Data to pass to the Autocrypt Functions.
Definition: functions.h:34
bool done
Should we close the Dialog?
Definition: functions.h:35
struct Menu * menu
Autocrypt Menu.
Definition: functions.h:36
@ MENU_AUTOCRYPT
Autocrypt Account menu.
Definition: type.h:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_browser()

void dlg_browser ( struct Buffer file,
SelectFileFlags  flags,
struct Mailbox m,
char ***  files,
int *  numfiles 
)

Let the user select a file -.

Parameters
[in]fileBuffer for the result
[in]flagsFlags, see SelectFileFlags
[in]mMailbox
[out]filesArray of selected files
[out]numfilesNumber of selected files

The Select File Dialog is a file browser. It allows the user to select a file or directory to use.

Definition at line 1295 of file dlg_browser.c.

1297{
1299 priv->file = file;
1300 priv->mailbox = m;
1301 priv->files = files;
1302 priv->numfiles = numfiles;
1303 struct MuttWindow *dlg = NULL;
1304
1305 priv->multiple = (flags & MUTT_SEL_MULTI);
1306 priv->folder = (flags & MUTT_SEL_FOLDER);
1307 priv->state.is_mailbox_list = (flags & MUTT_SEL_MAILBOX) && priv->folder;
1308 priv->last_selected_mailbox = -1;
1309
1310 init_lastdir();
1311
1312 if (OptNews)
1313 {
1314 if (buf_is_empty(file))
1315 {
1317
1318 /* default state for news reader mode is browse subscribed newsgroups */
1319 priv->state.is_mailbox_list = false;
1320 for (size_t i = 0; i < adata->groups_num; i++)
1321 {
1322 struct NntpMboxData *mdata = adata->groups_list[i];
1323 if (mdata && mdata->subscribed)
1324 {
1325 priv->state.is_mailbox_list = true;
1326 break;
1327 }
1328 }
1329 }
1330 else
1331 {
1332 buf_copy(priv->prefix, file);
1333 }
1334 }
1335 else if (!buf_is_empty(file))
1336 {
1337 buf_expand_path(file);
1338 if (imap_path_probe(buf_string(file), NULL) == MUTT_IMAP)
1339 {
1340 init_state(&priv->state, NULL);
1341 priv->state.imap_browse = true;
1342 if (imap_browse(buf_string(file), &priv->state) == 0)
1343 {
1344 buf_strcpy(&LastDir, priv->state.folder);
1345 browser_sort(&priv->state);
1346 }
1347 }
1348 else
1349 {
1350 int i;
1351 for (i = buf_len(file) - 1; (i > 0) && ((buf_string(file))[i] != '/'); i--)
1352 {
1353 ; // do nothing
1354 }
1355
1356 if (i > 0)
1357 {
1358 if ((buf_string(file))[0] == '/')
1359 {
1360 buf_strcpy_n(&LastDir, buf_string(file), i);
1361 }
1362 else
1363 {
1365 buf_addch(&LastDir, '/');
1366 buf_addstr_n(&LastDir, buf_string(file), i);
1367 }
1368 }
1369 else
1370 {
1371 if ((buf_string(file))[0] == '/')
1372 buf_strcpy(&LastDir, "/");
1373 else
1375 }
1376
1377 if ((i <= 0) && (buf_string(file)[0] != '/'))
1378 buf_copy(priv->prefix, file);
1379 else
1380 buf_strcpy(priv->prefix, buf_string(file) + i + 1);
1381 priv->kill_prefix = true;
1382 }
1383 }
1384 else
1385 {
1386 if (priv->folder)
1387 {
1388 /* Whether we use the tracking feature of the browser depends
1389 * on which sort method we chose to use. This variable is defined
1390 * only to help readability of the code. */
1391 bool browser_track = false;
1392
1393 const enum SortType c_sort_browser = cs_subset_sort(NeoMutt->sub, "sort_browser");
1394 switch (c_sort_browser & SORT_MASK)
1395 {
1396 case SORT_DESC:
1397 case SORT_SUBJECT:
1398 case SORT_ORDER:
1399 browser_track = true;
1400 break;
1401 }
1402
1403 /* We use mutt_browser_select_dir to initialize the two
1404 * variables (LastDir, LastDirBackup) at the appropriate
1405 * values.
1406 *
1407 * We do it only when LastDir is not set (first pass there)
1408 * or when CurrentFolder and LastDirBackup are not the same.
1409 * This code is executed only when we list files, not when
1410 * we press up/down keys to navigate in a displayed list.
1411 *
1412 * We only do this when CurrentFolder has been set (ie, not
1413 * when listing folders on startup with "neomutt -y").
1414 *
1415 * This tracker is only used when browser_track is true,
1416 * meaning only with sort methods SUBJECT/DESC for now. */
1417 if (CurrentFolder)
1418 {
1419 if (buf_is_empty(&LastDir))
1420 {
1421 /* If browsing in "local"-mode, than we chose to define LastDir to
1422 * MailDir */
1424 {
1425 case MUTT_IMAP:
1426 case MUTT_MAILDIR:
1427 case MUTT_MBOX:
1428 case MUTT_MH:
1429 case MUTT_MMDF:
1430 {
1431 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
1432 const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
1433 if (c_folder)
1434 buf_strcpy(&LastDir, c_folder);
1435 else if (c_spool_file)
1436 mutt_browser_select_dir(c_spool_file);
1437 break;
1438 }
1439 default:
1441 break;
1442 }
1443 }
1445 {
1447 }
1448 }
1449
1450 /* When browser tracking feature is disabled, clear LastDirBackup */
1451 if (!browser_track)
1453 }
1454 else
1455 {
1457 }
1458
1459 if (!priv->state.is_mailbox_list &&
1461 {
1462 init_state(&priv->state, NULL);
1463 priv->state.imap_browse = true;
1465 browser_sort(&priv->state);
1466 }
1467 else
1468 {
1469 size_t i = buf_len(&LastDir);
1470 while ((i > 0) && (buf_string(&LastDir)[--i] == '/'))
1471 LastDir.data[i] = '\0';
1473 if (buf_is_empty(&LastDir))
1475 }
1476 }
1477
1478 buf_reset(file);
1479
1480 const struct Mapping *help_data = NULL;
1481
1482 if (OptNews)
1483 help_data = FolderNewsHelp;
1484 else
1485 help_data = FolderHelp;
1486
1487 dlg = simple_dialog_new(MENU_FOLDER, WT_DLG_BROWSER, help_data);
1488
1489 priv->menu = dlg->wdata;
1490 dlg->wdata = priv;
1493 if (priv->multiple)
1494 priv->menu->tag = file_tag;
1495
1496 priv->sbar = window_find_child(dlg, WT_STATUS_BAR);
1498
1499 struct MuttWindow *win_menu = priv->menu->win;
1500
1501 // NT_COLOR is handled by the SimpleDialog
1505
1506 struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
1507
1508 if (priv->state.is_mailbox_list)
1509 {
1510 examine_mailboxes(m, NULL, &priv->state);
1511 }
1512 else if (!priv->state.imap_browse)
1513 {
1514 // examine_directory() calls browser_add_folder() which needs the menu
1515 if (examine_directory(m, priv->menu, &priv->state, buf_string(&LastDir),
1516 buf_string(priv->prefix)) == -1)
1517 {
1518 goto bail;
1519 }
1520 }
1521
1522 init_menu(&priv->state, priv->menu, m, priv->sbar);
1523 // only now do we have a valid priv->state to attach
1524 priv->menu->mdata = &priv->state;
1525
1526 // ---------------------------------------------------------------------------
1527 // Event Loop
1528 int op = OP_NULL;
1529 do
1530 {
1531 menu_tagging_dispatcher(priv->menu->win, op);
1532 window_redraw(NULL);
1533
1535 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
1536 if (op < 0)
1537 continue;
1538 if (op == OP_NULL)
1539 {
1541 continue;
1542 }
1544
1545 int rc = browser_function_dispatcher(priv->win_browser, op);
1546
1547 if (rc == FR_UNKNOWN)
1548 rc = menu_function_dispatcher(priv->menu->win, op);
1549 if (rc == FR_UNKNOWN)
1550 rc = global_function_dispatcher(NULL, op);
1551 } while (!priv->done);
1552 // ---------------------------------------------------------------------------
1553
1554bail:
1555 window_set_focus(old_focus);
1556 simple_dialog_free(&dlg);
1558}
int browser_function_dispatcher(struct MuttWindow *win, int op)
Perform a Browser function.
Definition: functions.c:1140
#define MUTT_SEL_MAILBOX
Select a mailbox.
Definition: lib.h:58
void browser_sort(struct BrowserState *state)
Sort the entries in the browser.
Definition: sort.c:186
#define MUTT_SEL_FOLDER
Select a local directory.
Definition: lib.h:60
#define MUTT_SEL_MULTI
Multi-selection is enabled.
Definition: lib.h:59
struct BrowserPrivateData * browser_private_data_new(void)
Create new Browser Data.
Definition: private_data.c:55
size_t buf_addstr_n(struct Buffer *buf, const char *s, size_t len)
Add a string to a Buffer, expanding it if necessary.
Definition: buffer.c:96
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:491
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:182
size_t buf_strcpy_n(struct Buffer *buf, const char *s, size_t len)
Copy a string into a Buffer.
Definition: buffer.c:416
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition: buffer.c:601
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:266
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_MH
'MH' Mailbox type
Definition: mailbox.h:47
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
@ MUTT_MAILDIR
'Maildir' Mailbox type
Definition: mailbox.h:48
void init_state(struct BrowserState *state, struct Menu *menu)
Initialise a browser state.
Definition: dlg_browser.c:688
int examine_directory(struct Mailbox *m, struct Menu *menu, struct BrowserState *state, const char *dirname, const char *prefix)
Get list of all files/newsgroups with mask.
Definition: dlg_browser.c:711
void init_menu(struct BrowserState *state, struct Menu *menu, struct Mailbox *m, struct MuttWindow *sbar)
Set up a new menu.
Definition: dlg_browser.c:1028
static void init_lastdir(void)
Initialise the browser directories.
Definition: dlg_browser.c:148
static const struct Mapping FolderNewsHelp[]
Help Bar for the NNTP Mailbox browser dialog.
Definition: dlg_browser.c:125
struct Buffer LastDir
Browser: previous selected directory.
Definition: dlg_browser.c:139
void mutt_browser_select_dir(const char *f)
Remember the last directory selected.
Definition: dlg_browser.c:1272
struct Buffer LastDirBackup
Browser: backup copy of the current directory.
Definition: dlg_browser.c:141
static const struct Mapping FolderHelp[]
Help Bar for the File/Dir/Mailbox browser dialog.
Definition: dlg_browser.c:113
int examine_mailboxes(struct Mailbox *m, struct Menu *menu, struct BrowserState *state)
Get list of mailboxes/subscribed newsgroups.
Definition: dlg_browser.c:838
bool OptNews
(pseudo) used to change reader mode
Definition: globals.c:68
char * CurrentFolder
Currently selected mailbox.
Definition: globals.c:43
static int folder_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format a Folder for the Menu - Implements Menu::make_entry() -.
Definition: dlg_browser.c:959
static int select_file_search(struct Menu *menu, regex_t *rx, int line)
Menu search callback for matching files - Implements Menu::search() -.
Definition: dlg_browser.c:943
static int file_tag(struct Menu *menu, int sel, int act)
Tag an entry in the menu - Implements Menu::tag() -.
Definition: dlg_browser.c:1133
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
Definition: imap.c:2345
static int browser_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_browser.c:1153
static int browser_mailbox_observer(struct NotifyCallback *nc)
Notification that a Mailbox has changed - Implements observer_t -.
Definition: dlg_browser.c:1193
static int browser_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_browser.c:1238
void browser_private_data_free(struct BrowserPrivateData **ptr)
Free Private Browser Data - Implements MuttWindow::wdata_free() -.
Definition: private_data.c:37
int imap_browse(const char *path, struct BrowserState *state)
IMAP hook into the folder browser.
Definition: browse.c:197
const char * mutt_path_getcwd(struct Buffer *cwd)
Get the current working directory.
Definition: path.c:469
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
@ WT_DLG_BROWSER
Browser Dialog, dlg_browser()
Definition: mutt_window.h:80
void buf_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:315
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1321
struct NntpAccountData * CurrentNewsSrv
Current NNTP news server.
Definition: nntp.c:77
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:49
#define SORT_MASK
Mask for the sort id.
Definition: sort2.h:70
SortType
Methods for sorting.
Definition: sort2.h:34
@ SORT_SUBJECT
Sort by the email's subject.
Definition: sort2.h:38
@ SORT_ORDER
Sort by the order the messages appear in the mailbox.
Definition: sort2.h:40
@ SORT_DESC
Sort by the folder's description.
Definition: sort2.h:55
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
Private state data for the Browser.
Definition: private_data.h:34
char *** files
Array of selected files.
Definition: private_data.h:38
struct Menu * menu
Menu.
Definition: private_data.h:43
struct Buffer * prefix
Folder prefix string.
Definition: private_data.h:49
bool kill_prefix
Prefix is in use.
Definition: private_data.h:44
bool done
Should we close the Dialog?
Definition: private_data.h:53
bool folder
Select folders.
Definition: private_data.h:46
int last_selected_mailbox
Index of last selected Mailbox.
Definition: private_data.h:50
int * numfiles
Number of selected files.
Definition: private_data.h:39
struct Mailbox * mailbox
Mailbox.
Definition: private_data.h:37
struct BrowserState state
State containing list of files/dir/mailboxes.
Definition: private_data.h:42
struct Buffer * file
Buffer for the result.
Definition: private_data.h:36
bool multiple
Allow multiple selections.
Definition: private_data.h:45
struct MuttWindow * win_browser
Browser Window.
Definition: private_data.h:52
struct MuttWindow * sbar
Status Bar.
Definition: private_data.h:51
char * folder
Folder name.
Definition: lib.h:147
bool is_mailbox_list
Viewing mailboxes.
Definition: lib.h:148
bool imap_browse
IMAP folder.
Definition: lib.h:146
char * data
Pointer to data.
Definition: buffer.h:37
void * mdata
Driver specific data.
Definition: mailbox.h:132
Mapping between user-readable string and a constant.
Definition: mapping.h:33
int(* search)(struct Menu *menu, regex_t *rx, int line)
Definition: lib.h:119
struct Notify * notify
Notifications handler.
Definition: neomutt.h:43
NNTP-specific Account data -.
Definition: adata.h:36
void ** groups_list
Definition: adata.h:60
NNTP-specific Mailbox data -.
Definition: mdata.h:34
struct NntpAccountData * adata
Definition: mdata.h:48
@ MENU_FOLDER
General file/mailbox browser.
Definition: type.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_compose()

int dlg_compose ( struct Email e,
struct Buffer fcc,
uint8_t  flags,
struct ConfigSubset sub 
)

Allow the user to edit the message envelope -.

Parameters
eEmail to fill
fccBuffer to save FCC
flagsFlags, e.g. MUTT_COMPOSE_NOFREEHEADER
subConfigSubset
Return values
1Message should be postponed
0Normal exit
-1Abort message

The Compose Dialog allows the user to edit the email envelope before sending.

Definition at line 305 of file dlg_compose.c.

306{
307 struct MuttWindow *dlg = compose_dlg_init(sub, e, fcc);
308 struct ComposeSharedData *shared = dlg->wdata;
309 shared->mailbox = get_current_mailbox();
310 shared->email = e;
311 shared->sub = sub;
312 shared->fcc = fcc;
313 shared->fcc_set = false;
314 shared->flags = flags;
315 shared->rc = -1;
316
320
321 if (OptNewsSend)
323 else
324 dlg->help_data = ComposeHelp;
325 dlg->help_menu = MENU_COMPOSE;
326
327 struct Menu *menu = shared->adata->menu;
328 update_menu(shared->adata->actx, menu, true);
330
331 struct MuttWindow *win_env = window_find_child(dlg, WT_CUSTOM);
332
333 dialog_push(dlg);
334 struct MuttWindow *old_focus = window_set_focus(menu->win);
335 // ---------------------------------------------------------------------------
336 // Event Loop
337 int rc = 0;
338 int op = OP_NULL;
339 do
340 {
341 OptNews = false; /* for any case */
342 menu_tagging_dispatcher(menu->win, op);
343 window_redraw(NULL);
344
346 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
347 if (op < 0)
348 continue;
349 if (op == OP_NULL)
350 {
352 continue;
353 }
355
356 rc = compose_function_dispatcher(dlg, op);
357 if (rc == FR_UNKNOWN)
358 rc = env_function_dispatcher(win_env, op);
359 if (rc == FR_UNKNOWN)
360 rc = menu_function_dispatcher(menu->win, op);
361 if (rc == FR_UNKNOWN)
362 rc = global_function_dispatcher(NULL, op);
363 } while (rc != FR_DONE);
364 // ---------------------------------------------------------------------------
365
366#ifdef USE_AUTOCRYPT
367 /* This is a fail-safe to make sure the bit isn't somehow turned
368 * on. The user could have disabled the option after setting SEC_AUTOCRYPT,
369 * or perhaps resuming or replying to an autocrypt message. */
370 const bool c_autocrypt = cs_subset_bool(sub, "autocrypt");
371 if (!c_autocrypt)
372 e->security &= ~SEC_AUTOCRYPT;
373#endif
374
375 if (shared->adata->actx->idxlen)
376 e->body = shared->adata->actx->idx[0]->body;
377 else
378 e->body = NULL;
379
380 rc = shared->rc;
381
382 window_set_focus(old_focus);
383 dialog_pop();
384 mutt_window_free(&dlg);
385
386 return rc;
387}
void dialog_push(struct MuttWindow *dlg)
Display a Window to the user.
Definition: dialog.c:109
void dialog_pop(void)
Hide a Window from the user.
Definition: dialog.c:142
void update_menu(struct AttachCtx *actx, struct Menu *menu, bool init)
Redraw the compose window.
Definition: dlg_compose.c:217
static const struct Mapping ComposeHelp[]
Help Bar for the Compose dialog.
Definition: dlg_compose.c:91
static const struct Mapping ComposeNewsHelp[]
Help Bar for the News Compose dialog.
Definition: dlg_compose.c:109
static struct MuttWindow * compose_dlg_init(struct ConfigSubset *sub, struct Email *e, struct Buffer *fcc)
Allocate the Windows for Compose.
Definition: dlg_compose.c:252
@ NT_EMAIL_CHANGE
Email has changed.
Definition: email.h:186
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: globals.c:69
int env_function_dispatcher(struct MuttWindow *win, int op)
Perform an Envelope function - Implements function_dispatcher_t -.
Definition: functions.c:527
int compose_function_dispatcher(struct MuttWindow *win, int op)
Perform a Compose function - Implements function_dispatcher_t -.
Definition: functions.c:2136
static int compose_email_observer(struct NotifyCallback *nc)
Notification that an Email has changed - Implements observer_t -.
Definition: dlg_compose.c:146
static int compose_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_compose.c:125
static int compose_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_compose.c:165
struct Mailbox * get_current_mailbox(void)
Get the current Mailbox.
Definition: index.c:715
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:173
void mutt_window_free(struct MuttWindow **ptr)
Free a Window and its children.
Definition: mutt_window.c:201
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:94
@ NT_EMAIL
Email has changed, NotifyEmail, EventEmail.
Definition: notify_type.h:44
@ NT_ALL
Register for all notifications.
Definition: notify_type.h:35
struct AttachPtr ** idx
Array of attachments.
Definition: attach.h:69
short idxlen
Number of attachmentes.
Definition: attach.h:70
struct Body * body
Attachment.
Definition: attach.h:38
struct Menu * menu
Menu displaying the attachments.
Definition: attach_data.h:35
struct AttachCtx * actx
Set of attachments.
Definition: attach_data.h:34
Shared Compose Data.
Definition: shared_data.h:35
struct ConfigSubset * sub
Config set to use.
Definition: shared_data.h:36
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:37
int flags
Flags, e.g. MUTT_COMPOSE_NOFREEHEADER.
Definition: shared_data.h:43
bool fcc_set
User has edited the Fcc: field.
Definition: shared_data.h:44
int rc
Return code to leave compose.
Definition: shared_data.h:45
struct ComposeAttachData * adata
Attachments.
Definition: shared_data.h:39
struct Email * email
Email being composed.
Definition: shared_data.h:38
struct Buffer * fcc
Buffer to save FCC.
Definition: shared_data.h:42
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
struct Notify * notify
Notifications: NotifyEmail, EventEmail.
Definition: email.h:73
const struct Mapping * help_data
Data for the Help Bar.
Definition: mutt_window.h:141
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:140
@ MENU_COMPOSE
Compose an email.
Definition: type.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_certificate()

int dlg_certificate ( const char *  title,
struct CertArray *  carr,
bool  allow_always,
bool  allow_skip 
)

Ask the user to validate the certificate -.

Parameters
titleMenu title
carrCertificate text to display
allow_alwaysIf true, allow the user to always accept the certificate
allow_skipIf true, allow the user to skip the verification
Return values
1Reject certificate (or menu aborted)
2Accept certificate once
3Accept certificate always/skip (see notes)
4Accept certificate skip

The Verify Certificate Dialog shows a list of signatures for a domain certificate. They can choose whether to accept or reject it.

The possible retvals will depend on the parameters. The options are given in the order: Reject, Once, Always, Skip. The retval represents the chosen option.

Definition at line 184 of file dlg_verifycert.c.

185{
187
188 struct CertMenuData mdata = { carr };
189
190 struct Menu *menu = dlg->wdata;
191 menu->mdata = &mdata;
192 menu->mdata_free = NULL; // Menu doesn't own the data
194 menu->max = ARRAY_SIZE(carr);
195
196 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
197 sbar_set_title(sbar, title);
198
199 if (allow_always)
200 {
201 if (allow_skip)
202 {
203 mdata.prompt = _("(r)eject, accept (o)nce, (a)ccept always, (s)kip");
204 /* L10N: The letters correspond to the choices in the string:
205 "(r)eject, accept (o)nce, (a)ccept always, (s)kip"
206 This is an interactive certificate confirmation prompt for an SSL connection. */
207 mdata.keys = _("roas");
208 }
209 else
210 {
211 mdata.prompt = _("(r)eject, accept (o)nce, (a)ccept always");
212 /* L10N: The letters correspond to the choices in the string:
213 "(r)eject, accept (o)nce, (a)ccept always"
214 This is an interactive certificate confirmation prompt for an SSL connection. */
215 mdata.keys = _("roa");
216 }
217 }
218 else
219 {
220 if (allow_skip)
221 {
222 mdata.prompt = _("(r)eject, accept (o)nce, (s)kip");
223 /* L10N: The letters correspond to the choices in the string:
224 "(r)eject, accept (o)nce, (s)kip"
225 This is an interactive certificate confirmation prompt for an SSL connection. */
226 mdata.keys = _("ros");
227 }
228 else
229 {
230 mdata.prompt = _("(r)eject, accept (o)nce");
231 /* L10N: The letters correspond to the choices in the string:
232 "(r)eject, accept (o)nce"
233 This is an interactive certificate confirmation prompt for an SSL connection. */
234 mdata.keys = _("ro");
235 }
236 }
238
239 struct MuttWindow *old_focus = window_set_focus(menu->win);
240 // ---------------------------------------------------------------------------
241 // Event Loop
242 int choice = 0;
243 int op = OP_NULL;
244 do
245 {
246 window_redraw(NULL);
248
249 // Try to catch dialog keys before ops
250 if (menu_dialog_dokey(menu, &op) != 0)
251 {
253 }
254
255 if (op == OP_TIMEOUT)
256 continue;
257
258 // Convert menubar movement to scrolling
260
261 if (op <= OP_MAX)
262 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
263 else
264 mutt_debug(LL_DEBUG1, "Got choice %d\n", op - OP_MAX);
265
266 switch (op)
267 {
268 case -1: // Abort: Ctrl-G
269 case OP_QUIT: // Q)uit
270 case OP_MAX + 1: // R)eject
271 choice = 1;
272 break;
273 case OP_MAX + 2: // O)nce
274 choice = 2;
275 break;
276 case OP_MAX + 3: // A)lways / S)kip
277 choice = 3;
278 break;
279 case OP_MAX + 4: // S)kip
280 choice = 4;
281 break;
282
283 case OP_JUMP:
284 case OP_JUMP_1:
285 case OP_JUMP_2:
286 case OP_JUMP_3:
287 case OP_JUMP_4:
288 case OP_JUMP_5:
289 case OP_JUMP_6:
290 case OP_JUMP_7:
291 case OP_JUMP_8:
292 case OP_JUMP_9:
293 mutt_error(_("Jumping is not implemented for dialogs"));
294 continue;
295
296 case OP_SEARCH:
297 case OP_SEARCH_NEXT:
298 case OP_SEARCH_OPPOSITE:
299 case OP_SEARCH_REVERSE:
300 mutt_error(_("Search is not implemented for this menu"));
301 continue;
302 }
303
304 (void) menu_function_dispatcher(menu->win, op);
305 } while (choice == 0);
306 // ---------------------------------------------------------------------------
307
308 window_set_focus(old_focus);
309 simple_dialog_free(&dlg);
310
311 return choice;
312}
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
@ MT_COLOR_PROMPT
Question/user input.
Definition: color.h:62
static int menu_dialog_dokey(struct Menu *menu, int *id)
Check if there are any menu key events to process.
static int menu_dialog_translate_op(int op)
Convert menubar movement to scrolling.
static const struct Mapping VerifyHelp[]
Help Bar for the Certificate Verification dialog.
#define mutt_error(...)
Definition: logging2.h:92
static int cert_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Create a Certificate for the Menu - Implements Menu::make_entry() -.
#define GETCH_IGNORE_MACRO
Don't use MacroEvents.
Definition: lib.h:52
void msgwin_set_text(struct MuttWindow *win, const char *text, enum ColorId color)
Set the text for the Message Window.
Definition: msgwin.c:484
@ WT_DLG_CERTIFICATE
Certificate Dialog, dlg_certificate()
Definition: mutt_window.h:81
#define OP_TIMEOUT
1 second with no events
Definition: opcodes.h:36
@ OP_MAX
Definition: opcodes.h:1000
Certificate data to use in the Menu.
Definition: ssl.h:42
struct CertArray * carr
Lines of the Certificate.
Definition: ssl.h:43
char * prompt
Prompt for user, similar to mw_multi_choice.
Definition: ssl.h:44
char * keys
Keys used in the prompt.
Definition: ssl.h:45
int max
Number of entries in the menu.
Definition: lib.h:81
@ MENU_DIALOG
Simple Dialog.
Definition: type.h:43
@ MENU_GENERIC
Generic selection list.
Definition: type.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_history()

void dlg_history ( char *  buf,
size_t  buflen,
char **  matches,
int  match_count 
)

Select an item from a history list -.

Parameters
[in]bufBuffer in which to save string
[in]buflenBuffer length
[out]matchesItems to choose from
[in]match_countNumber of items

The History Dialog lets the user select from the history of commands, functions or files.

Definition at line 139 of file dlg_history.c.

140{
142
143 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
144 char title[256] = { 0 };
145 snprintf(title, sizeof(title), _("History '%s'"), buf);
146 sbar_set_title(sbar, title);
147
148 struct Menu *menu = dlg->wdata;
150 menu->max = match_count;
151 menu->mdata = matches;
152 menu->mdata_free = NULL; // Menu doesn't own the data
153
154 struct HistoryData hd = { false, false, buf, buflen,
156 dlg->wdata = &hd;
157
158 struct MuttWindow *old_focus = window_set_focus(menu->win);
159 // ---------------------------------------------------------------------------
160 // Event Loop
161 int op = OP_NULL;
162 do
163 {
164 menu_tagging_dispatcher(menu->win, op);
165 window_redraw(NULL);
166
168 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
169 if (op < 0)
170 continue;
171 if (op == OP_NULL)
172 {
174 continue;
175 }
177
178 int rc = history_function_dispatcher(dlg, op);
179 if (rc == FR_UNKNOWN)
180 rc = menu_function_dispatcher(menu->win, op);
181 if (rc == FR_UNKNOWN)
182 rc = global_function_dispatcher(NULL, op);
183 } while (!hd.done);
184 // ---------------------------------------------------------------------------
185
186 window_set_focus(old_focus);
187 simple_dialog_free(&dlg);
188}
static const struct Mapping HistoryHelp[]
Help Bar for the History Selection dialog.
Definition: dlg_history.c:76
int history_function_dispatcher(struct MuttWindow *win, int op)
Perform a History function - Implements function_dispatcher_t -.
Definition: functions.c:75
static int history_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format a History Item for the Menu - Implements Menu::make_entry() -.
Definition: dlg_history.c:111
@ WT_DLG_HISTORY
History Dialog, dlg_history()
Definition: mutt_window.h:85
Data to pass to the History Functions.
Definition: functions.h:35
size_t buflen
Length of the results buffer.
Definition: functions.h:39
struct Menu * menu
History Menu.
Definition: functions.h:40
char ** matches
History entries.
Definition: functions.h:41
bool done
Should we close the Dialog?
Definition: functions.h:36
char * buf
Buffer for the results.
Definition: functions.h:38
int match_count
Number of history entries.
Definition: functions.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_index()

struct Mailbox * dlg_index ( struct MuttWindow dlg,
struct Mailbox m_init 
)

Display a list of emails -.

Parameters
dlgDialog containing Windows to draw on
m_initInitial mailbox
Return values
ptrMailbox open in the index

The Index Dialog is the heart of NeoMutt. From here, the user can read and reply to emails, organise them into folders, set labels, etc.

Definition at line 1070 of file dlg_index.c.

1071{
1072 /* Make sure use_threads/sort/sort_aux are coherent */
1074
1075 struct IndexSharedData *shared = dlg->wdata;
1077
1078 struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
1079
1080 struct IndexPrivateData *priv = panel_index->wdata;
1081 priv->win_index = window_find_child(panel_index, WT_MENU);
1082
1083 int op = OP_NULL;
1084
1085 if (shared->mailbox && (shared->mailbox->type == MUTT_NNTP))
1086 dlg->help_data = IndexNewsHelp;
1087 else
1088 dlg->help_data = IndexHelp;
1089 dlg->help_menu = MENU_INDEX;
1090
1091 priv->menu = priv->win_index->wdata;
1093 priv->menu->color = index_color;
1094 priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
1096
1097 struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
1098 mutt_window_reflow(NULL);
1099
1100 if (!shared->attach_msg)
1101 {
1102 /* force the mailbox check after we enter the folder */
1104 }
1105#ifdef USE_INOTIFY
1106 mutt_monitor_add(NULL);
1107#endif
1108
1109 const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
1110 if (mutt_using_threads() && c_collapse_all)
1111 {
1112 collapse_all(shared->mailbox_view, priv->menu, 0);
1114 }
1115
1116 int rc = 0;
1117 do
1118 {
1119 /* Clear the tag prefix unless we just started it.
1120 * Don't clear the prefix on a timeout, but do clear on an abort */
1121 if (priv->tag_prefix && (op != OP_TAG_PREFIX) &&
1122 (op != OP_TAG_PREFIX_COND) && (op != OP_TIMEOUT))
1123 {
1124 priv->tag_prefix = false;
1125 }
1126
1127 /* check if we need to resort the index because just about
1128 * any 'op' below could do mutt_enter_command(), either here or
1129 * from any new priv->menu launched, and change $sort/$sort_aux */
1130 if (OptNeedResort && shared->mailbox && (shared->mailbox->msg_count != 0) &&
1131 (menu_get_index(priv->menu) >= 0))
1132 {
1133 resort_index(shared->mailbox_view, priv->menu);
1134 }
1135
1136 priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
1137 priv->oldcount = shared->mailbox ? shared->mailbox->msg_count : 0;
1138
1139 if (shared->mailbox && shared->mailbox_view)
1140 {
1142
1143 shared->mailbox_view->menu = priv->menu;
1144 /* check for new mail in the mailbox. If nonzero, then something has
1145 * changed about the file (either we got new mail or the file was
1146 * modified underneath us.) */
1147 enum MxStatus check = mx_mbox_check(shared->mailbox);
1148
1149 if (check == MX_STATUS_ERROR)
1150 {
1151 if (buf_is_empty(&shared->mailbox->pathbuf))
1152 {
1153 /* fatal error occurred */
1154 mview_free(&shared->mailbox_view);
1156 }
1157
1159 }
1160 else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
1161 (check == MX_STATUS_FLAGS))
1162 {
1163 /* notify the user of new mail */
1164 if (check == MX_STATUS_REOPENED)
1165 {
1166 mutt_error(_("Mailbox was externally modified. Flags may be wrong."));
1167 }
1168 else if (check == MX_STATUS_NEW_MAIL)
1169 {
1170 for (size_t i = 0; i < shared->mailbox->msg_count; i++)
1171 {
1172 const struct Email *e = shared->mailbox->emails[i];
1173 if (e && !e->read && !e->old)
1174 {
1175 mutt_message(_("New mail in this mailbox"));
1176 const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
1177 if (c_beep_new)
1178 mutt_beep(true);
1179 const struct Expando *c_new_mail_command =
1180 cs_subset_expando(shared->sub, "new_mail_command");
1181 if (c_new_mail_command)
1182 {
1183 struct Buffer *cmd = buf_pool_get();
1184 menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
1185 if (mutt_system(buf_string(cmd)) != 0)
1186 mutt_error(_("Error running \"%s\""), buf_string(cmd));
1187 buf_pool_release(&cmd);
1188 }
1189 break;
1190 }
1191 }
1192 }
1193 else if (check == MX_STATUS_FLAGS)
1194 {
1195 mutt_message(_("Mailbox was externally modified"));
1196 }
1197
1198 /* avoid the message being overwritten by mailbox */
1199 priv->do_mailbox_notify = false;
1200
1201 bool verbose = shared->mailbox->verbose;
1202 shared->mailbox->verbose = false;
1203 update_index(priv->menu, shared->mailbox_view, check, priv->oldcount, shared);
1204 shared->mailbox->verbose = verbose;
1205 priv->menu->max = shared->mailbox->vcount;
1208 }
1209
1211 menu_get_index(priv->menu)));
1212 }
1213
1214 if (!shared->attach_msg)
1215 {
1216 /* check for new mail in the incoming folders */
1218 if (priv->do_mailbox_notify)
1219 {
1220 if (mutt_mailbox_notify(shared->mailbox))
1221 {
1222 const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
1223 if (c_beep_new)
1224 mutt_beep(true);
1225 const struct Expando *c_new_mail_command = cs_subset_expando(shared->sub, "new_mail_command");
1226 if (c_new_mail_command)
1227 {
1228 struct Buffer *cmd = buf_pool_get();
1229 menu_status_line(cmd, shared, priv->menu, -1, c_new_mail_command);
1230 if (mutt_system(buf_string(cmd)) != 0)
1231 mutt_error(_("Error running \"%s\""), buf_string(cmd));
1232 buf_pool_release(&cmd);
1233 }
1234 }
1235 }
1236 else
1237 {
1238 priv->do_mailbox_notify = true;
1239 }
1240 }
1241
1242 window_redraw(NULL);
1243
1244 /* give visual indication that the next command is a tag- command */
1245 if (priv->tag_prefix)
1246 {
1247 msgwin_set_text(NULL, "tag-", MT_COLOR_NORMAL);
1248 }
1249
1250 const bool c_arrow_cursor = cs_subset_bool(shared->sub, "arrow_cursor");
1251 const bool c_braille_friendly = cs_subset_bool(shared->sub, "braille_friendly");
1252 const int index = menu_get_index(priv->menu);
1253 if (c_arrow_cursor)
1254 {
1255 const char *const c_arrow_string = cs_subset_string(shared->sub, "arrow_string");
1256 const int arrow_width = mutt_strwidth(c_arrow_string);
1257 mutt_window_move(priv->menu->win, arrow_width, index - priv->menu->top);
1258 }
1259 else if (c_braille_friendly)
1260 {
1261 mutt_window_move(priv->menu->win, 0, index - priv->menu->top);
1262 }
1263 else
1264 {
1265 mutt_window_move(priv->menu->win, priv->menu->win->state.cols - 1,
1266 index - priv->menu->top);
1267 }
1268 mutt_refresh();
1269
1270 window_redraw(NULL);
1272
1273 if (op == OP_REPAINT)
1274 {
1275 /* force a real complete redraw. clrtobot() doesn't seem to be able
1276 * to handle every case without this. */
1277 msgwin_clear_text(NULL);
1278 mutt_refresh();
1279 continue;
1280 }
1281
1282 /* either user abort or timeout */
1283 if (op < OP_NULL)
1284 {
1285 if (priv->tag_prefix)
1286 msgwin_clear_text(NULL);
1287 continue;
1288 }
1289
1290 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
1291
1292 /* special handling for the priv->tag-prefix function */
1293 const bool c_auto_tag = cs_subset_bool(shared->sub, "auto_tag");
1294 if ((op == OP_TAG_PREFIX) || (op == OP_TAG_PREFIX_COND))
1295 {
1296 /* A second priv->tag-prefix command aborts */
1297 if (priv->tag_prefix)
1298 {
1299 priv->tag_prefix = false;
1300 msgwin_clear_text(NULL);
1301 continue;
1302 }
1303
1304 if (!shared->mailbox)
1305 {
1306 mutt_error(_("No mailbox is open"));
1307 continue;
1308 }
1309
1310 if (shared->mailbox->msg_tagged == 0)
1311 {
1312 if (op == OP_TAG_PREFIX)
1313 {
1314 mutt_error(_("No tagged messages"));
1315 }
1316 else if (op == OP_TAG_PREFIX_COND)
1317 {
1319 mutt_message(_("Nothing to do"));
1320 }
1321 continue;
1322 }
1323
1324 /* get the real command */
1325 priv->tag_prefix = true;
1326 continue;
1327 }
1328 else if (c_auto_tag && shared->mailbox && (shared->mailbox->msg_tagged != 0))
1329 {
1330 priv->tag_prefix = true;
1331 }
1332
1334
1335 OptNews = false; /* for any case */
1336
1337#ifdef USE_NOTMUCH
1338 nm_db_debug_check(shared->mailbox);
1339#endif
1340
1341 rc = index_function_dispatcher(priv->win_index, op);
1342
1343 if (rc == FR_UNKNOWN)
1344 rc = menu_function_dispatcher(priv->win_index, op);
1345
1346 if (rc == FR_UNKNOWN)
1347 {
1348 struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
1349 rc = sb_function_dispatcher(win_sidebar, op);
1350 }
1351 if (rc == FR_UNKNOWN)
1352 rc = global_function_dispatcher(NULL, op);
1353
1354 if (rc == FR_UNKNOWN)
1356
1357#ifdef USE_NOTMUCH
1358 nm_db_debug_check(shared->mailbox);
1359#endif
1360 } while (rc != FR_DONE);
1361
1362 mview_free(&shared->mailbox_view);
1363 window_set_focus(old_focus);
1364
1365 return shared->mailbox;
1366}
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:59
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:778
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:357
void mailbox_gc_run(void)
Run the garbage-collection.
Definition: mailbox.c:312
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
void mutt_refresh(void)
Force a refresh of the screen.
Definition: curs_lib.c:78
void mutt_beep(bool force)
Irritate the user.
Definition: curs_lib.c:68
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:443
const struct Mapping IndexNewsHelp[]
Help Bar for the News Index dialog.
Definition: dlg_index.c:118
void update_index(struct Menu *menu, struct MailboxView *mv, enum MxStatus check, int oldcount, const struct IndexSharedData *shared)
Update the index.
Definition: dlg_index.c:543
int find_first_message(struct MailboxView *mv)
Get index of first new message.
Definition: dlg_index.c:310
static const struct Mapping IndexHelp[]
Help Bar for the Index dialog.
Definition: dlg_index.c:103
void resort_index(struct MailboxView *mv, struct Menu *menu)
Resort the index.
Definition: dlg_index.c:370
void collapse_all(struct MailboxView *mv, struct Menu *menu, int toggle)
Collapse/uncollapse all threads.
Definition: dlg_index.c:166
void mutt_flush_macro_to_endcond(void)
Drop a macro from the input buffer.
Definition: get.c:166
bool OptNeedResort
(pseudo) used to force a re-sort
Definition: globals.c:67
int sb_function_dispatcher(struct MuttWindow *win, int op)
Perform a Sidebar function - Implements function_dispatcher_t -.
Definition: functions.c:375
int index_function_dispatcher(struct MuttWindow *win, int op)
Perform an Index function - Implements function_dispatcher_t -.
Definition: functions.c:3262
#define mutt_message(...)
Definition: logging2.h:91
const struct AttrColor * index_color(struct Menu *menu, int line)
Calculate the colour for a line of the index - Implements Menu::color() -.
Definition: dlg_index.c:897
int index_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an Email for the Menu - Implements Menu::make_entry() -.
Definition: dlg_index.c:797
void index_shared_data_set_email(struct IndexSharedData *shared, struct Email *e)
Set the current Email for the Index and friends.
Definition: shared_data.c:235
void index_shared_data_set_mview(struct IndexSharedData *shared, struct MailboxView *mv)
Set the MailboxView for the Index and friends.
Definition: shared_data.c:160
void index_adjust_sort_threads(const struct ConfigSubset *sub)
Adjust use_threads/sort/sort_aux.
Definition: index.c:184
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:59
void menu_queue_redraw(struct Menu *menu, MenuRedrawFlags redraw)
Queue a request for a redraw.
Definition: menu.c:184
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:160
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:174
int mutt_monitor_add(struct Mailbox *m)
Add a watch for a mailbox.
Definition: monitor.c:484
void msgwin_clear_text(struct MuttWindow *win)
Clear the text in the Message Window.
Definition: msgwin.c:519
int mutt_mailbox_check(struct Mailbox *m_cur, CheckStatsFlags flags)
Check all all Mailboxes for new mail.
Definition: mutt_mailbox.c:169
bool mutt_mailbox_notify(struct Mailbox *m_cur)
Notify the user if there's new mail.
Definition: mutt_mailbox.c:235
#define mutt_using_threads()
Definition: mutt_thread.h:114
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:343
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:296
@ WT_INDEX
A panel containing the Index Window.
Definition: mutt_window.h:96
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:100
struct Email * mutt_get_virt_email(struct Mailbox *m, int vnum)
Get a virtual Email.
Definition: mview.c:418
void mview_free(struct MailboxView **ptr)
Free a MailboxView.
Definition: mview.c:50
struct MailboxView * mview_new(struct Mailbox *m, struct Notify *parent)
Create a new MailboxView.
Definition: mview.c:91
enum MxStatus mx_mbox_check(struct Mailbox *m)
Check for new mail - Wrapper for MxOps::mbox_check()
Definition: mx.c:1105
#define MUTT_MAILBOX_CHECK_NO_FLAGS
No flags are set.
Definition: mxapi.h:53
#define MUTT_MAILBOX_CHECK_POSTPONED
Make sure the number of postponed messages is updated.
Definition: mxapi.h:54
MxStatus
Return values from mbox_check(), mbox_check_stats(), mbox_sync(), and mbox_close()
Definition: mxapi.h:63
@ MX_STATUS_ERROR
An error occurred.
Definition: mxapi.h:64
@ MX_STATUS_FLAGS
Nondestructive flags change (IMAP)
Definition: mxapi.h:69
@ MX_STATUS_REOPENED
Mailbox was reopened.
Definition: mxapi.h:68
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
Definition: mxapi.h:66
void nm_db_debug_check(struct Mailbox *m)
Check if the database is open.
Definition: db.c:397
#define OP_REPAINT
Repaint is needed.
Definition: opcodes.h:34
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:52
void menu_status_line(struct Buffer *buf, struct IndexSharedData *shared, struct Menu *menu, int max_cols, const struct Expando *exp)
Create the status line.
Definition: status.c:496
String manipulation buffer.
Definition: buffer.h:36
The envelope/body of an email.
Definition: email.h:39
bool read
Email is read.
Definition: email.h:50
bool old
Email is seen, but unread.
Definition: email.h:49
Parsed Expando trees.
Definition: expando.h:41
Private state data for the Index.
Definition: private_data.h:35
struct MuttWindow * win_index
Window for the Index.
Definition: private_data.h:42
struct IndexSharedData * shared
Shared Index data.
Definition: private_data.h:40
bool tag_prefix
tag-prefix has been pressed
Definition: private_data.h:36
bool do_mailbox_notify
Do we need to notify the user of new mail?
Definition: private_data.h:38
struct Menu * menu
Menu controlling the index.
Definition: private_data.h:41
int oldcount
Old count of mails in the mailbox.
Definition: private_data.h:37
Data shared between Index, Pager and Sidebar.
Definition: shared_data.h:37
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
bool attach_msg
Are we in "attach message" mode?
Definition: shared_data.h:46
struct ConfigSubset * sub
Config set to use.
Definition: shared_data.h:38
struct MailboxView * mailbox_view
Current Mailbox view.
Definition: shared_data.h:40
struct SearchState * search_state
State of the current search.
Definition: shared_data.h:45
struct Menu * menu
Needed for pattern compilation.
Definition: mview.h:47
int vcount
The number of virtual messages.
Definition: mailbox.h:99
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
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:94
bool verbose
Display status messages?
Definition: mailbox.h:117
const struct AttrColor *(* color)(struct Menu *menu, int line)
Definition: lib.h:143
int top
Entry that is the top of the current page.
Definition: lib.h:90
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:126
struct PatternList * pattern
compiled search pattern
Definition: search_state.h:37
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
@ MENU_INDEX
Index panel (list of emails)
Definition: type.h:51
+ Here is the caller graph for this function:

◆ dlg_gpgme()

struct CryptKeyInfo * dlg_gpgme ( struct CryptKeyInfo keys,
struct Address p,
const char *  s,
unsigned int  app,
bool *  forced_valid 
)

Get the user to select a key -.

Parameters
[in]keysList of keys to select from
[in]pAddress to match
[in]sReal name to display
[in]appFlags, e.g. APPLICATION_PGP
[out]forced_validSet to true if user overrode key's validity
Return values
ptrKey selected by user

The Select GPGME Key Dialog lets the user select a PGP Key to use.

Definition at line 636 of file dlg_gpgme.c.

638{
639 int keymax;
640 int i;
641 sort_t f = NULL;
642 enum MenuType menu_to_use = MENU_GENERIC;
643 bool unusable = false;
644
645 /* build the key table */
646 keymax = 0;
647 i = 0;
648 struct CryptKeyInfo **key_table = NULL;
649 const bool c_pgp_show_unusable = cs_subset_bool(NeoMutt->sub, "pgp_show_unusable");
650 for (struct CryptKeyInfo *k = keys; k; k = k->next)
651 {
652 if (!c_pgp_show_unusable && (k->flags & KEYFLAG_CANTUSE))
653 {
654 unusable = true;
655 continue;
656 }
657
658 if (i == keymax)
659 {
660 keymax += 20;
661 mutt_mem_realloc(&key_table, sizeof(struct CryptKeyInfo *) * keymax);
662 }
663
664 key_table[i++] = k;
665 }
666
667 if (!i && unusable)
668 {
669 mutt_error(_("All matching keys are marked expired/revoked"));
670 return NULL;
671 }
672
673 const short c_pgp_sort_keys = cs_subset_sort(NeoMutt->sub, "pgp_sort_keys");
674 switch (c_pgp_sort_keys & SORT_MASK)
675 {
676 case SORT_ADDRESS:
678 break;
679 case SORT_DATE:
680 f = crypt_sort_date;
681 break;
682 case SORT_KEYID:
684 break;
685 case SORT_TRUST:
686 default:
688 break;
689 }
690
691 if (key_table)
692 {
693 bool sort_reverse = c_pgp_sort_keys & SORT_REVERSE;
694 mutt_qsort_r(key_table, i, sizeof(struct CryptKeyInfo *), f, &sort_reverse);
695 }
696
697 if (app & APPLICATION_PGP)
698 menu_to_use = MENU_KEY_SELECT_PGP;
699 else if (app & APPLICATION_SMIME)
700 menu_to_use = MENU_KEY_SELECT_SMIME;
701
702 struct MuttWindow *dlg = simple_dialog_new(menu_to_use, WT_DLG_GPGME, GpgmeHelp);
703
704 struct Menu *menu = dlg->wdata;
705 menu->max = i;
707 menu->mdata = key_table;
709
710 struct GpgmeData gd = { false, menu, key_table, NULL, forced_valid };
711 dlg->wdata = &gd;
712
713 // NT_COLOR is handled by the SimpleDialog
716
717 const char *ts = NULL;
718
719 if ((app & APPLICATION_PGP) && (app & APPLICATION_SMIME))
720 ts = _("PGP and S/MIME keys matching");
721 else if ((app & APPLICATION_PGP))
722 ts = _("PGP keys matching");
723 else if ((app & APPLICATION_SMIME))
724 ts = _("S/MIME keys matching");
725 else
726 ts = _("keys matching");
727
728 char buf[1024] = { 0 };
729 if (p)
730 {
731 /* L10N: 1$s is one of the previous four entries.
732 %2$s is an address.
733 e.g. "S/MIME keys matching <john.doe@example.com>" */
734 snprintf(buf, sizeof(buf), _("%s <%s>"), ts, buf_string(p->mailbox));
735 }
736 else
737 {
738 /* L10N: e.g. 'S/MIME keys matching "John Doe".' */
739 snprintf(buf, sizeof(buf), _("%s \"%s\""), ts, s);
740 }
741
742 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
743 sbar_set_title(sbar, buf);
744
746
747 struct MuttWindow *old_focus = window_set_focus(menu->win);
748 // ---------------------------------------------------------------------------
749 // Event Loop
750 int op = OP_NULL;
751 do
752 {
753 menu_tagging_dispatcher(menu->win, op);
754 window_redraw(NULL);
755
756 op = km_dokey(menu_to_use, GETCH_NO_FLAGS);
757 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
758 if (op < 0)
759 continue;
760 if (op == OP_NULL)
761 {
762 km_error_key(menu_to_use);
763 continue;
764 }
766
767 int rc = gpgme_function_dispatcher(dlg, op);
768
769 if (rc == FR_UNKNOWN)
770 rc = menu_function_dispatcher(menu->win, op);
771 if (rc == FR_UNKNOWN)
772 rc = global_function_dispatcher(NULL, op);
773 } while (!gd.done);
774 // ---------------------------------------------------------------------------
775
776 window_set_focus(old_focus);
777 simple_dialog_free(&dlg);
778 return gd.key;
779}
static const struct Mapping GpgmeHelp[]
Help Bar for the GPGME key selection dialog.
Definition: dlg_gpgme.c:96
int gpgme_function_dispatcher(struct MuttWindow *win, int op)
Perform a Gpgme function - Implements function_dispatcher_t -.
static int crypt_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format a PGP Key for the Menu - Implements Menu::make_entry() -.
Definition: dlg_gpgme.c:540
static void gpgme_key_table_free(struct Menu *menu, void **ptr)
Free the key table - Implements Menu::mdata_free() -.
Definition: dlg_gpgme.c:565
static int gpgme_key_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_gpgme.c:573
static int gpgme_key_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_gpgme.c:602
static int crypt_sort_trust(const void *a, const void *b, void *sdata)
Compare two keys by their trust levels - Implements sort_t -.
Definition: dlg_gpgme.c:183
static int crypt_sort_address(const void *a, const void *b, void *sdata)
Compare two keys by their addresses - Implements sort_t -.
Definition: dlg_gpgme.c:109
static int crypt_sort_date(const void *a, const void *b, void *sdata)
Compare two keys by their dates - Implements sort_t -.
Definition: dlg_gpgme.c:147
static int crypt_sort_keyid(const void *a, const void *b, void *sdata)
Compare two keys by their IDs - Implements sort_t -.
Definition: dlg_gpgme.c:128
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
@ WT_DLG_GPGME
GPGME Dialog, dlg_gpgme()
Definition: mutt_window.h:83
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define KEYFLAG_CANTUSE
Definition: lib.h:139
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
void mutt_qsort_r(void *base, size_t nmemb, size_t size, sort_t compar, void *sdata)
Sort an array, where the comparator has access to opaque data rather than requiring global variables.
Definition: qsort_r.c:67
int(* sort_t)(const void *a, const void *b, void *sdata)
Definition: qsort_r.h:41
@ SORT_TRUST
Sort by encryption key's trust level.
Definition: sort2.h:48
@ SORT_KEYID
Sort by the encryption key's ID.
Definition: sort2.h:47
@ SORT_DATE
Sort by the date the email was sent.
Definition: sort2.h:35
@ SORT_ADDRESS
Sort by email address.
Definition: sort2.h:46
#define SORT_REVERSE
Reverse the order of the sort.
Definition: sort2.h:71
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
A stored PGP key.
Definition: crypt_gpgme.h:44
struct CryptKeyInfo * next
Linked list.
Definition: crypt_gpgme.h:45
Data to pass to the Gpgme Functions.
bool * forced_valid
User insists on out-of-date key.
struct CryptKeyInfo * key
Selected Key.
struct CryptKeyInfo ** key_table
Array of Keys.
bool done
Should we close the Dialog?
struct Menu * menu
Gpgme Menu.
MenuType
Types of GUI selections.
Definition: type.h:36
@ MENU_KEY_SELECT_PGP
Select a PGP key.
Definition: type.h:48
@ MENU_KEY_SELECT_SMIME
Select a SMIME key.
Definition: type.h:49
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_pgp()

struct PgpKeyInfo * dlg_pgp ( struct PgpKeyInfo keys,
struct Address p,
const char *  s 
)

Let the user select a key to use -.

Parameters
keysList of PGP keys
pAddress to match
sString to match
Return values
ptrSelected PGP key

The Select PGP Key Dialog lets the user select an PGP Key to use.

Definition at line 628 of file dlg_pgp.c.

629{
630 struct PgpUid **key_table = NULL;
631 struct Menu *menu = NULL;
632 char buf[1024] = { 0 };
633 struct PgpUid *a = NULL;
634 bool unusable = false;
635 int keymax = 0;
636
637 const bool c_pgp_show_unusable = cs_subset_bool(NeoMutt->sub, "pgp_show_unusable");
638 int i = 0;
639 for (struct PgpKeyInfo *kp = keys; kp; kp = kp->next)
640 {
641 if (!c_pgp_show_unusable && (kp->flags & KEYFLAG_CANTUSE))
642 {
643 unusable = true;
644 continue;
645 }
646
647 for (a = kp->address; a; a = a->next)
648 {
649 if (!c_pgp_show_unusable && (a->flags & KEYFLAG_CANTUSE))
650 {
651 unusable = true;
652 continue;
653 }
654
655 if (i == keymax)
656 {
657 keymax += 5;
658 mutt_mem_realloc(&key_table, sizeof(struct PgpUid *) * keymax);
659 }
660
661 key_table[i++] = a;
662 }
663 }
664
665 if ((i == 0) && unusable)
666 {
667 mutt_error(_("All matching keys are expired, revoked, or disabled"));
668 return NULL;
669 }
670
671 sort_t f = NULL;
672 short c_pgp_sort_keys = cs_subset_sort(NeoMutt->sub, "pgp_sort_keys");
673 switch (c_pgp_sort_keys & SORT_MASK)
674 {
675 case SORT_ADDRESS:
677 break;
678 case SORT_DATE:
679 f = pgp_sort_date;
680 break;
681 case SORT_KEYID:
682 f = pgp_sort_keyid;
683 break;
684 case SORT_TRUST:
685 default:
686 f = pgp_sort_trust;
687 break;
688 }
689
690 if (key_table)
691 {
692 bool sort_reverse = c_pgp_sort_keys & SORT_REVERSE;
693 mutt_qsort_r(key_table, i, sizeof(struct PgpUid *), f, &sort_reverse);
694 }
695
697
698 menu = dlg->wdata;
699 menu->max = i;
701 menu->mdata = key_table;
703
704 struct PgpData pd = { false, menu, key_table, NULL };
705 dlg->wdata = &pd;
706
707 // NT_COLOR is handled by the SimpleDialog
710
711 if (p)
712 snprintf(buf, sizeof(buf), _("PGP keys matching <%s>"), buf_string(p->mailbox));
713 else
714 snprintf(buf, sizeof(buf), _("PGP keys matching \"%s\""), s);
715
716 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
717 sbar_set_title(sbar, buf);
718
720
721 struct MuttWindow *old_focus = window_set_focus(menu->win);
722 // ---------------------------------------------------------------------------
723 // Event Loop
724 int op = OP_NULL;
725 do
726 {
727 menu_tagging_dispatcher(menu->win, op);
728 window_redraw(NULL);
729
731 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
732 if (op < 0)
733 continue;
734 if (op == OP_NULL)
735 {
737 continue;
738 }
740
741 int rc = pgp_function_dispatcher(dlg, op);
742
743 if (rc == FR_UNKNOWN)
744 rc = menu_function_dispatcher(menu->win, op);
745 if (rc == FR_UNKNOWN)
746 rc = global_function_dispatcher(NULL, op);
747 } while (!pd.done);
748 // ---------------------------------------------------------------------------
749
750 window_set_focus(old_focus);
751 simple_dialog_free(&dlg);
752 return pd.key;
753}
static const struct Mapping PgpHelp[]
Help Bar for the PGP key selection dialog.
Definition: dlg_pgp.c:94
int pgp_function_dispatcher(struct MuttWindow *win, int op)
Perform a Pgp function - Implements function_dispatcher_t -.
static int pgp_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format a PGP Key for the Menu - Implements Menu::make_entry() -.
Definition: dlg_pgp.c:534
static void pgp_key_table_free(struct Menu *menu, void **ptr)
Free the key table - Implements Menu::mdata_free() -.
Definition: dlg_pgp.c:559
static int pgp_key_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_pgp.c:596
static int pgp_key_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_pgp.c:567
static int pgp_sort_trust(const void *a, const void *b, void *sdata)
Compare two keys by their trust levels - Implements sort_t -.
Definition: dlg_pgp.c:167
static int pgp_sort_keyid(const void *a, const void *b, void *sdata)
Compare two keys by their IDs - Implements sort_t -.
Definition: dlg_pgp.c:148
static int pgp_sort_date(const void *a, const void *b, void *sdata)
Compare two keys by their dates - Implements sort_t -.
Definition: dlg_pgp.c:129
static int pgp_sort_address(const void *a, const void *b, void *sdata)
Compare two keys by their addresses - Implements sort_t -.
Definition: dlg_pgp.c:110
@ WT_DLG_PGP
Pgp Dialog, dlg_pgp()
Definition: mutt_window.h:88
Data to pass to the Pgp Functions.
Definition: pgp_functions.h:34
struct PgpUid ** key_table
Array of Keys.
Definition: pgp_functions.h:37
struct Menu * menu
Pgp Menu.
Definition: pgp_functions.h:36
bool done
Should we close the Dialog?
Definition: pgp_functions.h:35
struct PgpKeyInfo * key
Selected Key.
Definition: pgp_functions.h:38
Information about a PGP key.
Definition: pgplib.h:47
struct PgpKeyInfo * next
Definition: pgplib.h:57
PGP User ID.
Definition: pgplib.h:35
int flags
Definition: pgplib.h:38
struct PgpUid * next
Linked list.
Definition: pgplib.h:40
@ MENU_PGP
PGP encryption menu.
Definition: type.h:53
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_smime()

struct SmimeKey * dlg_smime ( struct SmimeKey keys,
const char *  query 
)

Get the user to select a key -.

Parameters
keysList of keys to select from
queryString to match
Return values
ptrKey selected by user

The Select SMIME Key Dialog lets the user select an SMIME Key to use.

Definition at line 200 of file dlg_smime.c.

201{
202 struct SmimeKey **table = NULL;
203 int table_size = 0;
204 int table_index = 0;
205 struct SmimeKey *key = NULL;
206
207 for (table_index = 0, key = keys; key; key = key->next)
208 {
209 if (table_index == table_size)
210 {
211 table_size += 5;
212 mutt_mem_realloc(&table, sizeof(struct SmimeKey *) * table_size);
213 }
214
215 table[table_index++] = key;
216 }
217
219
220 struct Menu *menu = dlg->wdata;
221 menu->max = table_index;
223 menu->mdata = table;
225 /* sorting keys might be done later - TODO */
226
227 struct SmimeData sd = { false, menu, table, NULL };
228 dlg->wdata = &sd;
229
230 char title[256] = { 0 };
231 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
232 snprintf(title, sizeof(title), _("S/MIME certificates matching \"%s\""), query);
233 sbar_set_title(sbar, title);
234
236
237 struct MuttWindow *old_focus = window_set_focus(menu->win);
238 // ---------------------------------------------------------------------------
239 // Event Loop
240 int op = OP_NULL;
241 do
242 {
243 menu_tagging_dispatcher(menu->win, op);
244 window_redraw(NULL);
245
247 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
248 if (op < 0)
249 continue;
250 if (op == OP_NULL)
251 {
253 continue;
254 }
256
257 int rc = smime_function_dispatcher(dlg, op);
258
259 if (rc == FR_UNKNOWN)
260 rc = menu_function_dispatcher(menu->win, op);
261 if (rc == FR_UNKNOWN)
262 rc = global_function_dispatcher(NULL, op);
263 } while (!sd.done);
264
265 window_set_focus(old_focus);
266 simple_dialog_free(&dlg);
267 return sd.key;
268}
static const struct Mapping SmimeHelp[]
Help Bar for the Smime key selection dialog.
Definition: dlg_smime.c:72
int smime_function_dispatcher(struct MuttWindow *win, int op)
Perform a Smime function - Implements function_dispatcher_t -.
static int smime_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an S/MIME Key for the Menu - Implements Menu::make_entry() -.
Definition: dlg_smime.c:110
static void smime_key_table_free(struct Menu *menu, void **ptr)
Free the key table - Implements Menu::mdata_free() -.
Definition: dlg_smime.c:187
@ WT_DLG_SMIME
Smime Dialog, dlg_smime()
Definition: mutt_window.h:91
Data to pass to the Smime Functions.
struct SmimeKey * key
Selected Key.
bool done
Should we close the Dialog?
struct Menu * menu
Smime Menu.
struct SmimeKey ** table
Array of Keys.
An SIME key.
Definition: smime.h:43
struct SmimeKey * next
Definition: smime.h:50
@ MENU_SMIME
SMIME encryption menu.
Definition: type.h:56
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_pager()

int dlg_pager ( struct PagerView pview)

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

Parameters
pviewPager view settings
Return values
0Success
-1Error

The Pager Dialog displays an Email to the user.

They can navigate through the Email, search through it and user color commands to highlight it.

From the Pager, the user can also use some Index functions, such as <next-entry> or <delete>.

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

216{
217 //===========================================================================
218 // ACT 1 - Ensure sanity of the caller and determine the mode
219 //===========================================================================
220 ASSERT(pview);
221 ASSERT((pview->mode > PAGER_MODE_UNKNOWN) && (pview->mode < PAGER_MODE_MAX));
222 ASSERT(pview->pdata); // view can't exist in a vacuum
223 ASSERT(pview->win_pager);
224 ASSERT(pview->win_pbar);
225
226 struct MuttWindow *dlg = dialog_find(pview->win_pager);
227 struct IndexSharedData *shared = dlg->wdata;
228 struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
229
230 switch (pview->mode)
231 {
232 case PAGER_MODE_EMAIL:
233 // This case was previously identified by IsEmail macro
234 // we expect data to contain email and not contain body
235 // We also expect email to always belong to some mailbox
236 ASSERT(shared->mailbox_view);
237 ASSERT(shared->mailbox);
238 ASSERT(shared->email);
239 ASSERT(!pview->pdata->body);
240 break;
241
243 // this case was previously identified by IsAttach and IsMsgAttach
244 // macros, we expect data to contain:
245 // - body (viewing regular attachment)
246 // - fp and body->email in special case of viewing an attached email.
247 ASSERT(pview->pdata->body);
248 if (pview->pdata->fp && pview->pdata->body->email)
249 {
250 // Special case: attachment is a full-blown email message.
251 // Yes, emails can contain other emails.
252 pview->mode = PAGER_MODE_ATTACH_E;
253 }
254 break;
255
256 case PAGER_MODE_HELP:
257 case PAGER_MODE_OTHER:
258 ASSERT(!shared->mailbox_view);
259 ASSERT(!shared->email);
260 ASSERT(!pview->pdata->body);
261 break;
262
264 case PAGER_MODE_MAX:
265 default:
266 // Unexpected mode. Catch fire and explode.
267 // This *should* happen if mode is PAGER_MODE_ATTACH_E, since
268 // we do not expect any caller to pass it to us.
269 ASSERT(false);
270 break;
271 }
272
273 //===========================================================================
274 // ACT 2 - Declare, initialize local variables, read config, etc.
275 //===========================================================================
276
277 //---------- local variables ------------------------------------------------
278 int op = 0;
279 enum MailboxType mailbox_type = shared->mailbox ? shared->mailbox->type : MUTT_UNKNOWN;
280 struct PagerPrivateData *priv = pview->win_pager->parent->wdata;
281 priv->rc = -1;
282 priv->searchctx = 0;
283 priv->first = true;
284 priv->wrapped = false;
285 priv->delay_read_timestamp = 0;
286 priv->pager_redraw = false;
287
288 // Wipe any previous state info
289 struct Notify *notify = priv->notify;
290 int prc = priv->rc;
291 memset(priv, 0, sizeof(*priv));
292 priv->rc = prc;
293 priv->notify = notify;
294 TAILQ_INIT(&priv->ansi_list);
295
296 //---------- setup flags ----------------------------------------------------
297 if (!(pview->flags & MUTT_SHOWCOLOR))
298 pview->flags |= MUTT_SHOWFLAT;
299
300 if ((pview->mode == PAGER_MODE_EMAIL) && !shared->email->read)
301 {
302 if (shared->mailbox_view)
303 shared->mailbox_view->msg_in_pager = shared->email->msgno;
304 const short c_pager_read_delay = cs_subset_number(NeoMutt->sub, "pager_read_delay");
305 if (c_pager_read_delay == 0)
306 {
307 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
308 }
309 else
310 {
311 priv->delay_read_timestamp = mutt_date_now_ms() + (1000 * c_pager_read_delay);
312 }
313 }
314 //---------- setup help menu ------------------------------------------------
315 pview->win_pager->help_data = pager_resolve_help_mapping(pview->mode, mailbox_type);
317
318 //---------- initialize redraw pdata -----------------------------------------
320 priv->lines_max = LINES; // number of lines on screen, from curses
321 priv->lines = mutt_mem_calloc(priv->lines_max, sizeof(struct Line));
322 priv->fp = mutt_file_fopen(pview->pdata->fname, "r");
323 priv->has_types = ((pview->mode == PAGER_MODE_EMAIL) || (pview->flags & MUTT_SHOWCOLOR)) ?
324 MUTT_TYPES :
325 0; // main message or rfc822 attachment
326
327 for (size_t i = 0; i < priv->lines_max; i++)
328 {
329 priv->lines[i].cid = -1;
330 priv->lines[i].search_arr_size = -1;
331 priv->lines[i].syntax = mutt_mem_calloc(1, sizeof(struct TextSyntax));
332 (priv->lines[i].syntax)[0].first = -1;
333 (priv->lines[i].syntax)[0].last = -1;
334 }
335
336 // ---------- try to open the pdata file -------------------------------------
337 if (!priv->fp)
338 {
339 mutt_perror("%s", pview->pdata->fname);
340 return -1;
341 }
342
343 if (stat(pview->pdata->fname, &priv->st) != 0)
344 {
345 mutt_perror("%s", pview->pdata->fname);
346 mutt_file_fclose(&priv->fp);
347 return -1;
348 }
349 unlink(pview->pdata->fname);
350 priv->pview = pview;
351
352 //---------- show windows, set focus and visibility --------------------------
353 window_set_visible(pview->win_pager->parent, true);
356
357 struct MuttWindow *old_focus = window_set_focus(pview->win_pager);
358
359 //---------- jump to the bottom if requested ------------------------------
360 if (pview->flags & MUTT_PAGER_BOTTOM)
361 {
362 jump_to_bottom(priv, pview);
363 }
364
365 //-------------------------------------------------------------------------
366 // ACT 3: Read user input and decide what to do with it
367 // ...but also do a whole lot of other things.
368 //-------------------------------------------------------------------------
369
370 // Force an initial paint, which will populate priv->lines
372 window_redraw(NULL);
373
375 do
376 {
379 window_redraw(NULL);
380
381 const bool c_braille_friendly = cs_subset_bool(NeoMutt->sub, "braille_friendly");
382 if (c_braille_friendly)
383 {
384 if (BrailleRow != -1)
385 {
387 BrailleRow = -1;
388 }
389 }
390 else
391 {
392 mutt_window_move(priv->pview->win_pbar, priv->pview->win_pager->state.cols - 1, 0);
393 }
394
395 // force redraw of the screen at every iteration of the event loop
396 mutt_refresh();
397
398 //-------------------------------------------------------------------------
399 // Check if information in the status bar needs an update
400 // This is done because pager is a single-threaded application, which
401 // tries to emulate concurrency.
402 //-------------------------------------------------------------------------
403 bool do_new_mail = false;
404 if (shared->mailbox && !shared->attach_msg)
405 {
406 int oldcount = shared->mailbox->msg_count;
407 /* check for new mail */
408 enum MxStatus check = mx_mbox_check(shared->mailbox);
409 if (check == MX_STATUS_ERROR)
410 {
411 if (!shared->mailbox || buf_is_empty(&shared->mailbox->pathbuf))
412 {
413 /* fatal error occurred */
415 break;
416 }
417 }
418 else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
419 (check == MX_STATUS_FLAGS))
420 {
421 /* notify user of newly arrived mail */
422 if (check == MX_STATUS_NEW_MAIL)
423 {
424 for (size_t i = oldcount; i < shared->mailbox->msg_count; i++)
425 {
426 struct Email *e = shared->mailbox->emails[i];
427
428 if (e && !e->read)
429 {
430 mutt_message(_("New mail in this mailbox"));
431 do_new_mail = true;
432 break;
433 }
434 }
435 }
436
437 if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
438 {
441 }
442 }
443
444 if (mutt_mailbox_notify(shared->mailbox) || do_new_mail)
445 {
446 const bool c_beep_new = cs_subset_bool(NeoMutt->sub, "beep_new");
447 if (c_beep_new)
448 mutt_beep(true);
449 const struct Expando *c_new_mail_command = cs_subset_expando(NeoMutt->sub, "new_mail_command");
450 if (c_new_mail_command)
451 {
452 struct Buffer *cmd = buf_pool_get();
453 menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
454 if (mutt_system(buf_string(cmd)) != 0)
455 mutt_error(_("Error running \"%s\""), buf_string(cmd));
456 buf_pool_release(&cmd);
457 }
458 }
459 }
460 //-------------------------------------------------------------------------
461
462 if (priv->pager_redraw)
463 {
464 priv->pager_redraw = false;
466 clearok(stdscr, true); /* force complete redraw */
467 msgwin_clear_text(NULL);
468
470 if (pview->flags & MUTT_PAGER_RETWINCH)
471 {
472 /* Store current position. */
473 priv->win_height = -1;
474 for (size_t i = 0; i <= priv->top_line; i++)
475 if (!priv->lines[i].cont_line)
476 priv->win_height++;
477
478 op = OP_ABORT;
479 priv->rc = OP_REFORMAT_WINCH;
480 break;
481 }
482 else
483 {
484 /* note: mutt_resize_screen() -> mutt_window_reflow() sets
485 * PAGER_REDRAW_PAGER and PAGER_REDRAW_FLOW */
486 op = OP_NULL;
487 }
488 continue;
489 }
490
491 dump_pager(priv);
492
493 //-------------------------------------------------------------------------
494 // Finally, read user's key press
495 //-------------------------------------------------------------------------
496 // km_dokey() reads not only user's key strokes, but also a MacroBuffer
497 // MacroBuffer may contain OP codes of the operations.
498 // MacroBuffer is global
499 // OP codes inserted into the MacroBuffer by various functions.
500 // One of such functions is `mutt_enter_command()`
501 // Some OP codes are not handled by pager, they cause pager to quit returning
502 // OP code to index. Index handles the operation and then restarts pager
504
505 // km_dokey() can block, so recheck the timer.
506 // Note: This check must occur before handling the operations of the index
507 // as those can change the currently selected message/entry yielding to
508 // marking the wrong message as read.
510 {
511 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
512 }
513
514 if (SigWinch)
515 priv->pager_redraw = true;
516
517 if (op >= OP_NULL)
519
520 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
521
522 if (op < OP_NULL)
523 {
524 op = OP_NULL;
525 continue;
526 }
527
528 if (op == OP_NULL)
529 {
531 continue;
532 }
533
534 int rc = pager_function_dispatcher(priv->pview->win_pager, op);
535
536 if (pview->mode == PAGER_MODE_EMAIL)
537 {
538 if ((rc == FR_UNKNOWN) && priv->pview->win_index)
540 if (rc == FR_UNKNOWN)
541 rc = sb_function_dispatcher(win_sidebar, op);
542 }
543 if (rc == FR_UNKNOWN)
544 rc = global_function_dispatcher(NULL, op);
545
546 if ((rc == FR_UNKNOWN) &&
547 ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
548 {
549 // Some attachment functions still need to be delegated
550 priv->rc = op;
551 break;
552 }
553
554 if ((pview->mode != PAGER_MODE_EMAIL) && (rc == FR_UNKNOWN))
556
557 } while (priv->loop == PAGER_LOOP_CONTINUE);
558 window_set_focus(old_focus);
559
560 //-------------------------------------------------------------------------
561 // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
562 //-------------------------------------------------------------------------
563
564 mutt_file_fclose(&priv->fp);
565 if (pview->mode == PAGER_MODE_EMAIL)
566 {
567 if (shared->mailbox_view)
568 shared->mailbox_view->msg_in_pager = -1;
569 }
570
572
573 for (size_t i = 0; i < priv->lines_max; i++)
574 {
575 FREE(&(priv->lines[i].syntax));
576 if (priv->search_compiled && priv->lines[i].search)
577 FREE(&(priv->lines[i].search));
578 }
579 if (priv->search_compiled)
580 {
581 regfree(&priv->search_re);
582 priv->search_compiled = false;
583 }
584 FREE(&priv->lines);
586 {
587 struct AttrColor *ac = NULL;
588 int count = 0;
589 TAILQ_FOREACH(ac, &priv->ansi_list, entries)
590 {
591 count++;
592 }
593 color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
594 }
595
596 priv->pview = NULL;
597
598 if (priv->loop == PAGER_LOOP_RELOAD)
599 return PAGER_LOOP_RELOAD;
600
601 return (priv->rc != -1) ? priv->rc : 0;
602}
void attr_color_list_clear(struct AttrColorList *acl)
Free the contents of an AttrColorList.
Definition: attr.c:117
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:143
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:58
void dump_pager(struct PagerPrivateData *priv)
Definition: pager.c:101
static int color_debug(enum LogLevel level, const char *format,...)
Definition: debug.h:53
struct MuttWindow * dialog_find(struct MuttWindow *win)
Find the parent Dialog of a Window.
Definition: dialog.c:89
int BrailleRow
Braille display: row to leave the cursor.
Definition: dlg_pager.c:67
int BrailleCol
Braille display: column to leave the cursor.
Definition: dlg_pager.c:69
static bool check_read_delay(uint64_t *timestamp)
Is it time to mark the message read?
Definition: dlg_pager.c:176
void pager_queue_redraw(struct PagerPrivateData *priv, PagerRedrawFlags redraw)
Queue a request for a redraw.
Definition: dlg_pager.c:127
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:139
#define mutt_file_fclose(FP)
Definition: file.h:138
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:137
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
int pager_function_dispatcher(struct MuttWindow *win, int op)
Perform a Pager function - Implements function_dispatcher_t -.
Definition: functions.c:1125
#define mutt_perror(...)
Definition: logging2.h:93
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:51
#define FREE(x)
Definition: memory.h:45
uint64_t mutt_date_now_ms(void)
Return the number of milliseconds since the Unix epoch.
Definition: date.c:465
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:73
void mutt_resize_screen(void)
Update NeoMutt's opinion about the window size.
Definition: resize.c:76
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:164
void window_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:766
@ MUTT_WIN_SIZE_MAXIMISE
Window wants as much space as possible.
Definition: mutt_window.h:48
@ NT_PAGER
Pager data has changed, NotifyPager, PagerPrivateData.
Definition: notify_type.h:53
#define OP_ABORT
$abort_key pressed (Ctrl-G)
Definition: opcodes.h:37
bool jump_to_bottom(struct PagerPrivateData *priv, struct PagerView *pview)
Make sure the bottom line is displayed.
Definition: functions.c:376
@ PAGER_LOOP_RELOAD
Reload the Pager from scratch.
Definition: lib.h:154
@ PAGER_LOOP_CONTINUE
Stay in the Pager Event Loop.
Definition: lib.h:152
#define MUTT_PAGER_RETWINCH
Need reformatting on SIGWINCH.
Definition: lib.h:71
#define NT_PAGER_VIEW
Pager View has changed.
Definition: lib.h:187
#define MUTT_TYPES
Compute line's type.
Definition: lib.h:65
#define MUTT_SHOWCOLOR
Show characters in color otherwise don't show characters.
Definition: lib.h:62
#define PAGER_REDRAW_FLOW
Reflow the pager.
Definition: lib.h:192
#define MUTT_PAGER_BOTTOM
Start at the bottom.
Definition: lib.h:75
@ PAGER_MODE_OTHER
Pager is invoked via 3rd path. Non-email content is likely to be shown.
Definition: lib.h:142
@ PAGER_MODE_HELP
Pager is invoked via 3rd path to show help.
Definition: lib.h:141
@ 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:139
@ PAGER_MODE_EMAIL
Pager is invoked via 1st path. The mime part is selected automatically.
Definition: lib.h:138
@ PAGER_MODE_ATTACH_E
A special case of PAGER_MODE_ATTACH - attachment is a full-blown email message.
Definition: lib.h:140
@ PAGER_MODE_UNKNOWN
A default and invalid mode, should never be used.
Definition: lib.h:136
@ PAGER_MODE_MAX
Another invalid mode, should never be used.
Definition: lib.h:144
#define PAGER_REDRAW_PAGER
Redraw the pager.
Definition: lib.h:191
#define MUTT_SHOWFLAT
Show characters (used for displaying help)
Definition: lib.h:61
#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:215
#define ASSERT(COND)
Definition: signal2.h:58
volatile sig_atomic_t SigWinch
true after SIGWINCH is received
Definition: signal.c:67
A curses colour and its attributes.
Definition: attr.h:66
struct Email * email
header information for message/rfc822
Definition: body.h:74
int msgno
Number displayed to the user.
Definition: email.h:111
struct Email * email
Currently selected Email.
Definition: shared_data.h:42
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:45
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:134
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:130
Notification API.
Definition: notify.c:53
const char * fname
Name of the file to read.
Definition: lib.h:165
FILE * fp
Source stream.
Definition: lib.h:163
struct Body * body
Current attachment.
Definition: lib.h:162
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
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
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
struct MuttWindow * win_pbar
Pager Bar Window.
Definition: lib.h:179
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:180
Highlighting for a piece of text.
Definition: display.h:40
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_pattern()

bool dlg_pattern ( char *  buf,
size_t  buflen 
)

Show menu to select a Pattern -.

Parameters
bufBuffer for the selected Pattern
buflenLength of buffer
Return values
trueA selection was made

The Select Pattern Dialog shows the user a help page of Patterns. They can select one to auto-complete some functions, e.g. <limit>

Definition at line 342 of file dlg_pattern.c.

343{
345 struct Menu *menu = create_pattern_menu(dlg);
346
347 struct PatternData pd = { false, false, buf, buflen, menu };
348 dlg->wdata = &pd;
349
350 // NT_COLOR is handled by the SimpleDialog
353
354 struct MuttWindow *old_focus = window_set_focus(menu->win);
355 // ---------------------------------------------------------------------------
356 // Event Loop
357 int op = OP_NULL;
358 do
359 {
360 menu_tagging_dispatcher(menu->win, op);
361 window_redraw(NULL);
362
364 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
365 if (op < 0)
366 continue;
367 if (op == OP_NULL)
368 {
370 continue;
371 }
373
374 int rc = pattern_function_dispatcher(dlg, op);
375 if (rc == FR_UNKNOWN)
376 rc = menu_function_dispatcher(menu->win, op);
377 if (rc == FR_UNKNOWN)
378 rc = global_function_dispatcher(NULL, op);
379 } while (!pd.done);
380 // ---------------------------------------------------------------------------
381
382 window_set_focus(old_focus);
383 simple_dialog_free(&dlg);
384 return pd.selection;
385}
static const struct Mapping PatternHelp[]
Help Bar for the Pattern selection dialog.
Definition: dlg_pattern.c:88
static struct Menu * create_pattern_menu(struct MuttWindow *dlg)
Create the Pattern Completion menu.
Definition: dlg_pattern.c:174
int pattern_function_dispatcher(struct MuttWindow *win, int op)
Perform a Pattern function - Implements function_dispatcher_t -.
Definition: functions.c:77
static int pattern_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_pattern.c:310
static int pattern_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_pattern.c:284
@ WT_DLG_PATTERN
Pattern Dialog, dlg_pattern()
Definition: mutt_window.h:87
Data to pass to the Pattern Functions.
Definition: functions.h:35
char * buf
Buffer for the results.
Definition: functions.h:38
struct Menu * menu
Pattern Menu.
Definition: functions.h:40
bool done
Should we close the Dialog?
Definition: functions.h:36
size_t buflen
Length of the results buffer.
Definition: functions.h:39
bool selection
Was a selection made?
Definition: functions.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_postponed()

struct Email * dlg_postponed ( struct Mailbox m)

Create a Menu to select a postponed message -.

Parameters
mMailbox
Return values
ptrEmail

The Select Postponed Email Dialog shows the user a list of draft emails. They can select one to use in the Compose Dialog.

This dialog is only shown if there are two or more postponed emails.

Definition at line 208 of file dlg_postpone.c.

209{
211 // Required to number the emails
212 struct MailboxView *mv = mview_new(m, NeoMutt->notify);
213
214 struct Menu *menu = dlg->wdata;
216 menu->color = post_color;
217 menu->max = m->msg_count;
218 menu->mdata = mv;
219 menu->mdata_free = NULL; // Menu doesn't own the data
220
221 struct PostponeData pd = { mv, menu, NULL, false, search_state_new() };
222 dlg->wdata = &pd;
223
224 // NT_COLOR is handled by the SimpleDialog
227
228 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
229 sbar_set_title(sbar, _("Postponed Messages"));
230
231 /* The postponed mailbox is setup to have sorting disabled, but the global
232 * `$sort` variable may indicate something different. Sorting has to be
233 * disabled while the postpone menu is being displayed. */
234 const enum SortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
236
237 struct MuttWindow *old_focus = window_set_focus(menu->win);
238 // ---------------------------------------------------------------------------
239 // Event Loop
240 int op = OP_NULL;
241 do
242 {
243 menu_tagging_dispatcher(menu->win, op);
244 window_redraw(NULL);
245
247 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
248 if (op < 0)
249 continue;
250 if (op == OP_NULL)
251 {
253 continue;
254 }
256
257 int rc = postpone_function_dispatcher(dlg, op);
258
259 if (rc == FR_UNKNOWN)
260 rc = menu_function_dispatcher(menu->win, op);
261 if (rc == FR_UNKNOWN)
262 rc = global_function_dispatcher(NULL, op);
263 } while (!pd.done);
264 // ---------------------------------------------------------------------------
265
266 mview_free(&mv);
267 cs_subset_str_native_set(NeoMutt->sub, "sort", c_sort, NULL);
269 window_set_focus(old_focus);
270 simple_dialog_free(&dlg);
271
272 return pd.email;
273}
static const struct Mapping PostponedHelp[]
Help Bar for the Postponed email selection dialog.
Definition: dlg_postpone.c:88
int postpone_function_dispatcher(struct MuttWindow *win, int op)
Perform a Postpone function - Implements function_dispatcher_t -.
Definition: functions.c:177
static const struct AttrColor * post_color(struct Menu *menu, int line)
Calculate the colour for a line of the postpone index - Implements Menu::color() -.
Definition: dlg_postpone.c:177
static int post_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
Format an Email for the Menu - Implements Menu::make_entry() -.
Definition: dlg_postpone.c:103
static int postponed_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_postpone.c:151
static int postponed_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_postpone.c:125
@ WT_DLG_POSTPONED
Postponed Dialog, dlg_postponed()
Definition: mutt_window.h:89
void search_state_free(struct SearchState **ptr)
Free a SearchState.
Definition: search_state.c:51
struct SearchState * search_state_new(void)
Create a new SearchState.
Definition: search_state.c:39
View of a Mailbox.
Definition: mview.h:40
Data to pass to the Postpone Functions.
Definition: functions.h:34
struct Email * email
Selected Email.
Definition: functions.h:37
struct SearchState * search_state
State of the current search.
Definition: functions.h:39
bool done
Should we close the Dialog?
Definition: functions.h:38
struct Menu * menu
Postponed Menu.
Definition: functions.h:36
int cs_subset_str_native_set(const struct ConfigSubset *sub, const char *name, intptr_t value, struct Buffer *err)
Natively set the value of a string config item.
Definition: subset.c:297
@ MENU_POSTPONED
Select a postponed email.
Definition: type.h:54
+ Here is the call graph for this function:
+ Here is the caller graph for this function: