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 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 StringArray *carr, bool allow_always, bool allow_skip)
	Ask the user to validate the certificate -.
void	dlg_history (struct Buffer *buf, struct StringArray *matches)
	Select an item from a history list -.
struct Mailbox *	dlg_index (struct MuttWindow *dlg, struct Mailbox *m_init)
	Display a list of emails -.
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 -.
struct PgpKeyInfo *	dlg_pgp (struct PgpKeyInfo *keys, struct Address *p, const char *s)
	Let the user select a key to use -.
struct SmimeKey *	dlg_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 (struct Buffer *buf)
	Show menu to select a Pattern -.
struct Email *	dlg_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

• Root Window

Children

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

• Address Book Dialog
• Compose Email Dialog
• GPGME Key Selection Dialog
• ...

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 AliasMenuData * mdata )

static

Display a menu of Aliases -.

Parameters

mdata

Menu data holding Aliases

Return values

true	Selection was made

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

Definition at line 266 of file dlg_alias.c.

{
  if (ARRAY_EMPTY(&mdata->ava))
  {
    mutt_warning(_("You have no aliases"));
    return false;
  }
 
  mdata->title = mutt_str_dup(_("Aliases"));
 
  struct SimpleDialogWindows sdw = alias_dialog_new(mdata);
  struct Menu *menu = sdw.menu;
  mdata->menu = menu;
  mdata->sbar = sdw.sbar;
 
  alias_array_sort(&mdata->ava, mdata->sub);
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata->ava)
  {
    avp->num = ARRAY_FOREACH_IDX_avp;
  }
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int rc = 0;
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_ALIAS, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_ALIAS);
      continue;
    }
    mutt_clear_error();
 
    rc = alias_function_dispatcher(sdw.dlg, &event);
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while ((rc != FR_DONE) && (rc != FR_CONTINUE));
  // ---------------------------------------------------------------------------
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  window_redraw(NULL);
  return (rc == FR_CONTINUE); // Was a selection made?
}

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

buf	Buffer for the query
mdata	Menu data holding Aliases

Return values

true	Selection 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 346 of file dlg_query.c.

{
  struct SimpleDialogWindows sdw = query_dialog_new(mdata, buf_string(buf));
  struct Menu *menu = sdw.menu;
  mdata->menu = menu;
  mdata->sbar = sdw.sbar;
  mdata->query = buf;
 
  alias_array_sort(&mdata->ava, mdata->sub);
 
  struct AliasView *avp = NULL;
  ARRAY_FOREACH(avp, &mdata->ava)
  {
    avp->num = ARRAY_FOREACH_IDX_avp;
  }
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int rc = 0;
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_QUERY, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_QUERY);
      continue;
    }
    mutt_clear_error();
 
    rc = alias_function_dispatcher(sdw.dlg, &event);
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while ((rc != FR_DONE) && (rc != FR_CONTINUE));
  // ---------------------------------------------------------------------------
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  window_redraw(NULL);
  return (rc == FR_CONTINUE); // Was a selection made?
}

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

sub	Config Subset
mv	Mailbox view
e	Email
fp	File with the content of the email, or NULL
attach_msg	Are 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 207 of file dlg_attach.c.

{
  if (!mv || !mv->mailbox || !e || !fp)
    return;
 
  struct Mailbox *m = mv->mailbox;
 
  /* make sure we have parsed this message */
  mutt_parse_mime_message(e, fp);
  mutt_message_hook(m, e, CMD_MESSAGE_HOOK);
 
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_ATTACHMENT, WT_DLG_ATTACHMENT,
                                                     AttachmentHelp);
  struct Menu *menu = sdw.menu;
  menu->make_entry = attach_make_entry;
  menu->tag = attach_tag;
 
  struct AttachCtx *actx = mutt_actx_new();
  actx->email = e;
  actx->fp_root = fp;
  mutt_update_recvattach_menu(actx, menu, true);
 
  struct AttachPrivateData *priv = attach_private_data_new();
  priv->menu = menu;
  priv->actx = actx;
  priv->sub = sub;
  priv->mailbox = m;
  priv->attach_msg = attach_msg;
  menu->mdata = priv;
  menu->mdata_free = attach_private_data_free;
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, attach_config_observer, menu);
  notify_observer_add(menu->win->notify, NT_WINDOW, attach_window_observer, menu->win);
 
  sbar_set_title(sdw.sbar, _("Attachments"));
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int rc = 0;
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_ATTACHMENT, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_ATTACHMENT);
      continue;
    }
    mutt_clear_error();
 
    rc = attach_function_dispatcher(sdw.dlg, &event);
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
 
    if (rc == FR_CONTINUE)
    {
      event.op = priv->op;
    }
 
  } while (rc != FR_DONE);
  // ---------------------------------------------------------------------------
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
}

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 240 of file dlg_autocrypt.c.

{
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt)
    return;
 
  if (mutt_autocrypt_init(false))
    return;
 
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_AUTOCRYPT, WT_DLG_AUTOCRYPT,
                                                     AutocryptHelp);
 
  struct Menu *menu = sdw.menu;
 
  struct AutocryptData *ad = autocrypt_data_new();
  ad->menu = menu;
 
  menu->make_entry = autocrypt_make_entry;
  menu->mdata = ad;
  menu->mdata_free = autocrypt_data_free;
 
  populate_menu(menu);
 
  // L10N: Autocrypt Account Management Menu title
  sbar_set_title(sdw.sbar, _("Autocrypt Accounts"));
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, autocrypt_config_observer, menu);
  notify_observer_add(menu->win->notify, NT_WINDOW, autocrypt_window_observer, menu->win);
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_AUTOCRYPT, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_AUTOCRYPT);
      continue;
    }
    mutt_clear_error();
 
    int rc = autocrypt_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!ad->done);
  // ---------------------------------------------------------------------------
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
}

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]	file	Buffer for the result
[in]	flags	Flags, see SelectFileFlags
[in]	m	Mailbox
[out]	files	Array of selected files
[out]	numfiles	Number 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 850 of file dlg_browser.c.

{
  struct BrowserPrivateData *priv = browser_private_data_new();
  priv->file = file;
  priv->mailbox = m;
  priv->files = files;
  priv->numfiles = numfiles;
  priv->multiple = (flags & MUTT_SEL_MULTI);
  priv->folder = (flags & MUTT_SEL_FOLDER);
  priv->state.is_mailbox_list = (flags & MUTT_SEL_MAILBOX) && priv->folder;
  priv->last_selected_mailbox = -1;
 
  init_lastdir();
 
  if (OptNews)
  {
    if (buf_is_empty(file))
    {
      struct NntpAccountData *adata = CurrentNewsSrv;
 
      /* default state for news reader mode is browse subscribed newsgroups */
      priv->state.is_mailbox_list = false;
      for (size_t i = 0; i < adata->groups_num; i++)
      {
        struct NntpMboxData *mdata = adata->groups_list[i];
        if (mdata && mdata->subscribed)
        {
          priv->state.is_mailbox_list = true;
          break;
        }
      }
    }
    else
    {
      buf_copy(priv->prefix, file);
    }
  }
  else if (!buf_is_empty(file))
  {
    buf_expand_path(file);
    if (imap_path_probe(buf_string(file), NULL) == MUTT_IMAP)
    {
      init_state(&priv->state);
      priv->state.imap_browse = true;
      if (imap_browse(buf_string(file), &priv->state) == 0)
      {
        buf_strcpy(&LastDir, priv->state.folder);
        browser_sort(&priv->state);
      }
    }
    else
    {
      int i = buf_len(file);
      i--;
      for (; (i > 0) && ((buf_string(file))[i] != '/'); i--)
      {
        ; // do nothing
      }
 
      if (i > 0)
      {
        if ((buf_string(file))[0] == '/')
        {
          buf_strcpy_n(&LastDir, buf_string(file), i);
        }
        else
        {
          mutt_path_getcwd(&LastDir);
          buf_addch(&LastDir, '/');
          buf_addstr_n(&LastDir, buf_string(file), i);
        }
      }
      else
      {
        if ((buf_string(file))[0] == '/')
          buf_strcpy(&LastDir, "/");
        else
          mutt_path_getcwd(&LastDir);
      }
 
      if ((i <= 0) && (buf_string(file)[0] != '/'))
        buf_copy(priv->prefix, file);
      else
        buf_strcpy(priv->prefix, buf_string(file) + i + 1);
      priv->kill_prefix = true;
    }
  }
  else
  {
    if (priv->folder)
    {
      /* Whether we use the tracking feature of the browser depends
       * on which sort method we chose to use. This variable is defined
       * only to help readability of the code.  */
      bool browser_track = false;
 
      const enum EmailSortType c_browser_sort = cs_subset_sort(NeoMutt->sub, "browser_sort");
      switch (c_browser_sort & SORT_MASK)
      {
        case BROWSER_SORT_ALPHA:
        case BROWSER_SORT_DESC:
        case BROWSER_SORT_UNSORTED:
          browser_track = true;
          break;
      }
 
      /* We use mutt_browser_select_dir to initialize the two
       * variables (LastDir, LastDirBackup) at the appropriate
       * values.
       *
       * We do it only when LastDir is not set (first pass there)
       * or when CurrentFolder and LastDirBackup are not the same.
       * This code is executed only when we list files, not when
       * we press up/down keys to navigate in a displayed list.
       *
       * We only do this when CurrentFolder has been set (ie, not
       * when listing folders on startup with "neomutt -y").
       *
       * This tracker is only used when browser_track is true,
       * meaning only with sort methods SUBJECT/DESC for now.  */
      if (CurrentFolder)
      {
        if (buf_is_empty(&LastDir))
        {
          /* If browsing in "local"-mode, than we chose to define LastDir to
           * MailDir */
          switch (mx_path_probe(CurrentFolder))
          {
            case MUTT_IMAP:
            case MUTT_MAILDIR:
            case MUTT_MBOX:
            case MUTT_MH:
            case MUTT_MMDF:
            {
              const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
              const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
              if (c_folder)
                buf_strcpy(&LastDir, c_folder);
              else if (c_spool_file)
                mutt_browser_select_dir(c_spool_file);
              break;
            }
            default:
              mutt_browser_select_dir(CurrentFolder);
              break;
          }
        }
        else if (!mutt_str_equal(CurrentFolder, buf_string(&LastDirBackup)))
        {
          mutt_browser_select_dir(CurrentFolder);
        }
      }
 
      /* When browser tracking feature is disabled, clear LastDirBackup */
      if (!browser_track)
        buf_reset(&LastDirBackup);
    }
    else
    {
      mutt_path_getcwd(&LastDir);
    }
 
    if (!priv->state.is_mailbox_list &&
        (imap_path_probe(buf_string(&LastDir), NULL) == MUTT_IMAP))
    {
      init_state(&priv->state);
      priv->state.imap_browse = true;
      imap_browse(buf_string(&LastDir), &priv->state);
      browser_sort(&priv->state);
    }
    else
    {
      size_t i = buf_len(&LastDir);
      while ((i > 0) && (buf_string(&LastDir)[--i] == '/'))
        LastDir.data[i] = '\0';
      buf_fix_dptr(&LastDir);
      if (buf_is_empty(&LastDir))
        mutt_path_getcwd(&LastDir);
    }
  }
 
  buf_reset(file);
 
  const struct Mapping *help_data = NULL;
 
  if (OptNews)
    help_data = FolderNewsHelp;
  else
    help_data = FolderHelp;
 
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_BROWSER, WT_DLG_BROWSER, help_data);
 
  struct Menu *menu = sdw.menu;
  menu->make_entry = folder_make_entry;
  menu->search = select_file_search;
  menu->mdata = priv;
 
  priv->menu = menu;
  if (priv->multiple)
    priv->menu->tag = file_tag;
 
  priv->sbar = sdw.sbar;
 
  struct MuttWindow *win_menu = priv->menu->win;
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, browser_config_observer, priv);
  notify_observer_add(win_menu->notify, NT_WINDOW, browser_window_observer, priv);
  notify_observer_add(NeoMutt->notify, NT_MAILBOX, browser_mailbox_observer, priv);
 
  struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
 
  if (priv->state.is_mailbox_list)
  {
    examine_mailboxes(m, NULL, &priv->state);
  }
  else if (!priv->state.imap_browse)
  {
    // examine_directory() calls browser_add_folder() which needs the menu
    if (examine_directory(m, priv->menu, &priv->state, buf_string(&LastDir),
                          buf_string(priv->prefix)) == -1)
    {
      goto bail;
    }
  }
 
  init_menu(&priv->state, priv->menu, m, priv->sbar);
 
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(priv->menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_BROWSER, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_BROWSER);
      continue;
    }
    mutt_clear_error();
 
    int rc = browser_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!priv->done);
  // ---------------------------------------------------------------------------
 
bail:
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  browser_private_data_free(&priv);
}

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

e	Email to fill
fcc	Buffer to save FCC
flags	Flags, e.g. MUTT_COMPOSE_NOFREEHEADER
sub	ConfigSubset

Return values

1	Message should be postponed
0	Normal exit
-1	Abort message

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

Definition at line 403 of file dlg_compose.c.

{
  struct MuttWindow *dlg = compose_dlg_init(sub, e, fcc);
  struct ComposeSharedData *shared = dlg->wdata;
  shared->mailbox = get_current_mailbox();
  shared->email = e;
  shared->sub = sub;
  shared->fcc = fcc;
  shared->fcc_set = false;
  shared->flags = flags;
  shared->rc = -1;
 
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, compose_config_observer, dlg);
  notify_observer_add(e->notify, NT_ENVELOPE, compose_email_observer, shared);
  notify_observer_add(dlg->notify, NT_WINDOW, compose_window_observer, dlg);
 
  if (OptNewsSend)
    dlg->help_data = ComposeNewsHelp;
  else
    dlg->help_data = ComposeHelp;
  dlg->help_menu = MENU_COMPOSE;
 
  struct Menu *menu = shared->adata->menu;
  update_menu(shared->adata->actx, menu, true);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE, NULL);
 
  struct MuttWindow *win_env = window_find_child(dlg, WT_CUSTOM);
 
  dialog_push(dlg);
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int rc = 0;
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    OptNews = false; /* for any case */
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_COMPOSE, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_COMPOSE);
      continue;
    }
    mutt_clear_error();
 
    rc = compose_function_dispatcher(dlg, &event);
    if (rc == FR_UNKNOWN)
      rc = env_function_dispatcher(win_env, &event);
    if (rc == FR_UNKNOWN)
      rc = preview_function_dispatcher(shared->win_preview, &event);
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (rc != FR_DONE);
  // ---------------------------------------------------------------------------
 
#ifdef USE_AUTOCRYPT
  /* This is a fail-safe to make sure the bit isn't somehow turned
   * on.  The user could have disabled the option after setting SEC_AUTOCRYPT,
   * or perhaps resuming or replying to an autocrypt message.  */
  const bool c_autocrypt = cs_subset_bool(sub, "autocrypt");
  if (!c_autocrypt)
    e->security &= ~SEC_AUTOCRYPT;
#endif
 
  if (shared->adata->actx->idxlen)
    e->body = shared->adata->actx->idx[0]->body;
  else
    e->body = NULL;
 
  rc = shared->rc;
 
  window_set_focus(old_focus);
  dialog_pop();
  mutt_window_free(&dlg);
 
  return rc;
}

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 StringArray *	carr,
		bool	allow_always,
		bool	allow_skip )

Ask the user to validate the certificate -.

Parameters

title	Menu title
carr	Certificate text to display
allow_always	If true, allow the user to always accept the certificate
allow_skip	If true, allow the user to skip the verification

Return values

1	Reject certificate (or menu aborted)
2	Accept certificate once
3	Accept certificate always/skip (see notes)
4	Accept 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 166 of file dlg_verifycert.c.

{
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_GENERIC, WT_DLG_CERTIFICATE, VerifyHelp);
 
  struct CertMenuData mdata = { carr };
 
  struct Menu *menu = sdw.menu;
  menu->mdata = &mdata;
  menu->mdata_free = NULL; // Menu doesn't own the data
  menu->make_entry = cert_make_entry;
  menu->max = ARRAY_SIZE(carr);
  menu->show_indicator = false;
 
  sbar_set_title(sdw.sbar, title);
 
  if (allow_always)
  {
    if (allow_skip)
    {
      mdata.prompt = _("(r)eject, accept (o)nce, (a)ccept always, (s)kip");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce, (a)ccept always, (s)kip"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("roas");
    }
    else
    {
      mdata.prompt = _("(r)eject, accept (o)nce, (a)ccept always");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce, (a)ccept always"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("roa");
    }
  }
  else
  {
    if (allow_skip)
    {
      mdata.prompt = _("(r)eject, accept (o)nce, (s)kip");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce, (s)kip"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("ros");
    }
    else
    {
      mdata.prompt = _("(r)eject, accept (o)nce");
      /* L10N: The letters correspond to the choices in the string:
         "(r)eject, accept (o)nce"
         This is an interactive certificate confirmation prompt for an SSL connection. */
      mdata.keys = _("ro");
    }
  }
  msgwin_set_text(NULL, mdata.prompt, MT_COLOR_PROMPT);
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int choice = 0;
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    window_redraw(NULL);
    msgwin_set_text(NULL, mdata.prompt, MT_COLOR_PROMPT);
 
    // Try to catch dialog keys before ops
    if (menu_dialog_dokey(menu, &op) != 0)
    {
      event = km_dokey(MENU_DIALOG, GETCH_IGNORE_MACRO);
      op = event.op;
    }
 
    if (op == OP_TIMEOUT)
      continue;
 
    // Convert menubar movement to scrolling
    op = menu_dialog_translate_op(op);
 
    if (op <= OP_MAX)
      mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    else
      mutt_debug(LL_DEBUG1, "Got choice %d\n", op - OP_MAX);
 
    switch (op)
    {
      case OP_ABORT:   // Abort: Ctrl-G
      case OP_QUIT:    // Q)uit
      case OP_MAX + 1: // R)eject
        choice = 1;
        break;
      case OP_MAX + 2: // O)nce
        choice = 2;
        break;
      case OP_MAX + 3: // A)lways / S)kip
        choice = 3;
        break;
      case OP_MAX + 4: // S)kip
        choice = 4;
        break;
 
      case OP_JUMP:
      case OP_JUMP_1:
      case OP_JUMP_2:
      case OP_JUMP_3:
      case OP_JUMP_4:
      case OP_JUMP_5:
      case OP_JUMP_6:
      case OP_JUMP_7:
      case OP_JUMP_8:
      case OP_JUMP_9:
        mutt_error(_("Jumping is not implemented for dialogs"));
        continue;
 
      case OP_SEARCH:
      case OP_SEARCH_NEXT:
      case OP_SEARCH_OPPOSITE:
      case OP_SEARCH_REVERSE:
        mutt_error(_("Search is not implemented for this menu"));
        continue;
    }
 
    (void) menu_function_dispatcher(menu->win, &event);
  } while (choice == 0);
  // ---------------------------------------------------------------------------
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
 
  return choice;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dlg_history()

void dlg_history	(	struct Buffer *	buf,
		struct StringArray *	matches )

Select an item from a history list -.

Parameters

[in]	buf	Buffer in which to save string
[out]	matches	Items to choose from

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

Definition at line 119 of file dlg_history.c.

{
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_DIALOG, WT_DLG_HISTORY, HistoryHelp);
  struct Menu *menu = sdw.menu;
 
  struct HistoryData hd = { false, false, buf, menu, matches };
 
  char title[256] = { 0 };
  snprintf(title, sizeof(title), _("History '%s'"), buf_string(buf));
  sbar_set_title(sdw.sbar, title);
 
  menu->make_entry = history_make_entry;
  menu->max = ARRAY_SIZE(matches);
  menu->mdata = &hd;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_DIALOG, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_GENERIC);
      continue;
    }
    mutt_clear_error();
 
    int rc = history_function_dispatcher(sdw.dlg, &event);
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!hd.done);
  // ---------------------------------------------------------------------------
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
}

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

dlg	Dialog containing Windows to draw on
m_init	Initial mailbox

Return values

ptr	Mailbox 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 1097 of file dlg_index.c.

{
  /* Make sure use_threads/sort/sort_aux are coherent */
  index_adjust_sort_threads(NeoMutt->sub);
 
  struct IndexSharedData *shared = dlg->wdata;
  index_shared_data_set_mview(shared, mview_new(m_init, NeoMutt->notify));
 
  struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
 
  struct IndexPrivateData *priv = panel_index->wdata;
  priv->win_index = window_find_child(panel_index, WT_MENU);
 
  int op = OP_NULL;
 
  if (shared->mailbox && (shared->mailbox->type == MUTT_NNTP))
    dlg->help_data = IndexNewsHelp;
  else
    dlg->help_data = IndexHelp;
  dlg->help_menu = MENU_INDEX;
 
  priv->menu = priv->win_index->wdata;
  priv->menu->make_entry = index_make_entry;
  priv->menu->color = index_color;
  priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
  menu_set_index(priv->menu, find_first_message(shared->mailbox_view));
 
  struct MuttWindow *old_focus = window_set_focus(priv->menu->win);
  mutt_window_reflow(NULL);
 
  if (!shared->attach_msg)
  {
    /* force the mailbox check after we enter the folder */
    mutt_mailbox_check(shared->mailbox, MUTT_MAILBOX_CHECK_POSTPONED);
  }
#ifdef USE_INOTIFY
  mutt_monitor_add(NULL);
#endif
 
  const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
  if (mutt_using_threads() && c_collapse_all)
  {
    collapse_all(shared->mailbox_view, priv->menu, 0);
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
 
  int rc = 0;
  do
  {
    /* Clear the tag prefix unless we just started it.
     * Don't clear the prefix on a timeout, but do clear on an abort */
    if (priv->tag_prefix && (op != OP_TAG_PREFIX) &&
        (op != OP_TAG_PREFIX_COND) && (op != OP_TIMEOUT))
    {
      priv->tag_prefix = false;
    }
 
    /* check if we need to resort the index because just about
     * any 'op' below could do mutt_enter_command(), either here or
     * from any new priv->menu launched, and change $sort/$sort_aux */
    if (OptNeedResort && shared->mailbox && (shared->mailbox->msg_count != 0) &&
        (menu_get_index(priv->menu) >= 0))
    {
      resort_index(shared->mailbox_view, priv->menu);
    }
 
    priv->menu->max = shared->mailbox ? shared->mailbox->vcount : 0;
    priv->oldcount = shared->mailbox ? shared->mailbox->msg_count : 0;
 
    if (shared->mailbox && shared->mailbox_view)
    {
      mailbox_gc_run();
 
      shared->mailbox_view->menu = priv->menu;
      /* check for new mail in the mailbox.  If nonzero, then something has
       * changed about the file (either we got new mail or the file was
       * modified underneath us.) */
      enum MxStatus check = mx_mbox_check(shared->mailbox);
 
      if (check == MX_STATUS_ERROR)
      {
        if (buf_is_empty(&shared->mailbox->pathbuf))
        {
          /* fatal error occurred */
          mview_free(&shared->mailbox_view);
          menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
        }
 
        mutt_pattern_free(&shared->search_state->pattern);
      }
      else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
               (check == MX_STATUS_FLAGS))
      {
        /* notify the user of new mail */
        if (check == MX_STATUS_REOPENED)
        {
          mutt_error(_("Mailbox was externally modified.  Flags may be wrong."));
        }
        else if (check == MX_STATUS_NEW_MAIL)
        {
          for (size_t i = 0; i < shared->mailbox->msg_count; i++)
          {
            const struct Email *e = shared->mailbox->emails[i];
            if (e && !e->read && !e->old)
            {
              mutt_message(_("New mail in this mailbox"));
              const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
              if (c_beep_new)
                mutt_beep(true);
              const struct Expando *c_new_mail_command =
                  cs_subset_expando(shared->sub, "new_mail_command");
              if (c_new_mail_command)
              {
                struct Buffer *cmd = buf_pool_get();
                menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
                if (mutt_system(buf_string(cmd)) != 0)
                  mutt_error(_("Error running \"%s\""), buf_string(cmd));
                buf_pool_release(&cmd);
              }
              break;
            }
          }
        }
        else if (check == MX_STATUS_FLAGS)
        {
          mutt_message(_("Mailbox was externally modified"));
        }
 
        /* avoid the message being overwritten by mailbox */
        priv->do_mailbox_notify = false;
 
        bool verbose = shared->mailbox->verbose;
        shared->mailbox->verbose = false;
        update_index(priv->menu, shared->mailbox_view, check, priv->oldcount, shared);
        shared->mailbox->verbose = verbose;
        priv->menu->max = shared->mailbox->vcount;
        menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
        mutt_pattern_free(&shared->search_state->pattern);
      }
 
      index_shared_data_set_email(shared, mutt_get_virt_email(shared->mailbox,
                                                              menu_get_index(priv->menu)));
    }
 
    if (!shared->attach_msg)
    {
      /* check for new mail in the incoming folders */
      mutt_mailbox_check(shared->mailbox, MUTT_MAILBOX_CHECK_NO_FLAGS);
      if (priv->do_mailbox_notify)
      {
        if (mutt_mailbox_notify(shared->mailbox))
        {
          const bool c_beep_new = cs_subset_bool(shared->sub, "beep_new");
          if (c_beep_new)
            mutt_beep(true);
          const struct Expando *c_new_mail_command = cs_subset_expando(shared->sub, "new_mail_command");
          if (c_new_mail_command)
          {
            struct Buffer *cmd = buf_pool_get();
            menu_status_line(cmd, shared, priv->menu, -1, c_new_mail_command);
            if (mutt_system(buf_string(cmd)) != 0)
              mutt_error(_("Error running \"%s\""), buf_string(cmd));
            buf_pool_release(&cmd);
          }
        }
      }
      else
      {
        priv->do_mailbox_notify = true;
      }
    }
 
    window_redraw(NULL);
 
    /* give visual indication that the next command is a tag- command */
    if (priv->tag_prefix)
    {
      msgwin_set_text(NULL, "tag-", MT_COLOR_NORMAL);
    }
 
    const bool c_arrow_cursor = cs_subset_bool(shared->sub, "arrow_cursor");
    const bool c_braille_friendly = cs_subset_bool(shared->sub, "braille_friendly");
    const int index = menu_get_index(priv->menu);
    if (c_arrow_cursor)
    {
      const char *const c_arrow_string = cs_subset_string(shared->sub, "arrow_string");
      const int arrow_width = mutt_strwidth(c_arrow_string);
      mutt_window_move(priv->menu->win, index - priv->menu->top, arrow_width);
    }
    else if (c_braille_friendly)
    {
      mutt_window_move(priv->menu->win, index - priv->menu->top, 0);
    }
    else
    {
      mutt_window_move(priv->menu->win, index - priv->menu->top,
                       priv->menu->win->state.cols - 1);
    }
    mutt_refresh();
 
    window_redraw(NULL);
    struct KeyEvent event = km_dokey(MENU_INDEX, GETCH_NO_FLAGS);
    op = event.op;
 
    if (op == OP_REPAINT)
    {
      /* force a real complete redraw.  clrtobot() doesn't seem to be able
       * to handle every case without this.  */
      msgwin_clear_text(NULL);
      mutt_refresh();
      continue;
    }
 
    /* either user abort or timeout */
    if (op < OP_NULL)
    {
      if (priv->tag_prefix)
        msgwin_clear_text(NULL);
      continue;
    }
 
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
 
    /* special handling for the priv->tag-prefix function */
    const bool c_auto_tag = cs_subset_bool(shared->sub, "auto_tag");
    if ((op == OP_TAG_PREFIX) || (op == OP_TAG_PREFIX_COND))
    {
      /* A second priv->tag-prefix command aborts */
      if (priv->tag_prefix)
      {
        priv->tag_prefix = false;
        msgwin_clear_text(NULL);
        continue;
      }
 
      if (!shared->mailbox)
      {
        mutt_error(_("No mailbox is open"));
        continue;
      }
 
      if (shared->mailbox->msg_tagged == 0)
      {
        if (op == OP_TAG_PREFIX)
        {
          mutt_error(_("No tagged messages"));
        }
        else if (op == OP_TAG_PREFIX_COND)
        {
          mutt_flush_macro_to_endcond();
          mutt_message(_("Nothing to do"));
        }
        continue;
      }
 
      /* get the real command */
      priv->tag_prefix = true;
      continue;
    }
    else if (c_auto_tag && shared->mailbox && (shared->mailbox->msg_tagged != 0))
    {
      priv->tag_prefix = true;
    }
 
    mutt_clear_error();
 
    OptNews = false; /* for any case */
 
#ifdef USE_NOTMUCH
    nm_db_debug_check(shared->mailbox);
#endif
 
    rc = index_function_dispatcher(priv->win_index, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(priv->win_index, &event);
 
    if (rc == FR_UNKNOWN)
    {
      struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
      rc = sb_function_dispatcher(win_sidebar, &event);
    }
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(priv->menu->win, &event);
 
    if (rc == FR_UNKNOWN)
      km_error_key(MENU_INDEX);
 
#ifdef USE_NOTMUCH
    nm_db_debug_check(shared->mailbox);
#endif
  } while (rc != FR_DONE);
 
  mview_free(&shared->mailbox_view);
  window_set_focus(old_focus);
 
  return shared->mailbox;
}

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]	keys	List of keys to select from
[in]	p	Address to match
[in]	s	Real name to display
[in]	app	Flags, e.g. APPLICATION_PGP
[out]	forced_valid	Set to true if user overrode key's validity

Return values

ptr	Key selected by user

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

Definition at line 194 of file dlg_gpgme.c.

{
  /* build the key table */
  struct CryptKeyInfoArray ckia = ARRAY_HEAD_INITIALIZER;
  const bool c_pgp_show_unusable = cs_subset_bool(NeoMutt->sub, "pgp_show_unusable");
  bool unusable = false;
  for (struct CryptKeyInfo *k = keys; k; k = k->next)
  {
    if (!c_pgp_show_unusable && (k->flags & KEYFLAG_CANTUSE))
    {
      unusable = true;
      continue;
    }
 
    ARRAY_ADD(&ckia, k);
  }
 
  if ((ARRAY_SIZE(&ckia) == 0) && unusable)
  {
    mutt_error(_("All matching keys are marked expired/revoked"));
    return NULL;
  }
 
  gpgme_sort_keys(&ckia);
 
  enum MenuType menu_to_use = MENU_GENERIC;
  if (app & APPLICATION_PGP)
    menu_to_use = MENU_PGP;
  else if (app & APPLICATION_SMIME)
    menu_to_use = MENU_SMIME;
 
  struct SimpleDialogWindows sdw = simple_dialog_new(menu_to_use, WT_DLG_GPGME, GpgmeHelp);
 
  struct Menu *menu = sdw.menu;
  struct GpgmeData gd = { false, menu, &ckia, NULL, forced_valid };
 
  menu->max = ARRAY_SIZE(&ckia);
  menu->make_entry = crypt_make_entry;
  menu->mdata = &gd;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, gpgme_key_config_observer, menu);
  notify_observer_add(menu->win->notify, NT_WINDOW, gpgme_key_window_observer, menu->win);
 
  const char *ts = NULL;
 
  if ((app & APPLICATION_PGP) && (app & APPLICATION_SMIME))
    ts = _("PGP and S/MIME keys matching");
  else if ((app & APPLICATION_PGP))
    ts = _("PGP keys matching");
  else if ((app & APPLICATION_SMIME))
    ts = _("S/MIME keys matching");
  else
    ts = _("keys matching");
 
  char buf[1024] = { 0 };
  if (p)
  {
    /* L10N: 1$s is one of the previous four entries.
       %2$s is an address.
       e.g. "S/MIME keys matching <john.doe@example.com>" */
    snprintf(buf, sizeof(buf), _("%s <%s>"), ts, buf_string(p->mailbox));
  }
  else
  {
    /* L10N: e.g. 'S/MIME keys matching "John Doe".' */
    snprintf(buf, sizeof(buf), _("%s \"%s\""), ts, s);
  }
 
  sbar_set_title(sdw.sbar, buf);
 
  mutt_clear_error();
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(menu_to_use, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(menu_to_use);
      continue;
    }
    mutt_clear_error();
 
    int rc = gpgme_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!gd.done);
  // ---------------------------------------------------------------------------
 
  ARRAY_FREE(&ckia);
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  return gd.key;
}

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

keys	List of PGP keys
p	Address to match
s	String to match

Return values

ptr	Selected PGP key

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

Definition at line 191 of file dlg_pgp.c.

{
  struct Menu *menu = NULL;
  char buf[1024] = { 0 };
  bool unusable = false;
  struct PgpUidArray pua = ARRAY_HEAD_INITIALIZER;
 
  const bool c_pgp_show_unusable = cs_subset_bool(NeoMutt->sub, "pgp_show_unusable");
  for (struct PgpKeyInfo *kp = keys; kp; kp = kp->next)
  {
    if (!c_pgp_show_unusable && (kp->flags & KEYFLAG_CANTUSE))
    {
      unusable = true;
      continue;
    }
 
    for (struct PgpUid *a = kp->address; a; a = a->next)
    {
      if (!c_pgp_show_unusable && (a->flags & KEYFLAG_CANTUSE))
      {
        unusable = true;
        continue;
      }
 
      ARRAY_ADD(&pua, a);
    }
  }
 
  if ((ARRAY_SIZE(&pua) == 0) && unusable)
  {
    mutt_error(_("All matching keys are expired, revoked, or disabled"));
    return NULL;
  }
 
  pgp_sort_keys(&pua);
 
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_PGP, WT_DLG_PGP, PgpHelp);
  menu = sdw.menu;
  struct PgpData pd = { false, menu, &pua, NULL };
 
  menu->max = ARRAY_SIZE(&pua);
  menu->make_entry = pgp_make_entry;
  menu->mdata = &pd;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, pgp_key_config_observer, menu);
  notify_observer_add(menu->win->notify, NT_WINDOW, pgp_key_window_observer, menu->win);
 
  if (p)
    snprintf(buf, sizeof(buf), _("PGP keys matching <%s>"), buf_string(p->mailbox));
  else
    snprintf(buf, sizeof(buf), _("PGP keys matching \"%s\""), s);
 
  sbar_set_title(sdw.sbar, buf);
 
  mutt_clear_error();
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_PGP, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_PGP);
      continue;
    }
    mutt_clear_error();
 
    int rc = pgp_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!pd.done);
  // ---------------------------------------------------------------------------
 
  ARRAY_FREE(&pua);
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  return pd.key;
}

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

keys	List of keys to select from
query	String to match

Return values

ptr	Key selected by user

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

Definition at line 194 of file dlg_smime.c.

{
  struct SmimeKeyArray ska = ARRAY_HEAD_INITIALIZER;
  for (struct SmimeKey *key = keys; key; key = key->next)
  {
    ARRAY_ADD(&ska, key);
  }
  /* sorting keys might be done later - TODO */
 
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_SMIME, WT_DLG_SMIME, SmimeHelp);
  struct Menu *menu = sdw.menu;
 
  struct SmimeData sd = { false, menu, &ska, NULL };
 
  menu->max = ARRAY_SIZE(&ska);
  menu->make_entry = smime_make_entry;
  menu->mdata = &sd;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  char title[256] = { 0 };
  snprintf(title, sizeof(title), _("S/MIME certificates matching \"%s\""), query);
  sbar_set_title(sdw.sbar, title);
 
  mutt_clear_error();
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_SMIME, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_SMIME);
      continue;
    }
    mutt_clear_error();
 
    int rc = smime_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!sd.done);
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  return sd.key;
}

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

pview

Pager view settings

Return values

0	Success
-1	Error

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.

{
  //===========================================================================
  // ACT 1 - Ensure sanity of the caller and determine the mode
  //===========================================================================
  ASSERT(pview);
  ASSERT((pview->mode > PAGER_MODE_UNKNOWN) && (pview->mode < PAGER_MODE_MAX));
  ASSERT(pview->pdata); // view can't exist in a vacuum
  ASSERT(pview->win_pager);
  ASSERT(pview->win_pbar);
 
  struct MuttWindow *dlg = dialog_find(pview->win_pager);
  struct IndexSharedData *shared = dlg->wdata;
  struct MuttWindow *win_sidebar = window_find_child(dlg, WT_SIDEBAR);
 
  switch (pview->mode)
  {
    case PAGER_MODE_EMAIL:
      // This case was previously identified by IsEmail macro
      // we expect data to contain email and not contain body
      // We also expect email to always belong to some mailbox
      ASSERT(shared->mailbox_view);
      ASSERT(shared->mailbox);
      ASSERT(shared->email);
      ASSERT(!pview->pdata->body);
      break;
 
    case PAGER_MODE_ATTACH:
      // this case was previously identified by IsAttach and IsMsgAttach
      // macros, we expect data to contain:
      //  - body (viewing regular attachment)
      //  - fp and body->email in special case of viewing an attached email.
      ASSERT(pview->pdata->body);
      if (pview->pdata->fp && pview->pdata->body->email)
      {
        // Special case: attachment is a full-blown email message.
        // Yes, emails can contain other emails.
        pview->mode = PAGER_MODE_ATTACH_E;
      }
      break;
 
    case PAGER_MODE_HELP:
    case PAGER_MODE_OTHER:
      ASSERT(!shared->mailbox_view);
      ASSERT(!shared->email);
      ASSERT(!pview->pdata->body);
      break;
 
    case PAGER_MODE_UNKNOWN:
    case PAGER_MODE_MAX:
    default:
      // Unexpected mode. Catch fire and explode.
      // This *should* happen if mode is PAGER_MODE_ATTACH_E, since
      // we do not expect any caller to pass it to us.
      ASSERT(false);
      break;
  }
 
  //===========================================================================
  // ACT 2 - Declare, initialize local variables, read config, etc.
  //===========================================================================
 
  //---------- local variables ------------------------------------------------
  int op = 0;
  enum MailboxType mailbox_type = shared->mailbox ? shared->mailbox->type : MUTT_UNKNOWN;
  struct PagerPrivateData *priv = pview->win_pager->parent->wdata;
  priv->rc = -1;
  priv->searchctx = 0;
  priv->first = true;
  priv->wrapped = false;
  priv->delay_read_timestamp = 0;
  priv->pager_redraw = false;
 
  // Wipe any previous state info
  struct Notify *notify = priv->notify;
  int prc = priv->rc;
  memset(priv, 0, sizeof(*priv));
  priv->rc = prc;
  priv->notify = notify;
  TAILQ_INIT(&priv->ansi_list);
 
  //---------- setup flags ----------------------------------------------------
  if (!(pview->flags & MUTT_SHOWCOLOR))
    pview->flags |= MUTT_SHOWFLAT;
 
  if ((pview->mode == PAGER_MODE_EMAIL) && !shared->email->read)
  {
    if (shared->mailbox_view)
      shared->mailbox_view->msg_in_pager = shared->email->msgno;
    const short c_pager_read_delay = cs_subset_number(NeoMutt->sub, "pager_read_delay");
    if (c_pager_read_delay == 0)
    {
      mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
    }
    else
    {
      priv->delay_read_timestamp = mutt_date_now_ms() + (1000 * c_pager_read_delay);
    }
  }
  //---------- setup help menu ------------------------------------------------
  pview->win_pager->help_data = pager_resolve_help_mapping(pview->mode, mailbox_type);
  pview->win_pager->help_menu = MENU_PAGER;
 
  //---------- initialize redraw pdata  -----------------------------------------
  pview->win_pager->size = MUTT_WIN_SIZE_MAXIMISE;
  priv->lines_max = LINES; // number of lines on screen, from curses
  priv->lines = MUTT_MEM_CALLOC(priv->lines_max, struct Line);
  priv->fp = mutt_file_fopen(pview->pdata->fname, "r");
  priv->has_types = ((pview->mode == PAGER_MODE_EMAIL) || (pview->flags & MUTT_SHOWCOLOR)) ?
                        MUTT_TYPES :
                        0; // main message or rfc822 attachment
 
  for (size_t i = 0; i < priv->lines_max; i++)
  {
    priv->lines[i].cid = -1;
    priv->lines[i].search_arr_size = -1;
    priv->lines[i].syntax = MUTT_MEM_CALLOC(1, struct TextSyntax);
    (priv->lines[i].syntax)[0].first = -1;
    (priv->lines[i].syntax)[0].last = -1;
  }
 
  // ---------- try to open the pdata file -------------------------------------
  if (!priv->fp)
  {
    mutt_perror("%s", pview->pdata->fname);
    return -1;
  }
 
  if (stat(pview->pdata->fname, &priv->st) != 0)
  {
    mutt_perror("%s", pview->pdata->fname);
    mutt_file_fclose(&priv->fp);
    return -1;
  }
  unlink(pview->pdata->fname);
  priv->pview = pview;
 
  //---------- show windows, set focus and visibility --------------------------
  window_set_visible(pview->win_pager->parent, true);
  mutt_window_reflow(dlg);
  window_invalidate_all();
 
  struct MuttWindow *old_focus = window_set_focus(pview->win_pager);
 
  //---------- jump to the bottom if requested ------------------------------
  if (pview->flags & MUTT_PAGER_BOTTOM)
  {
    jump_to_bottom(priv, pview);
  }
 
  //-------------------------------------------------------------------------
  // ACT 3: Read user input and decide what to do with it
  //        ...but also do a whole lot of other things.
  //-------------------------------------------------------------------------
 
  // Force an initial paint, which will populate priv->lines
  pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
  window_redraw(NULL);
 
  priv->loop = PAGER_LOOP_CONTINUE;
  do
  {
    window_redraw(NULL);
 
    const bool c_braille_friendly = cs_subset_bool(NeoMutt->sub, "braille_friendly");
    if (c_braille_friendly)
    {
      if (BrailleRow != -1)
      {
        mutt_window_move(priv->pview->win_pager, BrailleRow + 1, BrailleCol);
        BrailleRow = -1;
      }
    }
    else
    {
      mutt_window_move(priv->pview->win_pbar, 0, priv->pview->win_pager->state.cols - 1);
    }
 
    // force redraw of the screen at every iteration of the event loop
    mutt_refresh();
 
    //-------------------------------------------------------------------------
    // Check if information in the status bar needs an update
    // This is done because pager is a single-threaded application, which
    // tries to emulate concurrency.
    //-------------------------------------------------------------------------
    bool do_new_mail = false;
    if (shared->mailbox && !shared->attach_msg)
    {
      int oldcount = shared->mailbox->msg_count;
      /* check for new mail */
      enum MxStatus check = mx_mbox_check(shared->mailbox);
      if (check == MX_STATUS_ERROR)
      {
        if (!shared->mailbox || buf_is_empty(&shared->mailbox->pathbuf))
        {
          /* fatal error occurred */
          pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
          break;
        }
      }
      else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED) ||
               (check == MX_STATUS_FLAGS))
      {
        /* notify user of newly arrived mail */
        if (check == MX_STATUS_NEW_MAIL)
        {
          for (size_t i = oldcount; i < shared->mailbox->msg_count; i++)
          {
            struct Email *e = shared->mailbox->emails[i];
 
            if (e && !e->read)
            {
              mutt_message(_("New mail in this mailbox"));
              do_new_mail = true;
              break;
            }
          }
        }
 
        if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
        {
          pager_queue_redraw(priv, PAGER_REDRAW_PAGER);
          mutt_pattern_free(&shared->search_state->pattern);
        }
      }
 
      if (mutt_mailbox_notify(shared->mailbox) || do_new_mail)
      {
        const bool c_beep_new = cs_subset_bool(NeoMutt->sub, "beep_new");
        if (c_beep_new)
          mutt_beep(true);
        const struct Expando *c_new_mail_command = cs_subset_expando(NeoMutt->sub, "new_mail_command");
        if (c_new_mail_command)
        {
          struct Buffer *cmd = buf_pool_get();
          menu_status_line(cmd, shared, NULL, -1, c_new_mail_command);
          if (mutt_system(buf_string(cmd)) != 0)
            mutt_error(_("Error running \"%s\""), buf_string(cmd));
          buf_pool_release(&cmd);
        }
      }
    }
    //-------------------------------------------------------------------------
 
    if (priv->pager_redraw)
    {
      priv->pager_redraw = false;
      mutt_resize_screen();
      clearok(stdscr, true); /* force complete redraw */
      msgwin_clear_text(NULL);
 
      pager_queue_redraw(priv, PAGER_REDRAW_FLOW);
 
      /* note: mutt_resize_screen() -> mutt_window_reflow() sets
       * PAGER_REDRAW_PAGER and PAGER_REDRAW_FLOW */
      continue;
    }
 
    dump_pager(priv);
 
    //-------------------------------------------------------------------------
    // Finally, read user's key press
    //-------------------------------------------------------------------------
    // km_dokey() reads not only user's key strokes, but also a MacroBuffer
    // MacroBuffer may contain OP codes of the operations.
    // MacroBuffer is global
    // OP codes inserted into the MacroBuffer by various functions.
    // One of such functions is `mutt_enter_command()`
    // Some OP codes are not handled by pager, they cause pager to quit returning
    // OP code to index. Index handles the operation and then restarts pager
    struct KeyEvent event = km_dokey(MENU_PAGER, GETCH_NO_FLAGS);
    op = event.op;
 
    // km_dokey() can block, so recheck the timer.
    // Note: This check must occur before handling the operations of the index
    // as those can change the currently selected message/entry yielding to
    // marking the wrong message as read.
    if (check_read_delay(&priv->delay_read_timestamp))
    {
      mutt_set_flag(shared->mailbox, shared->email, MUTT_READ, true, true);
    }
 
    if (SigWinch)
      priv->pager_redraw = true;
 
    if (op >= OP_NULL)
      mutt_clear_error();
 
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
 
    if (op < OP_NULL)
      continue;
 
    if (op == OP_NULL)
    {
      km_error_key(MENU_PAGER);
      continue;
    }
 
    int rc = pager_function_dispatcher(priv->pview->win_pager, &event);
 
    if (pview->mode == PAGER_MODE_EMAIL)
    {
      if ((rc == FR_UNKNOWN) && priv->pview->win_index)
        rc = index_function_dispatcher(priv->pview->win_index, &event);
      if (rc == FR_UNKNOWN)
        rc = sb_function_dispatcher(win_sidebar, &event);
    }
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(priv->pview->win_pager, &event);
 
    if ((rc == FR_UNKNOWN) &&
        ((pview->mode == PAGER_MODE_ATTACH) || (pview->mode == PAGER_MODE_ATTACH_E)))
    {
      // Some attachment functions still need to be delegated
      priv->rc = op;
      break;
    }
 
    if ((pview->mode != PAGER_MODE_EMAIL) && (rc == FR_UNKNOWN))
      mutt_flushinp();
 
  } while (priv->loop == PAGER_LOOP_CONTINUE);
  window_set_focus(old_focus);
 
  //-------------------------------------------------------------------------
  // END OF ACT 3: Read user input loop - while (op != OP_ABORT)
  //-------------------------------------------------------------------------
 
  mutt_file_fclose(&priv->fp);
  if (pview->mode == PAGER_MODE_EMAIL)
  {
    if (shared->mailbox_view)
      shared->mailbox_view->msg_in_pager = -1;
  }
 
  qstyle_free_tree(&priv->quote_list);
 
  for (size_t i = 0; i < priv->lines_max; i++)
  {
    FREE(&(priv->lines[i].syntax));
    if (priv->search_compiled && priv->lines[i].search)
      FREE(&(priv->lines[i].search));
  }
  if (priv->search_compiled)
  {
    regfree(&priv->search_re);
    priv->search_compiled = false;
  }
  FREE(&priv->lines);
  attr_color_list_clear(&priv->ansi_list);
  {
    struct AttrColor *ac = NULL;
    int count = 0;
    TAILQ_FOREACH(ac, &priv->ansi_list, entries)
    {
      count++;
    }
    color_debug(LL_DEBUG5, "AnsiColors %d\n", count);
  }
 
  priv->pview = NULL;
 
  if (priv->loop == PAGER_LOOP_RELOAD)
    return PAGER_LOOP_RELOAD;
 
  return (priv->rc != -1) ? priv->rc : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dlg_pattern()

bool dlg_pattern

(

struct Buffer *

buf

)

Show menu to select a Pattern -.

Parameters

buf	Buffer for the selected Pattern

Return values

true	A 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 282 of file dlg_pattern.c.

{
  struct PatternData *pd = pattern_data_new();
 
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_DIALOG, WT_DLG_PATTERN, PatternHelp);
  create_pattern_entries(&pd->entries);
 
  struct Menu *menu = sdw.menu;
  pd->menu = menu;
  pd->buf = buf;
 
  menu->mdata = pd;
  menu->mdata_free = pattern_data_free;
  menu->make_entry = pattern_make_entry;
  menu->max = ARRAY_SIZE(&pd->entries);
 
  // L10N: Pattern completion menu title
  sbar_set_title(sdw.sbar, _("Patterns"));
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, pattern_config_observer, menu);
  notify_observer_add(menu->win->notify, NT_WINDOW, pattern_window_observer, menu->win);
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_DIALOG, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_GENERIC);
      continue;
    }
    mutt_clear_error();
 
    int rc = pattern_function_dispatcher(sdw.dlg, &event);
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!pd->done);
  // ---------------------------------------------------------------------------
 
  bool rc = pd->selection;
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
 
  return rc;
}

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

m

Mailbox

Return values

ptr

Email

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 209 of file dlg_postpone.c.

{
  struct SimpleDialogWindows sdw = simple_dialog_new(MENU_POSTPONED, WT_DLG_POSTPONED,
                                                     PostponedHelp);
  // Required to number the emails
  struct MailboxView *mv = mview_new(m, NeoMutt->notify);
 
  struct Menu *menu = sdw.menu;
  menu->make_entry = post_make_entry;
  menu->color = post_color;
  menu->max = m->msg_count;
 
  struct PostponeData pd = { mv, menu, NULL, false, search_state_new() };
  menu->mdata = &pd;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  // NT_COLOR is handled by the SimpleDialog
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, postponed_config_observer, menu);
  notify_observer_add(menu->win->notify, NT_WINDOW, postponed_window_observer, menu->win);
 
  sbar_set_title(sdw.sbar, _("Postponed Messages"));
 
  /* The postponed mailbox is setup to have sorting disabled, but the global
   * `$sort` variable may indicate something different.   Sorting has to be
   * disabled while the postpone menu is being displayed. */
  const enum EmailSortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  cs_subset_str_native_set(NeoMutt->sub, "sort", EMAIL_SORT_UNSORTED, NULL);
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(MENU_POSTPONED, GETCH_NO_FLAGS);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_POSTPONED);
      continue;
    }
    mutt_clear_error();
 
    int rc = postpone_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!pd.done);
  // ---------------------------------------------------------------------------
 
  mview_free(&mv);
  cs_subset_str_native_set(NeoMutt->sub, "sort", c_sort, NULL);
  search_state_free(&pd.search_state);
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
 
  return pd.email;
}

Here is the call graph for this function:

Here is the caller graph for this function: