NeoMutt  2024-03-23-147-g885fbc
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 -.
 
void dlg_mixmaster (struct ListHead *chainhead)
 Create a Mixmaster chain -.
 
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:463
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: get.c:293
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:172
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:634
struct MuttWindow * window_set_focus(struct MuttWindow *win)
Set the Window focus.
Definition: mutt_window.c:684
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:533
@ WT_STATUS_BAR
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
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:145
@ 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:98
@ MENU_QUERY
Select from results of external query.
Definition: type.h:58
+ 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:138
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
@ 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:48
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 1296 of file dlg_browser.c.

1298{
1300 priv->file = file;
1301 priv->mailbox = m;
1302 priv->files = files;
1303 priv->numfiles = numfiles;
1304 struct MuttWindow *dlg = NULL;
1305
1306 priv->multiple = (flags & MUTT_SEL_MULTI);
1307 priv->folder = (flags & MUTT_SEL_FOLDER);
1308 priv->state.is_mailbox_list = (flags & MUTT_SEL_MAILBOX) && priv->folder;
1309 priv->last_selected_mailbox = -1;
1310
1311 init_lastdir();
1312
1313 if (OptNews)
1314 {
1315 if (buf_is_empty(file))
1316 {
1318
1319 /* default state for news reader mode is browse subscribed newsgroups */
1320 priv->state.is_mailbox_list = false;
1321 for (size_t i = 0; i < adata->groups_num; i++)
1322 {
1323 struct NntpMboxData *mdata = adata->groups_list[i];
1324 if (mdata && mdata->subscribed)
1325 {
1326 priv->state.is_mailbox_list = true;
1327 break;
1328 }
1329 }
1330 }
1331 else
1332 {
1333 buf_copy(priv->prefix, file);
1334 }
1335 }
1336 else if (!buf_is_empty(file))
1337 {
1338 buf_expand_path(file);
1339 if (imap_path_probe(buf_string(file), NULL) == MUTT_IMAP)
1340 {
1341 init_state(&priv->state, NULL);
1342 priv->state.imap_browse = true;
1343 if (imap_browse(buf_string(file), &priv->state) == 0)
1344 {
1345 buf_strcpy(&LastDir, priv->state.folder);
1346 browser_sort(&priv->state);
1347 }
1348 }
1349 else
1350 {
1351 int i;
1352 for (i = buf_len(file) - 1; (i > 0) && ((buf_string(file))[i] != '/'); i--)
1353 {
1354 ; // do nothing
1355 }
1356
1357 if (i > 0)
1358 {
1359 if ((buf_string(file))[0] == '/')
1360 {
1361 buf_strcpy_n(&LastDir, buf_string(file), i);
1362 }
1363 else
1364 {
1366 buf_addch(&LastDir, '/');
1367 buf_addstr_n(&LastDir, buf_string(file), i);
1368 }
1369 }
1370 else
1371 {
1372 if ((buf_string(file))[0] == '/')
1373 buf_strcpy(&LastDir, "/");
1374 else
1376 }
1377
1378 if ((i <= 0) && (buf_string(file)[0] != '/'))
1379 buf_copy(priv->prefix, file);
1380 else
1381 buf_strcpy(priv->prefix, buf_string(file) + i + 1);
1382 priv->kill_prefix = true;
1383 }
1384 }
1385 else
1386 {
1387 if (priv->folder)
1388 {
1389 /* Whether we use the tracking feature of the browser depends
1390 * on which sort method we chose to use. This variable is defined
1391 * only to help readability of the code. */
1392 bool browser_track = false;
1393
1394 const enum SortType c_sort_browser = cs_subset_sort(NeoMutt->sub, "sort_browser");
1395 switch (c_sort_browser & SORT_MASK)
1396 {
1397 case SORT_DESC:
1398 case SORT_SUBJECT:
1399 case SORT_ORDER:
1400 browser_track = true;
1401 break;
1402 }
1403
1404 /* We use mutt_browser_select_dir to initialize the two
1405 * variables (LastDir, LastDirBackup) at the appropriate
1406 * values.
1407 *
1408 * We do it only when LastDir is not set (first pass there)
1409 * or when CurrentFolder and LastDirBackup are not the same.
1410 * This code is executed only when we list files, not when
1411 * we press up/down keys to navigate in a displayed list.
1412 *
1413 * We only do this when CurrentFolder has been set (ie, not
1414 * when listing folders on startup with "neomutt -y").
1415 *
1416 * This tracker is only used when browser_track is true,
1417 * meaning only with sort methods SUBJECT/DESC for now. */
1418 if (CurrentFolder)
1419 {
1420 if (buf_is_empty(&LastDir))
1421 {
1422 /* If browsing in "local"-mode, than we chose to define LastDir to
1423 * MailDir */
1425 {
1426 case MUTT_IMAP:
1427 case MUTT_MAILDIR:
1428 case MUTT_MBOX:
1429 case MUTT_MH:
1430 case MUTT_MMDF:
1431 {
1432 const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
1433 const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
1434 if (c_folder)
1435 buf_strcpy(&LastDir, c_folder);
1436 else if (c_spool_file)
1437 mutt_browser_select_dir(c_spool_file);
1438 break;
1439 }
1440 default:
1442 break;
1443 }
1444 }
1446 {
1448 }
1449 }
1450
1451 /* When browser tracking feature is disabled, clear LastDirBackup */
1452 if (!browser_track)
1454 }
1455 else
1456 {
1458 }
1459
1460 if (!priv->state.is_mailbox_list &&
1462 {
1463 init_state(&priv->state, NULL);
1464 priv->state.imap_browse = true;
1466 browser_sort(&priv->state);
1467 }
1468 else
1469 {
1470 size_t i = buf_len(&LastDir);
1471 while ((i > 0) && (buf_string(&LastDir)[--i] == '/'))
1472 LastDir.data[i] = '\0';
1474 if (buf_is_empty(&LastDir))
1476 }
1477 }
1478
1479 buf_reset(file);
1480
1481 const struct Mapping *help_data = NULL;
1482
1483 if (OptNews)
1484 help_data = FolderNewsHelp;
1485 else
1486 help_data = FolderHelp;
1487
1488 dlg = simple_dialog_new(MENU_FOLDER, WT_DLG_BROWSER, help_data);
1489
1490 priv->menu = dlg->wdata;
1491 dlg->wdata = priv;
1494 if (priv->multiple)
1495 priv->menu->tag = file_tag;
1496
1497 priv->sbar = window_find_child(dlg, WT_STATUS_BAR);
1499
1500 struct MuttWindow *win_menu = priv->menu->win;
1501
1502 // NT_COLOR is handled by the SimpleDialog
1506
1507 struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
1508
1509 if (priv->state.is_mailbox_list)
1510 {
1511 examine_mailboxes(m, NULL, &priv->state);
1512 }
1513 else if (!priv->state.imap_browse)
1514 {
1515 // examine_directory() calls browser_add_folder() which needs the menu
1516 if (examine_directory(m, priv->menu, &priv->state, buf_string(&LastDir),
1517 buf_string(priv->prefix)) == -1)
1518 {
1519 goto bail;
1520 }
1521 }
1522
1523 init_menu(&priv->state, priv->menu, m, priv->sbar);
1524 // only now do we have a valid priv->state to attach
1525 priv->menu->mdata = &priv->state;
1526
1527 // ---------------------------------------------------------------------------
1528 // Event Loop
1529 int op = OP_NULL;
1530 do
1531 {
1532 menu_tagging_dispatcher(priv->menu->win, op);
1533 window_redraw(NULL);
1534
1536 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
1537 if (op < 0)
1538 continue;
1539 if (op == OP_NULL)
1540 {
1542 continue;
1543 }
1545
1546 int rc = browser_function_dispatcher(priv->win_browser, op);
1547
1548 if (rc == FR_UNKNOWN)
1549 rc = menu_function_dispatcher(priv->menu->win, op);
1550 if (rc == FR_UNKNOWN)
1551 rc = global_function_dispatcher(NULL, op);
1552 } while (!priv->done);
1553 // ---------------------------------------------------------------------------
1554
1555bail:
1556 window_set_focus(old_focus);
1557 simple_dialog_free(&dlg);
1559}
int browser_function_dispatcher(struct MuttWindow *win, int op)
Perform a Browser function.
Definition: functions.c:1139
#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:95
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:490
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:75
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:290
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:181
size_t buf_strcpy_n(struct Buffer *buf, const char *s, size_t len)
Copy a string into a Buffer.
Definition: buffer.c:415
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:240
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:394
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition: buffer.c:600
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:267
@ 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:689
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:712
void init_menu(struct BrowserState *state, struct Menu *menu, struct Mailbox *m, struct MuttWindow *sbar)
Set up a new menu.
Definition: dlg_browser.c:1029
static void init_lastdir(void)
Initialise the browser directories.
Definition: dlg_browser.c:149
static const struct Mapping FolderNewsHelp[]
Help Bar for the NNTP Mailbox browser dialog.
Definition: dlg_browser.c:126
struct Buffer LastDir
Browser: previous selected directory.
Definition: dlg_browser.c:140
void mutt_browser_select_dir(const char *f)
Remember the last directory selected.
Definition: dlg_browser.c:1273
struct Buffer LastDirBackup
Browser: backup copy of the current directory.
Definition: dlg_browser.c:142
static const struct Mapping FolderHelp[]
Help Bar for the File/Dir/Mailbox browser dialog.
Definition: dlg_browser.c:114
int examine_mailboxes(struct Mailbox *m, struct Menu *menu, struct BrowserState *state)
Get list of mailboxes/subscribed newsgroups.
Definition: dlg_browser.c:839
bool OptNews
(pseudo) used to change reader mode
Definition: globals.c:70
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:960
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:944
static int file_tag(struct Menu *menu, int sel, int act)
Tag an entry in the menu - Implements Menu::tag() -.
Definition: dlg_browser.c:1134
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
Definition: imap.c:2344
static int browser_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_browser.c:1154
static int browser_mailbox_observer(struct NotifyCallback *nc)
Notification that a Mailbox has changed - Implements observer_t -.
Definition: dlg_browser.c:1194
static int browser_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_browser.c:1239
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:472
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:709
@ 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:328
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1319
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:42
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:189
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: globals.c:71
int env_function_dispatcher(struct MuttWindow *win, int op)
Perform an Envelope function - Implements function_dispatcher_t -.
Definition: functions.c:546
int compose_function_dispatcher(struct MuttWindow *win, int op)
Perform a Compose function - Implements function_dispatcher_t -.
Definition: functions.c:2153
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:202
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:95
@ 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:142
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:141
@ 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:1030
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 1071 of file dlg_index.c.

1072{
1073 /* Make sure use_threads/sort/sort_aux are coherent */
1075
1076 struct IndexSharedData *shared = dlg->wdata;
1078
1079 struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
1080
1081 struct IndexPrivateData *priv = panel_index->wdata;
1082 priv->win_index = window_find_child(panel_index, WT_MENU);
1083
1084 int op = OP_NULL;
1085
1086 if (shared->mailbox && (shared->mailbox->type == MUTT_NNTP))
1087 dlg->help_data = IndexNewsHelp;
1088 else
1089 dlg->help_data = IndexHelp;
1090 dlg->help_menu = MENU_INDEX;
1091
1092 priv->menu = priv->win_index->wdata;
1094 priv->menu->color = index_color;
1095 priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
1097
1098 struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
1099 mutt_window_reflow(NULL);
1100
1101 if (!shared->attach_msg)
1102 {
1103 /* force the mailbox check after we enter the folder */
1105 }
1106#ifdef USE_INOTIFY
1107 mutt_monitor_add(NULL);
1108#endif
1109
1110 const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
1111 if (mutt_using_threads() && c_collapse_all)
1112 {
1113 collapse_all(shared->mailbox_view, priv->menu, 0);
1115 }
1116
1117 int rc = 0;
1118 do
1119 {
1120 /* Clear the tag prefix unless we just started it.
1121 * Don't clear the prefix on a timeout, but do clear on an abort */
1122 if (priv->tag_prefix && (op != OP_TAG_PREFIX) &&
1123 (op != OP_TAG_PREFIX_COND) && (op != OP_TIMEOUT))
1124 {
1125 priv->tag_prefix = false;
1126 }
1127
1128 /* check if we need to resort the index because just about
1129 * any 'op' below could do mutt_enter_command(), either here or
1130 * from any new priv->menu launched, and change $sort/$sort_aux */
1131 if (OptNeedResort && shared->mailbox && (shared->mailbox->msg_count != 0) &&
1132 (menu_get_index(priv->menu) >= 0))
1133 {
1134 resort_index(shared->mailbox_view, priv->menu);
1135 }
1136
1137 priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
1138 priv->oldcount = shared->mailbox ? shared->mailbox->msg_count : 0;
1139
1140 if (shared->mailbox && shared->mailbox_view)
1141 {
1143
1144 shared->mailbox_view->menu = priv->menu;
1145 /* check for new mail in the mailbox. If nonzero, then something has
1146 * changed about the file (either we got new mail or the file was
1147 * modified underneath us.) */
1148 enum MxStatus check = mx_mbox_check(shared->mailbox);
1149
1150 if (check == MX_STATUS_ERROR)
1151 {
1152 if (buf_is_empty(&shared->mailbox->pathbuf))
1153 {
1154 /* fatal error occurred */
1155 mview_free(&shared->mailbox_view);
1157 }
1158
1160 }
1161 else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
1162 (check == MX_STATUS_FLAGS))
1163 {
1164 /* notify the user of new mail */
1165 if (check == MX_STATUS_REOPENED)
1166 {
1167 mutt_error(_("Mailbox was externally modified. Flags may be wrong."));
1168 }
1169 else if (check == MX_STATUS_NEW_MAIL)
1170 {
1171 for (size_t i = 0; i < shared->mailbox->msg_count; i++)
1172 {
1173 const struct Email *e = shared->mailbox->emails[i];
1174 if (e && !e->read && !e->old)
1175 {
1176 mutt_message(_("New mail in this mailbox"));
1177 const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
1178 if (c_beep_new)
1179 mutt_beep(true);
1180 const struct Expando *c_new_mail_command =
1181 cs_subset_expando(shared->sub, "new_mail_command");
1182 if (c_new_mail_command)
1183 {
1184 struct Buffer *cmd = buf_pool_get();
1185 menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
1186 if (mutt_system(buf_string(cmd)) != 0)
1187 mutt_error(_("Error running \"%s\""), buf_string(cmd));
1188 buf_pool_release(&cmd);
1189 }
1190 break;
1191 }
1192 }
1193 }
1194 else if (check == MX_STATUS_FLAGS)
1195 {
1196 mutt_message(_("Mailbox was externally modified"));
1197 }
1198
1199 /* avoid the message being overwritten by mailbox */
1200 priv->do_mailbox_notify = false;
1201
1202 bool verbose = shared->mailbox->verbose;
1203 shared->mailbox->verbose = false;
1204 update_index(priv->menu, shared->mailbox_view, check, priv->oldcount, shared);
1205 shared->mailbox->verbose = verbose;
1206 priv->menu->max = shared->mailbox->vcount;
1209 }
1210
1212 menu_get_index(priv->menu)));
1213 }
1214
1215 if (!shared->attach_msg)
1216 {
1217 /* check for new mail in the incoming folders */
1219 if (priv->do_mailbox_notify)
1220 {
1221 if (mutt_mailbox_notify(shared->mailbox))
1222 {
1223 const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
1224 if (c_beep_new)
1225 mutt_beep(true);
1226 const struct Expando *c_new_mail_command = cs_subset_expando(shared->sub, "new_mail_command");
1227 if (c_new_mail_command)
1228 {
1229 struct Buffer *cmd = buf_pool_get();
1230 menu_status_line(cmd, shared, priv->menu, -1, c_new_mail_command);
1231 if (mutt_system(buf_string(cmd)) != 0)
1232 mutt_error(_("Error running \"%s\""), buf_string(cmd));
1233 buf_pool_release(&cmd);
1234 }
1235 }
1236 }
1237 else
1238 {
1239 priv->do_mailbox_notify = true;
1240 }
1241 }
1242
1243 window_redraw(NULL);
1244
1245 /* give visual indication that the next command is a tag- command */
1246 if (priv->tag_prefix)
1247 {
1248 msgwin_set_text(NULL, "tag-", MT_COLOR_NORMAL);
1249 }
1250
1251 const bool c_arrow_cursor = cs_subset_bool(shared->sub, "arrow_cursor");
1252 const bool c_braille_friendly = cs_subset_bool(shared->sub, "braille_friendly");
1253 const int index = menu_get_index(priv->menu);
1254 if (c_arrow_cursor)
1255 {
1256 const char *const c_arrow_string = cs_subset_string(shared->sub, "arrow_string");
1257 const int arrow_width = mutt_strwidth(c_arrow_string);
1258 mutt_window_move(priv->menu->win, arrow_width, index - priv->menu->top);
1259 }
1260 else if (c_braille_friendly)
1261 {
1262 mutt_window_move(priv->menu->win, 0, index - priv->menu->top);
1263 }
1264 else
1265 {
1266 mutt_window_move(priv->menu->win, priv->menu->win->state.cols - 1,
1267 index - priv->menu->top);
1268 }
1269 mutt_refresh();
1270
1271 window_redraw(NULL);
1273
1274 if (op == OP_REPAINT)
1275 {
1276 /* force a real complete redraw. clrtobot() doesn't seem to be able
1277 * to handle every case without this. */
1278 msgwin_clear_text(NULL);
1279 mutt_refresh();
1280 continue;
1281 }
1282
1283 /* either user abort or timeout */
1284 if (op < OP_NULL)
1285 {
1286 if (priv->tag_prefix)
1287 msgwin_clear_text(NULL);
1288 continue;
1289 }
1290
1291 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
1292
1293 /* special handling for the priv->tag-prefix function */
1294 const bool c_auto_tag = cs_subset_bool(shared->sub, "auto_tag");
1295 if ((op == OP_TAG_PREFIX) || (op == OP_TAG_PREFIX_COND))
1296 {
1297 /* A second priv->tag-prefix command aborts */
1298 if (priv->tag_prefix)
1299 {
1300 priv->tag_prefix = false;
1301 msgwin_clear_text(NULL);
1302 continue;
1303 }
1304
1305 if (!shared->mailbox)
1306 {
1307 mutt_error(_("No mailbox is open"));
1308 continue;
1309 }
1310
1311 if (shared->mailbox->msg_tagged == 0)
1312 {
1313 if (op == OP_TAG_PREFIX)
1314 {
1315 mutt_error(_("No tagged messages"));
1316 }
1317 else if (op == OP_TAG_PREFIX_COND)
1318 {
1320 mutt_message(_("Nothing to do"));
1321 }
1322 continue;
1323 }
1324
1325 /* get the real command */
1326 priv->tag_prefix = true;
1327 continue;
1328 }
1329 else if (c_auto_tag && shared->mailbox && (shared->mailbox->msg_tagged != 0))
1330 {
1331 priv->tag_prefix = true;
1332 }
1333
1335
1336 OptNews = false; /* for any case */
1337
1338#ifdef USE_NOTMUCH
1339 nm_db_debug_check(shared->mailbox);
1340#endif
1341
1342 rc = index_function_dispatcher(priv->win_index, op);
1343
1344 if (rc == FR_UNKNOWN)
1345 rc = menu_function_dispatcher(priv->win_index, op);
1346
1347 if (rc == FR_UNKNOWN)
1348 {
1349 struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
1350 rc = sb_function_dispatcher(win_sidebar, op);
1351 }
1352 if (rc == FR_UNKNOWN)
1353 rc = global_function_dispatcher(NULL, op);
1354
1355 if (rc == FR_UNKNOWN)
1357
1358#ifdef USE_NOTMUCH
1359 nm_db_debug_check(shared->mailbox);
1360#endif
1361 } while (rc != FR_DONE);
1362
1363 mview_free(&shared->mailbox_view);
1364 window_set_focus(old_focus);
1365
1366 return shared->mailbox;
1367}
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:59
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:777
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:358
void mailbox_gc_run(void)
Run the garbage-collection.
Definition: mailbox.c:313
@ 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:119
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:544
int find_first_message(struct MailboxView *mv)
Get index of first new message.
Definition: dlg_index.c:311
static const struct Mapping IndexHelp[]
Help Bar for the Index dialog.
Definition: dlg_index.c:104
void resort_index(struct MailboxView *mv, struct Menu *menu)
Resort the index.
Definition: dlg_index.c:371
void collapse_all(struct MailboxView *mv, struct Menu *menu, int toggle)
Collapse/uncollapse all threads.
Definition: dlg_index.c:167
void mutt_flush_macro_to_endcond(void)
Drop a macro from the input buffer.
Definition: get.c:165
bool OptNeedResort
(pseudo) used to force a re-sort
Definition: globals.c:69
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:3256
#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:898
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:798
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:483
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:168
bool mutt_mailbox_notify(struct Mailbox *m_cur)
Notify the user if there's new mail.
Definition: mutt_mailbox.c:234
#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:344
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:297
@ WT_INDEX
A panel containing the Index Window.
Definition: mutt_window.h:97
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:101
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:1103
#define MUTT_MAILBOX_CHECK_NO_FLAGS
No flags are set.
Definition: mxapi.h:53
#define MUTT_MAILBOX_CHECK_FORCE
Ignore MailboxTime and check for new mail.
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:396
#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:51
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:495
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:127
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_mixmaster()

void dlg_mixmaster ( struct ListHead *  chainhead)

Create a Mixmaster chain -.

Parameters
chainheadList of chain links

The Mixmaster Dialogs allows the user to create a chain of anonymous remailers. The user can add/delete/reorder the hostss.

Definition at line 186 of file dlg_mixmaster.c.

187{
188 struct MixmasterPrivateData priv = { 0 };
189
190 struct RemailerArray ra = remailer_get_hosts();
191 if (ARRAY_EMPTY(&ra))
192 {
193 mutt_error(_("Can't get mixmaster's type2.list"));
194 return;
195 }
196
197 struct MuttWindow *dlg = mix_dlg_new(&priv, &ra);
198
199 win_chain_init(priv.win_chain, chainhead, &ra);
200 mutt_list_free(chainhead);
201
202 dialog_push(dlg);
203 struct MuttWindow *old_focus = window_set_focus(priv.win_hosts);
204
205 // ---------------------------------------------------------------------------
206 // Event Loop
207 int op = OP_NULL;
208 int rc = FR_UNKNOWN;
209 do
210 {
212 window_redraw(NULL);
213
215 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
216 if (op < 0)
217 continue;
218 if (op == OP_NULL)
219 {
221 continue;
222 }
224
225 rc = mix_function_dispatcher(dlg, op);
226
227 if (rc == FR_UNKNOWN)
228 rc = menu_function_dispatcher(priv.win_hosts, op);
229 if (rc == FR_UNKNOWN)
230 rc = global_function_dispatcher(NULL, op);
231 } while ((rc != FR_DONE) && (rc != FR_NO_ACTION));
232 // ---------------------------------------------------------------------------
233
234 /* construct the remailer list */
235 if (rc == FR_DONE)
236 win_chain_extract(priv.win_chain, chainhead);
237
238 window_set_focus(old_focus);
239 dialog_pop();
240 mutt_window_free(&dlg);
241
243}
@ FR_NO_ACTION
Valid function - no action performed.
Definition: dispatcher.h:37
static struct MuttWindow * mix_dlg_new(struct MixmasterPrivateData *priv, struct RemailerArray *ra)
Create a new Mixmaster Remailer Dialog.
int mix_function_dispatcher(struct MuttWindow *win, int op)
Perform a Mixmaster function - Implements function_dispatcher_t -.
Definition: functions.c:183
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:122
struct RemailerArray remailer_get_hosts(void)
Parse the type2.list as given by mixmaster -T.
Definition: remailer.c:114
void remailer_clear_hosts(struct RemailerArray *ra)
Clear a Remailer List.
Definition: remailer.c:205
Private state data for the Mixmaster.
Definition: private_data.h:30
struct MuttWindow * win_chain
Chain Window.
Definition: private_data.h:32
struct MuttWindow * win_hosts
Hosts Window.
Definition: private_data.h:31
@ MENU_MIXMASTER
Create/edit a Mixmaster chain.
Definition: type.h:53
int win_chain_extract(struct MuttWindow *win, struct ListHead *chain)
Extract the Chain list data.
Definition: win_chain.c:233
void win_chain_init(struct MuttWindow *win, struct ListHead *chain, struct RemailerArray *ra)
Initialise the Chain list Window.
Definition: win_chain.c:207
+ Here is the call graph for this function:
+ 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 637 of file dlg_gpgme.c.

639{
640 int keymax;
641 int i;
642 sort_t f = NULL;
643 enum MenuType menu_to_use = MENU_GENERIC;
644 bool unusable = false;
645
646 /* build the key table */
647 keymax = 0;
648 i = 0;
649 struct CryptKeyInfo **key_table = NULL;
650 const bool c_pgp_show_unusable = cs_subset_bool(NeoMutt->sub, "pgp_show_unusable");
651 for (struct CryptKeyInfo *k = keys; k; k = k->next)
652 {
653 if (!c_pgp_show_unusable && (k->flags & KEYFLAG_CANTUSE))
654 {
655 unusable = true;
656 continue;
657 }
658
659 if (i == keymax)
660 {
661 keymax += 20;
662 mutt_mem_realloc(&key_table, sizeof(struct CryptKeyInfo *) * keymax);
663 }
664
665 key_table[i++] = k;
666 }
667
668 if (!i && unusable)
669 {
670 mutt_error(_("All matching keys are marked expired/revoked"));
671 return NULL;
672 }
673
674 const short c_pgp_sort_keys = cs_subset_sort(NeoMutt->sub, "pgp_sort_keys");
675 switch (c_pgp_sort_keys & SORT_MASK)
676 {
677 case SORT_ADDRESS:
679 break;
680 case SORT_DATE:
681 f = crypt_sort_date;
682 break;
683 case SORT_KEYID:
685 break;
686 case SORT_TRUST:
687 default:
689 break;
690 }
691
692 if (key_table)
693 {
694 bool sort_reverse = c_pgp_sort_keys & SORT_REVERSE;
695 mutt_qsort_r(key_table, i, sizeof(struct CryptKeyInfo *), f, &sort_reverse);
696 }
697
698 if (app & APPLICATION_PGP)
699 menu_to_use = MENU_KEY_SELECT_PGP;
700 else if (app & APPLICATION_SMIME)
701 menu_to_use = MENU_KEY_SELECT_SMIME;
702
703 struct MuttWindow *dlg = simple_dialog_new(menu_to_use, WT_DLG_GPGME, GpgmeHelp);
704
705 struct Menu *menu = dlg->wdata;
706 menu->max = i;
708 menu->mdata = key_table;
710
711 struct GpgmeData gd = { false, menu, key_table, NULL, forced_valid };
712 dlg->wdata = &gd;
713
714 // NT_COLOR is handled by the SimpleDialog
717
718 const char *ts = NULL;
719
720 if ((app & APPLICATION_PGP) && (app & APPLICATION_SMIME))
721 ts = _("PGP and S/MIME keys matching");
722 else if ((app & APPLICATION_PGP))
723 ts = _("PGP keys matching");
724 else if ((app & APPLICATION_SMIME))
725 ts = _("S/MIME keys matching");
726 else
727 ts = _("keys matching");
728
729 char buf[1024] = { 0 };
730 if (p)
731 {
732 /* L10N: 1$s is one of the previous four entries.
733 %2$s is an address.
734 e.g. "S/MIME keys matching <john.doe@example.com>" */
735 snprintf(buf, sizeof(buf), _("%s <%s>"), ts, buf_string(p->mailbox));
736 }
737 else
738 {
739 /* L10N: e.g. 'S/MIME keys matching "John Doe".' */
740 snprintf(buf, sizeof(buf), _("%s \"%s\""), ts, s);
741 }
742
743 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
744 sbar_set_title(sbar, buf);
745
747
748 struct MuttWindow *old_focus = window_set_focus(menu->win);
749 // ---------------------------------------------------------------------------
750 // Event Loop
751 int op = OP_NULL;
752 do
753 {
754 menu_tagging_dispatcher(menu->win, op);
755 window_redraw(NULL);
756
757 op = km_dokey(menu_to_use, GETCH_NO_FLAGS);
758 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
759 if (op < 0)
760 continue;
761 if (op == OP_NULL)
762 {
763 km_error_key(menu_to_use);
764 continue;
765 }
767
768 int rc = gpgme_function_dispatcher(dlg, op);
769
770 if (rc == FR_UNKNOWN)
771 rc = menu_function_dispatcher(menu->win, op);
772 if (rc == FR_UNKNOWN)
773 rc = global_function_dispatcher(NULL, op);
774 } while (!gd.done);
775 // ---------------------------------------------------------------------------
776
777 window_set_focus(old_focus);
778 simple_dialog_free(&dlg);
779 return gd.key;
780}
static const struct Mapping GpgmeHelp[]
Help Bar for the GPGME key selection dialog.
Definition: dlg_gpgme.c:97
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:541
static void gpgme_key_table_free(struct Menu *menu, void **ptr)
Free the key table - Implements Menu::mdata_free() -.
Definition: dlg_gpgme.c:566
static int gpgme_key_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_gpgme.c:574
static int gpgme_key_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_gpgme.c:603
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:184
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:110
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:148
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:129
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:114
@ 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 629 of file dlg_pgp.c.

630{
631 struct PgpUid **key_table = NULL;
632 struct Menu *menu = NULL;
633 char buf[1024] = { 0 };
634 struct PgpUid *a = NULL;
635 bool unusable = false;
636 int keymax = 0;
637
638 const bool c_pgp_show_unusable = cs_subset_bool(NeoMutt->sub, "pgp_show_unusable");
639 int i = 0;
640 for (struct PgpKeyInfo *kp = keys; kp; kp = kp->next)
641 {
642 if (!c_pgp_show_unusable && (kp->flags & KEYFLAG_CANTUSE))
643 {
644 unusable = true;
645 continue;
646 }
647
648 for (a = kp->address; a; a = a->next)
649 {
650 if (!c_pgp_show_unusable && (a->flags & KEYFLAG_CANTUSE))
651 {
652 unusable = true;
653 continue;
654 }
655
656 if (i == keymax)
657 {
658 keymax += 5;
659 mutt_mem_realloc(&key_table, sizeof(struct PgpUid *) * keymax);
660 }
661
662 key_table[i++] = a;
663 }
664 }
665
666 if ((i == 0) && unusable)
667 {
668 mutt_error(_("All matching keys are expired, revoked, or disabled"));
669 return NULL;
670 }
671
672 sort_t f = NULL;
673 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 = pgp_sort_date;
681 break;
682 case SORT_KEYID:
683 f = pgp_sort_keyid;
684 break;
685 case SORT_TRUST:
686 default:
687 f = pgp_sort_trust;
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 PgpUid *), f, &sort_reverse);
695 }
696
698
699 menu = dlg->wdata;
700 menu->max = i;
702 menu->mdata = key_table;
704
705 struct PgpData pd = { false, menu, key_table, NULL };
706 dlg->wdata = &pd;
707
708 // NT_COLOR is handled by the SimpleDialog
711
712 if (p)
713 snprintf(buf, sizeof(buf), _("PGP keys matching <%s>"), buf_string(p->mailbox));
714 else
715 snprintf(buf, sizeof(buf), _("PGP keys matching \"%s\""), s);
716
717 struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
718 sbar_set_title(sbar, buf);
719
721
722 struct MuttWindow *old_focus = window_set_focus(menu->win);
723 // ---------------------------------------------------------------------------
724 // Event Loop
725 int op = OP_NULL;
726 do
727 {
728 menu_tagging_dispatcher(menu->win, op);
729 window_redraw(NULL);
730
732 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
733 if (op < 0)
734 continue;
735 if (op == OP_NULL)
736 {
738 continue;
739 }
741
742 int rc = pgp_function_dispatcher(dlg, op);
743
744 if (rc == FR_UNKNOWN)
745 rc = menu_function_dispatcher(menu->win, op);
746 if (rc == FR_UNKNOWN)
747 rc = global_function_dispatcher(NULL, op);
748 } while (!pd.done);
749 // ---------------------------------------------------------------------------
750
751 window_set_focus(old_focus);
752 simple_dialog_free(&dlg);
753 return pd.key;
754}
static const struct Mapping PgpHelp[]
Help Bar for the PGP key selection dialog.
Definition: dlg_pgp.c:95
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:535
static void pgp_key_table_free(struct Menu *menu, void **ptr)
Free the key table - Implements Menu::mdata_free() -.
Definition: dlg_pgp.c:560
static int pgp_key_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: dlg_pgp.c:597
static int pgp_key_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: dlg_pgp.c:568
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:168
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:149
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:130
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:111
@ 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:56
+ 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:92
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:59
+ 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 216 of file dlg_pager.c.

217{
218 //===========================================================================
219 // ACT 1 - Ensure sanity of the caller and determine the mode
220 //===========================================================================
221 assert(pview);
222 assert((pview->mode > PAGER_MODE_UNKNOWN) && (pview->mode < PAGER_MODE_MAX));
223 assert(pview->pdata); // view can't exist in a vacuum
224 assert(pview->win_pager);
225 assert(pview->win_pbar);
226
227 struct MuttWindow *dlg = dialog_find(pview->win_pager);
228 struct IndexSharedData *shared = dlg->wdata;
229 struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
230
231 switch (pview->mode)
232 {
233 case PAGER_MODE_EMAIL:
234 // This case was previously identified by IsEmail macro
235 // we expect data to contain email and not contain body
236 // We also expect email to always belong to some mailbox
237 assert(shared->mailbox_view);
238 assert(shared->mailbox);
239 assert(shared->email);
240 assert(!pview->pdata->body);
241 break;
242
244 // this case was previously identified by IsAttach and IsMsgAttach
245 // macros, we expect data to contain:
246 // - body (viewing regular attachment)
247 // - fp and body->email in special case of viewing an attached email.
248 assert(pview->pdata->body);
249 if (pview->pdata->fp && pview->pdata->body->email)
250 {
251 // Special case: attachment is a full-blown email message.
252 // Yes, emails can contain other emails.
253 pview->mode = PAGER_MODE_ATTACH_E;
254 }
255 break;
256
257 case PAGER_MODE_HELP:
258 case PAGER_MODE_OTHER:
259 assert(!shared->mailbox_view);
260 assert(!shared->email);
261 assert(!pview->pdata->body);
262 break;
263
265 case PAGER_MODE_MAX:
266 default:
267 // Unexpected mode. Catch fire and explode.
268 // This *should* happen if mode is PAGER_MODE_ATTACH_E, since
269 // we do not expect any caller to pass it to us.
270 assert(false);
271 break;
272 }
273
274 //===========================================================================
275 // ACT 2 - Declare, initialize local variables, read config, etc.
276 //===========================================================================
277
278 //---------- local variables ------------------------------------------------
279 int op = 0;
280 enum MailboxType mailbox_type = shared->mailbox ? shared->mailbox->type : MUTT_UNKNOWN;
281 struct PagerPrivateData *priv = pview->win_pager->parent->wdata;
282 priv->rc = -1;
283 priv->searchctx = 0;
284 priv->first = true;
285 priv->wrapped = false;
286 priv->delay_read_timestamp = 0;
287 priv->pager_redraw = false;
288
289 // Wipe any previous state info
290 struct Notify *notify = priv->notify;
291 int prc = priv->rc;
292 memset(priv, 0, sizeof(*priv));
293 priv->rc = prc;
294 priv->notify = notify;
295 TAILQ_INIT(&priv->ansi_list);
296
297 //---------- setup flags ----------------------------------------------------
298 if (!(pview->flags & MUTT_SHOWCOLOR))
299 pview->flags |= MUTT_SHOWFLAT;
300
301 if ((pview->mode == PAGER_MODE_EMAIL) && !shared->email->read)
302 {
303 if (shared->mailbox_view)
304 shared->mailbox_view->msg_in_pager = shared->email->msgno;
305 const short c_pager_read_delay = cs_subset_number(NeoMutt->sub, "pager_read_delay");
306 if (c_pager_read_delay == 0)
307 {
308 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
309 }
310 else
311 {
312 priv->delay_read_timestamp = mutt_date_now_ms() + (1000 * c_pager_read_delay);
313 }
314 }
315 //---------- setup help menu ------------------------------------------------
316 pview->win_pager->help_data = pager_resolve_help_mapping(pview->mode, mailbox_type);
318
319 //---------- initialize redraw pdata -----------------------------------------
321 priv->lines_max = LINES; // number of lines on screen, from curses
322 priv->lines = mutt_mem_calloc(priv->lines_max, sizeof(struct Line));
323 priv->fp = mutt_file_fopen(pview->pdata->fname, "r");
324 priv->has_types = ((pview->mode == PAGER_MODE_EMAIL) || (pview->flags & MUTT_SHOWCOLOR)) ?
325 MUTT_TYPES :
326 0; // main message or rfc822 attachment
327
328 for (size_t i = 0; i < priv->lines_max; i++)
329 {
330 priv->lines[i].cid = -1;
331 priv->lines[i].search_arr_size = -1;
332 priv->lines[i].syntax = mutt_mem_calloc(1, sizeof(struct TextSyntax));
333 (priv->lines[i].syntax)[0].first = -1;
334 (priv->lines[i].syntax)[0].last = -1;
335 }
336
337 // ---------- try to open the pdata file -------------------------------------
338 if (!priv->fp)
339 {
340 mutt_perror("%s", pview->pdata->fname);
341 return -1;
342 }
343
344 if (stat(pview->pdata->fname, &priv->st) != 0)
345 {
346 mutt_perror("%s", pview->pdata->fname);
347 mutt_file_fclose(&priv->fp);
348 return -1;
349 }
350 unlink(pview->pdata->fname);
351 priv->pview = pview;
352
353 //---------- show windows, set focus and visibility --------------------------
354 window_set_visible(pview->win_pager->parent, true);
357
358 struct MuttWindow *old_focus = window_set_focus(pview->win_pager);
359
360 //---------- jump to the bottom if requested ------------------------------
361 if (pview->flags & MUTT_PAGER_BOTTOM)
362 {
363 jump_to_bottom(priv, pview);
364 }
365
366 //-------------------------------------------------------------------------
367 // ACT 3: Read user input and decide what to do with it
368 // ...but also do a whole lot of other things.
369 //-------------------------------------------------------------------------
370
371 // Force an initial paint, which will populate priv->lines
373 window_redraw(NULL);
374
376 do
377 {
380 window_redraw(NULL);
381
382 const bool c_braille_friendly = cs_subset_bool(NeoMutt->sub, "braille_friendly");
383 if (c_braille_friendly)
384 {
385 if (BrailleRow != -1)
386 {
388 BrailleRow = -1;
389 }
390 }
391 else
392 {
393 mutt_window_move(priv->pview->win_pbar, priv->pview->win_pager->state.cols - 1, 0);
394 }
395
396 // force redraw of the screen at every iteration of the event loop
397 mutt_refresh();
398
399 //-------------------------------------------------------------------------
400 // Check if information in the status bar needs an update
401 // This is done because pager is a single-threaded application, which
402 // tries to emulate concurrency.
403 //-------------------------------------------------------------------------
404 bool do_new_mail = false;
405 if (shared->mailbox && !shared->attach_msg)
406 {
407 int oldcount = shared->mailbox->msg_count;
408 /* check for new mail */
409 enum MxStatus check = mx_mbox_check(shared->mailbox);
410 if (check == MX_STATUS_ERROR)
411 {
412 if (!shared->mailbox || buf_is_empty(&shared->mailbox->pathbuf))
413 {
414 /* fatal error occurred */
416 break;
417 }
418 }
419 else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
420 (check == MX_STATUS_FLAGS))
421 {
422 /* notify user of newly arrived mail */
423 if (check == MX_STATUS_NEW_MAIL)
424 {
425 for (size_t i = oldcount; i < shared->mailbox->msg_count; i++)
426 {
427 struct Email *e = shared->mailbox->emails[i];
428
429 if (e && !e->read)
430 {
431 mutt_message(_("New mail in this mailbox"));
432 do_new_mail = true;
433 break;
434 }
435 }
436 }
437
438 if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
439 {
442 }
443 }
444
445 if (mutt_mailbox_notify(shared->mailbox) || do_new_mail)
446 {
447 const bool c_beep_new = cs_subset_bool(NeoMutt->sub, "beep_new");
448 if (c_beep_new)
449 mutt_beep(true);
450 const struct Expando *c_new_mail_command = cs_subset_expando(NeoMutt->sub, "new_mail_command");
451 if (c_new_mail_command)
452 {
453 struct Buffer *cmd = buf_pool_get();
454 menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
455 if (mutt_system(buf_string(cmd)) != 0)
456 mutt_error(_("Error running \"%s\""), buf_string(cmd));
457 buf_pool_release(&cmd);
458 }
459 }
460 }
461 //-------------------------------------------------------------------------
462
463 if (priv->pager_redraw)
464 {
465 priv->pager_redraw = false;
467 clearok(stdscr, true); /* force complete redraw */
468 msgwin_clear_text(NULL);
469
471 if (pview->flags & MUTT_PAGER_RETWINCH)
472 {
473 /* Store current position. */
474 priv->win_height = -1;
475 for (size_t i = 0; i <= priv->top_line; i++)
476 if (!priv->lines[i].cont_line)
477 priv->win_height++;
478
479 op = OP_ABORT;
480 priv->rc = OP_REFORMAT_WINCH;
481 break;
482 }
483 else
484 {
485 /* note: mutt_resize_screen() -> mutt_window_reflow() sets
486 * PAGER_REDRAW_PAGER and PAGER_REDRAW_FLOW */
487 op = OP_NULL;
488 }
489 continue;
490 }
491
492 dump_pager(priv);
493
494 //-------------------------------------------------------------------------
495 // Finally, read user's key press
496 //-------------------------------------------------------------------------
497 // km_dokey() reads not only user's key strokes, but also a MacroBuffer
498 // MacroBuffer may contain OP codes of the operations.
499 // MacroBuffer is global
500 // OP codes inserted into the MacroBuffer by various functions.
501 // One of such functions is `mutt_enter_command()`
502 // Some OP codes are not handled by pager, they cause pager to quit returning
503 // OP code to index. Index handles the operation and then restarts pager
505
506 // km_dokey() can block, so recheck the timer.
507 // Note: This check must occur before handling the operations of the index
508 // as those can change the currently selected message/entry yielding to
509 // marking the wrong message as read.
511 {
512 mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
513 }
514
515 if (SigWinch)
516 priv->pager_redraw = true;
517
518 if (op >= OP_NULL)
520
521 mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
522
523 if (op < OP_NULL)
524 {
525 op = OP_NULL;
526 continue;
527 }
528
529 if (op == OP_NULL)
530 {
532 continue;
533 }
534
535 int rc = pager_function_dispatcher(priv->pview->win_pager, op);
536
537 if (pview->mode == PAGER_MODE_EMAIL)
538 {
539 if ((rc == FR_UNKNOWN) && priv->pview->win_index)
541 if (rc == FR_UNKNOWN)
542 rc = sb_function_dispatcher(win_sidebar, op);
543 }
544 if (rc == FR_UNKNOWN)
545 rc = global_function_dispatcher(NULL, op);
546
547 if ((rc == FR_UNKNOWN) &&
548 ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
549 {
550 // Some attachment functions still need to be delegated
551 priv->rc = op;
552 break;
553 }
554
555 if ((pview->mode != PAGER_MODE_EMAIL) && (rc == FR_UNKNOWN))
557
558 } while (priv->loop == PAGER_LOOP_CONTINUE);
559 window_set_focus(old_focus);
560
561 //-------------------------------------------------------------------------
562 // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
563 //-------------------------------------------------------------------------
564
565 mutt_file_fclose(&priv->fp);
566 if (pview->mode == PAGER_MODE_EMAIL)
567 {
568 if (shared->mailbox_view)
569 shared->mailbox_view->msg_in_pager = -1;
570 }
571
573
574 for (size_t i = 0; i < priv->lines_max; i++)
575 {
576 FREE(&(priv->lines[i].syntax));
577 if (priv->search_compiled && priv->lines[i].search)
578 FREE(&(priv->lines[i].search));
579 }
580 if (priv->search_compiled)
581 {
582 regfree(&priv->search_re);
583 priv->search_compiled = false;
584 }
585 FREE(&priv->lines);
587 {
588 struct AttrColor *ac = NULL;
589 int count = 0;
590 TAILQ_FOREACH(ac, &priv->ansi_list, entries)
591 {
592 count++;
593 }
594 color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
595 }
596
597 priv->pview = NULL;
598
599 if (priv->loop == PAGER_LOOP_RELOAD)
600 return PAGER_LOOP_RELOAD;
601
602 return (priv->rc != -1) ? priv->rc : 0;
603}
void attr_color_list_clear(struct AttrColorList *acl)
Free the contents of an AttrColorList.
Definition: attr.c:118
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:144
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:57
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:68
int BrailleCol
Braille display: column to leave the cursor.
Definition: dlg_pager.c:70
static bool check_read_delay(uint64_t *timestamp)
Is it time to mark the message read?
Definition: dlg_pager.c:177
void pager_queue_redraw(struct PagerPrivateData *priv, PagerRedrawFlags redraw)
Queue a request for a redraw.
Definition: dlg_pager.c:128
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:140
#define mutt_file_fclose(FP)
Definition: file.h:147
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:146
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:50
#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:464
@ 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:75
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:165
void window_invalidate_all(void)
Mark all windows as in need of repaint.
Definition: mutt_window.c:767
@ 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
volatile sig_atomic_t SigWinch
true after SIGWINCH is received
Definition: signal.c:64
A curses colour and its attributes.
Definition: attr.h:66
struct Email * email
header information for message/rfc822
Definition: body.h:73
int msgno
Number displayed to the user.
Definition: email.h:114
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:135
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:131
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:55
+ 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:57
+ Here is the call graph for this function:
+ Here is the caller graph for this function: