window.c File Reference

Envelope Window. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "private.h"
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "color/lib.h"
#include "ncrypt/lib.h"
#include "functions.h"
#include "globals.h"
#include "module_data.h"
#include "wdata.h"
#include <libintl.h>

Include dependency graph for window.c:

Go to the source code of this file.

Macros
#define	MAX_ADDR_ROWS   5
	Maximum number of rows to use for the To:, Cc:, Bcc: fields.
#define	MAX_USER_HDR_ROWS   5
	Maximum number of rows to use for the Headers: field.

Functions
static void	calc_header_width_padding (struct EnvelopeModuleData *mod_data, int idx, const char *header, bool calc_max)
	Calculate the width needed for the compose labels.
static void	init_header_padding (void)
	Calculate how much padding the compose table will need.
static int	calc_address (struct AddressList *al, short cols, short *srows)
	Calculate how many rows an AddressList will need.
static int	calc_security (struct Email *e, short *rows, const struct ConfigSubset *sub)
	Calculate how many rows the security info will need.
static int	calc_user_hdrs (const struct ListHead *hdrs)
	Calculate how many rows are needed for user-defined headers.
static int	calc_envelope (struct MuttWindow *win, struct EnvelopeWindowData *wdata)
	Calculate how many rows the envelope will need.
static void	draw_floating (struct MuttWindow *win, int col, int row, const char *text)
	Draw a floating label.
static void	draw_header (struct MuttWindow *win, int row, enum HeaderField field)
	Draw an aligned label.
static void	draw_header_content (struct MuttWindow *win, int row, enum HeaderField field, const char *content)
	Draw content on a separate line aligned to header prompt.
static int	draw_crypt_lines (struct MuttWindow *win, struct EnvelopeWindowData *wdata, int row)
	Update the encryption info in the compose window.
static int	draw_envelope_addr (int field, struct AddressList *al, struct MuttWindow *win, int row, size_t max_lines)
	Write addresses to the compose window.
static int	draw_envelope_user_hdrs (struct MuttWindow *win, struct EnvelopeWindowData *wdata, int row)
	Write user-defined headers to the compose window.
static void	draw_envelope (struct MuttWindow *win, struct EnvelopeWindowData *wdata)
	Write the email headers to the compose window.
static int	env_recalc (struct MuttWindow *win)
	Recalculate the Window data - Implements MuttWindow::recalc() -.
static int	env_repaint (struct MuttWindow *win)
	Repaint the Window - Implements MuttWindow::repaint() -.
static int	env_color_observer (struct NotifyCallback *nc)
	Notification that a Color has changed - Implements observer_t -.
static int	env_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
static int	env_email_observer (struct NotifyCallback *nc)
	Notification that the Email has changed - Implements observer_t -.
static int	env_header_observer (struct NotifyCallback *nc)
	Notification that a User Header has changed - Implements observer_t -.
static int	env_window_observer (struct NotifyCallback *nc)
	Notification that a Window has changed - Implements observer_t -.
struct MuttWindow *	env_window_new (struct Email *e, struct Buffer *fcc, struct ConfigSubset *sub)
	Create the Envelope Window.

Variables
const char *const	Prompts []
	Names of header fields used in the envelope, e.g. From:, To:
static const char *const	AutocryptRecUiFlags []
	Autocrypt "recommendation" strings.

Detailed Description

Envelope Window.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file window.c.

Macro Definition Documentation

MAX_ADDR_ROWS

#define MAX_ADDR_ROWS   5

Maximum number of rows to use for the To:, Cc:, Bcc: fields.

Definition at line 83 of file window.c.

MAX_USER_HDR_ROWS

#define MAX_USER_HDR_ROWS   5

Maximum number of rows to use for the Headers: field.

Definition at line 86 of file window.c.

Function Documentation

calc_header_width_padding()

static void calc_header_width_padding ( struct EnvelopeModuleData * mod_data, int idx, const char * header, bool calc_max )

static

Calculate the width needed for the compose labels.

Parameters

mod_data	Module data
idx	Store the result at this index of header_padding
header	Header string
calc_max	If true, calculate the maximum width

Definition at line 158 of file window.c.

{
  int width;
 
  mod_data->header_padding[idx] = mutt_str_len(header);
  width = mutt_strwidth(header);
  if (calc_max && (mod_data->max_header_width < width))
    mod_data->max_header_width = width;
  mod_data->header_padding[idx] -= width;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_header_padding()

static void init_header_padding ( void )

static

Calculate how much padding the compose table will need.

The padding needed for each header is strlen() + max_width - strwidth().

calc_header_width_padding sets each entry in header_padding to strlen - width. Then, afterwards, we go through and add max_width to each entry.

Definition at line 178 of file window.c.

{
  static bool done = false;
 
  if (done)
    return;
  done = true;
 
  struct EnvelopeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ENVELOPE);
 
  for (int i = 0; i < HDR_ATTACH_TITLE; i++)
  {
    if (i == HDR_CRYPTINFO)
      continue;
    calc_header_width_padding(mod_data, i, _(Prompts[i]), true);
  }
 
  /* Don't include "Sign as: " in the MaxHeaderWidth calculation.  It
   * doesn't show up by default, and so can make the indentation of
   * the other fields look funny. */
  calc_header_width_padding(mod_data, HDR_CRYPTINFO, _(Prompts[HDR_CRYPTINFO]), false);
 
  for (int i = 0; i < HDR_ATTACH_TITLE; i++)
  {
    mod_data->header_padding[i] += mod_data->max_header_width;
    if (mod_data->header_padding[i] < 0)
      mod_data->header_padding[i] = 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

calc_address()

static int calc_address ( struct AddressList * al, short cols, short * srows )

static

Calculate how many rows an AddressList will need.

Parameters

[in]	al	Address List
[in]	cols	Screen columns available
[out]	srows	Rows needed

Return values

num	Rows needed

Note

Number of rows is capped at MAX_ADDR_ROWS

Definition at line 217 of file window.c.

{
  struct ListHead slist = STAILQ_HEAD_INITIALIZER(slist);
  mutt_addrlist_write_list(al, &slist);
 
  short rows = 1;
  int addr_len;
  int width_left = cols;
  struct ListNode *next = NULL;
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &slist, entries)
  {
    next = STAILQ_NEXT(np, entries);
    addr_len = mutt_strwidth(np->data);
    if (next)
      addr_len += 2; // ", "
 
  try_again:
    if (addr_len >= width_left)
    {
      if (width_left == cols)
        break;
 
      rows++;
      width_left = cols;
      goto try_again;
    }
 
    if (addr_len < width_left)
      width_left -= addr_len;
  }
 
  mutt_list_free(&slist);
 
  *srows = MIN(rows, MAX_ADDR_ROWS);
  return *srows;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calc_security()

static int calc_security ( struct Email * e, short * rows, const struct ConfigSubset * sub )

static

Calculate how many rows the security info will need.

Parameters

e	Email
rows	Rows needed
sub	ConfigSubset

Return values

num	Rows needed

Definition at line 262 of file window.c.

{
  if ((WithCrypto & (APPLICATION_PGP | APPLICATION_SMIME)) == 0)
    *rows = 0; // Neither PGP nor SMIME are built into NeoMutt
  else if ((e->security & (SEC_ENCRYPT | SEC_SIGN)) != 0)
    *rows = 2; // 'Security:' and 'Sign as:'
  else
    *rows = 1; // Just 'Security:'
 
#ifdef USE_AUTOCRYPT
  const bool c_autocrypt = cs_subset_bool(sub, "autocrypt");
  if (c_autocrypt)
    *rows += 1;
#endif
 
  return *rows;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calc_user_hdrs()

static int calc_user_hdrs ( const struct ListHead * hdrs )

static

Calculate how many rows are needed for user-defined headers.

Parameters

hdrs	Header List

Return values

num	Rows needed, limited to MAX_USER_HDR_ROWS

Definition at line 285 of file window.c.

{
  int rows = 0; /* Don't print at all if no custom headers*/
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, hdrs, entries)
  {
    if (rows == MAX_USER_HDR_ROWS)
      break;
    rows++;
  }
  return rows;
}

Here is the caller graph for this function:

calc_envelope()

static int calc_envelope ( struct MuttWindow * win, struct EnvelopeWindowData * wdata )

static

Calculate how many rows the envelope will need.

Parameters

win	Window to draw on
wdata	Envelope Window data

Return values

num	Rows needed

Definition at line 304 of file window.c.

{
  int rows = 4; // 'From:', 'Subject:', 'Reply-To:', 'Fcc:'
  struct Email *e = wdata->email;
 
  struct EnvelopeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ENVELOPE);
  struct Envelope *env = e->env;
  const int cols = win->state.cols - mod_data->max_header_width;
 
  if (wdata->is_news)
  {
    rows += 2; // 'Newsgroups:' and 'Followup-To:'
    const bool c_x_comment_to = cs_subset_bool(wdata->sub, "x_comment_to");
    if (c_x_comment_to)
      rows++;
  }
  else
  {
    rows += calc_address(&env->to, cols, &wdata->to_rows);
    rows += calc_address(&env->cc, cols, &wdata->cc_rows);
    rows += calc_address(&env->bcc, cols, &wdata->bcc_rows);
  }
  rows += calc_security(e, &wdata->sec_rows, wdata->sub);
  const bool c_compose_show_user_headers = cs_subset_bool(wdata->sub, "compose_show_user_headers");
  if (c_compose_show_user_headers)
    rows += calc_user_hdrs(&env->userhdrs);
 
  return rows;
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_floating()

static void draw_floating ( struct MuttWindow * win, int col, int row, const char * text )

static

Draw a floating label.

Parameters

win	Window to draw on
col	Column to draw at
row	Row to draw at
text	Text to display

Definition at line 341 of file window.c.

{
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_HEADER);
  mutt_window_move(win, row, col);
  mutt_window_printf(win, "%s", text);
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_header()

static void draw_header ( struct MuttWindow * win, int row, enum HeaderField field )

static

Draw an aligned label.

Parameters

win	Window to draw on
row	Row to draw at
field	Field to display, e.g. HDR_FROM

Definition at line 355 of file window.c.

{
  struct EnvelopeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ENVELOPE);
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_HEADER);
  mutt_window_move(win, row, 0);
  mutt_window_printf(win, "%*s", mod_data->header_padding[field], _(Prompts[field]));
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_header_content()

static void draw_header_content ( struct MuttWindow * win, int row, enum HeaderField field, const char * content )

static

Draw content on a separate line aligned to header prompt.

Parameters

win	Window to draw on
row	Row to draw at
field	Field to display, e.g. HDR_FROM
content	Text to display

Content will be truncated if it is wider than the window.

Definition at line 373 of file window.c.

{
  struct EnvelopeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ENVELOPE);
  mutt_window_move(win, row, mod_data->header_padding[field]);
  mutt_paddstr(win, win->state.cols - mod_data->header_padding[field], content);
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_crypt_lines()

static int draw_crypt_lines ( struct MuttWindow * win, struct EnvelopeWindowData * wdata, int row )

static

Update the encryption info in the compose window.

Parameters

win	Window to draw on
wdata	Envelope Window data
row	Window row to start drawing

Return values

num	Number of lines used

Definition at line 388 of file window.c.

{
  struct Email *e = wdata->email;
 
  draw_header(win, row++, HDR_CRYPT);
 
  if ((WithCrypto & (APPLICATION_PGP | APPLICATION_SMIME)) == 0)
    return 0;
 
  // We'll probably need two lines for 'Security:' and 'Sign as:'
  int used = 2;
  if ((e->security & (SEC_ENCRYPT | SEC_SIGN)) == (SEC_ENCRYPT | SEC_SIGN))
  {
    mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_SECURITY_BOTH);
    mutt_window_addstr(win, _("Sign, Encrypt"));
  }
  else if (e->security & SEC_ENCRYPT)
  {
    mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_SECURITY_ENCRYPT);
    mutt_window_addstr(win, _("Encrypt"));
  }
  else if (e->security & SEC_SIGN)
  {
    mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_SECURITY_SIGN);
    mutt_window_addstr(win, _("Sign"));
  }
  else
  {
    /* L10N: This refers to the encryption of the email, e.g. "Security: None" */
    mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_SECURITY_NONE);
    mutt_window_addstr(win, _("None"));
    used = 1; // 'Sign as:' won't be needed
  }
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
  if ((e->security & (SEC_ENCRYPT | SEC_SIGN)))
  {
    if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
    {
      if ((e->security & SEC_INLINE))
        mutt_window_addstr(win, _(" (inline PGP)"));
      else
        mutt_window_addstr(win, _(" (PGP/MIME)"));
    }
    else if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
    {
      mutt_window_addstr(win, _(" (S/MIME)"));
    }
  }
 
  const bool c_crypt_opportunistic_encrypt = cs_subset_bool(wdata->sub, "crypt_opportunistic_encrypt");
  if (c_crypt_opportunistic_encrypt && (e->security & SEC_OPPENCRYPT))
    mutt_window_addstr(win, _(" (OppEnc mode)"));
 
  mutt_window_clrtoeol(win);
 
  if (((WithCrypto & APPLICATION_PGP) != 0) &&
      (e->security & APPLICATION_PGP) && (e->security & SEC_SIGN))
  {
    draw_header(win, row++, HDR_CRYPTINFO);
    const char *const c_pgp_sign_as = cs_subset_string(wdata->sub, "pgp_sign_as");
    mutt_window_printf(win, "%s", c_pgp_sign_as ? c_pgp_sign_as : _("<default>"));
  }
 
  if (((WithCrypto & APPLICATION_SMIME) != 0) &&
      (e->security & APPLICATION_SMIME) && (e->security & SEC_SIGN))
  {
    draw_header(win, row++, HDR_CRYPTINFO);
    const char *const c_smime_sign_as = cs_subset_string(wdata->sub, "smime_sign_as");
    mutt_window_printf(win, "%s", c_smime_sign_as ? c_smime_sign_as : _("<default>"));
  }
 
  const char *const c_smime_encrypt_with = cs_subset_string(wdata->sub, "smime_encrypt_with");
  if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME) &&
      (e->security & SEC_ENCRYPT) && c_smime_encrypt_with)
  {
    draw_floating(win, 40, row - 1, _("Encrypt with: "));
    mutt_window_printf(win, "%s", NONULL(c_smime_encrypt_with));
  }
 
#ifdef USE_AUTOCRYPT
  const bool c_autocrypt = cs_subset_bool(wdata->sub, "autocrypt");
  if (c_autocrypt)
  {
    draw_header(win, row, HDR_AUTOCRYPT);
    if (e->security & SEC_AUTOCRYPT)
    {
      mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_SECURITY_ENCRYPT);
      mutt_window_addstr(win, _("Encrypt"));
    }
    else
    {
      mutt_curses_set_normal_backed_color_by_id(MT_COLOR_COMPOSE_SECURITY_NONE);
      mutt_window_addstr(win, _("Off"));
    }
 
    /* L10N: The autocrypt compose menu Recommendation field.
       Displays the output of the recommendation engine
       (Off, No, Discouraged, Available, Yes) */
    draw_floating(win, 40, row, _("Recommendation: "));
    mutt_window_printf(win, "%s", _(AutocryptRecUiFlags[wdata->autocrypt_rec]));
 
    used++;
  }
#endif
  return used;
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_envelope_addr()

static int draw_envelope_addr ( int field, struct AddressList * al, struct MuttWindow * win, int row, size_t max_lines )

static

Write addresses to the compose window.

Parameters

field	Field to display, e.g. HDR_FROM
al	Address list to write
win	Window
row	Window row to start drawing
max_lines	How many lines may be used

Return values

num	Lines used

Definition at line 505 of file window.c.

{
  draw_header(win, row, field);
 
  struct EnvelopeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ENVELOPE);
 
  /* Format addresses into displayable strings and wrap across multiple
   * lines as needed, showing "(+N more)" when lines are exhausted */
  struct ListHead list = STAILQ_HEAD_INITIALIZER(list);
  int count = mutt_addrlist_count_recips(al);
 
  int lines_used = 1;
  int width_left = win->state.cols - mod_data->max_header_width;
  char more[32] = { 0 };
  int more_len = 0;
 
  struct Buffer *buf = buf_pool_get();
  bool in_group = false;
  char *sep = NULL;
  struct Address *addr = NULL;
  TAILQ_FOREACH(addr, al, entries)
  {
    struct Address *next = TAILQ_NEXT(addr, entries);
 
    if (addr->group)
    {
      in_group = true;
    }
 
    buf_reset(buf);
    mutt_addr_write(buf, addr, true);
    size_t addr_len = mutt_strwidth(buf_string(buf));
 
    sep = "";
    if (!addr->group)
    {
      // group terminator
      if (in_group && next && !next->mailbox && !next->personal)
      {
        sep = ";";
        addr_len += 1;
        in_group = false;
      }
      else if (next)
      {
        sep = ", ";
        addr_len += 2;
      }
    }
 
    count--;
  try_again:
    /* Calculate the "(+N more)" indicator width if we're on the last line */
    more_len = snprintf(more, sizeof(more),
                        ngettext("(+%d more)", "(+%d more)", count), count);
    if ((more_len < 0) || (more_len >= sizeof(more)))
      more_len = mutt_strwidth(more);
    mutt_debug(LL_DEBUG3, "text: '%s'  len: %d\n", more, more_len);
 
    int reserve = ((count > 0) && (lines_used == max_lines)) ? more_len : 0;
    mutt_debug(LL_DEBUG3, "processing: %s (al:%zu, wl:%d, r:%d, lu:%d)\n",
               buf_string(buf), addr_len, width_left, reserve, lines_used);
    if (addr_len >= (width_left - reserve))
    {
      mutt_debug(LL_DEBUG3, "not enough space\n");
      if (lines_used == max_lines)
      {
        mutt_debug(LL_DEBUG3, "no more lines\n");
        mutt_debug(LL_DEBUG3, "truncating: %s\n", buf_string(buf));
        mutt_paddstr(win, width_left, buf_string(buf));
        break;
      }
 
      if (width_left == (win->state.cols - mod_data->max_header_width))
      {
        mutt_debug(LL_DEBUG3, "couldn't print: %s\n", buf_string(buf));
        mutt_paddstr(win, width_left, buf_string(buf));
        break;
      }
 
      mutt_debug(LL_DEBUG3, "start a new line\n");
      mutt_window_clrtoeol(win);
      row++;
      lines_used++;
      width_left = win->state.cols - mod_data->max_header_width;
      mutt_window_move(win, row, mod_data->max_header_width);
      goto try_again;
    }
 
    if (addr_len < width_left)
    {
      mutt_debug(LL_DEBUG3, "space for: %s\n", buf_string(buf));
      mutt_window_addstr(win, buf_string(buf));
      mutt_window_addstr(win, sep);
      width_left -= addr_len;
    }
    mutt_debug(LL_DEBUG3, "%d addresses remaining\n", count);
    mutt_debug(LL_DEBUG3, "%zd lines remaining\n", max_lines - lines_used);
  }
  mutt_list_free(&list);
  buf_pool_release(&buf);
 
  /* Display the "(+N more)" overflow indicator, or clear the rest of the line */
  if (count > 0)
  {
    mutt_window_move(win, row, win->state.cols - more_len);
    mutt_curses_set_normal_backed_color_by_id(MT_COLOR_BOLD);
    mutt_window_addstr(win, more);
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    mutt_debug(LL_DEBUG3, "%d more (len %d)\n", count, more_len);
  }
  else
  {
    mutt_window_clrtoeol(win);
  }
 
  for (int i = lines_used; i < max_lines; i++)
  {
    mutt_window_move(win, row + i, 0);
    mutt_window_clrtoeol(win);
  }
 
  mutt_debug(LL_DEBUG3, "used %d lines\n", lines_used);
  return lines_used;
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_envelope_user_hdrs()

static int draw_envelope_user_hdrs ( struct MuttWindow * win, struct EnvelopeWindowData * wdata, int row )

static

Write user-defined headers to the compose window.

Parameters

win	Window to draw on
wdata	Envelope Window data
row	Window row to start drawing from

Return values

num

Rows used

Definition at line 639 of file window.c.

{
  const char *overflow_text = "...";
  int rows_used = 0;
 
  struct ListNode *first = STAILQ_FIRST(&wdata->email->env->userhdrs);
  if (!first)
    return rows_used;
 
  /* Draw first entry on same line as prompt */
  draw_header(win, row, HDR_CUSTOM_HEADERS);
  draw_header_content(win, row, HDR_CUSTOM_HEADERS, first->data);
  rows_used++;
 
  /* Draw any following entries on their own line */
  struct ListNode *np = STAILQ_NEXT(first, entries);
  if (!np)
    return rows_used;
 
  STAILQ_FOREACH_FROM(np, &wdata->email->env->userhdrs, entries)
  {
    if ((rows_used == (MAX_USER_HDR_ROWS - 1)) && STAILQ_NEXT(np, entries))
    {
      draw_header_content(win, row + rows_used, HDR_CUSTOM_HEADERS, overflow_text);
      rows_used++;
      break;
    }
    draw_header_content(win, row + rows_used, HDR_CUSTOM_HEADERS, np->data);
    rows_used++;
  }
  return rows_used;
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_envelope()

static void draw_envelope ( struct MuttWindow * win, struct EnvelopeWindowData * wdata )

static

Write the email headers to the compose window.

Parameters

win	Window to draw on
wdata	Envelope Window data

Definition at line 678 of file window.c.

{
  struct Email *e = wdata->email;
  const char *fcc = buf_string(wdata->fcc);
  struct EnvelopeModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ENVELOPE);
  const int cols = win->state.cols - mod_data->max_header_width;
 
  mutt_window_clear(win);
  int row = draw_envelope_addr(HDR_FROM, &e->env->from, win, 0, 1);
 
  if (wdata->is_news)
  {
    draw_header(win, row++, HDR_NEWSGROUPS);
    mutt_paddstr(win, cols, NONULL(e->env->newsgroups));
 
    draw_header(win, row++, HDR_FOLLOWUPTO);
    mutt_paddstr(win, cols, NONULL(e->env->followup_to));
 
    const bool c_x_comment_to = cs_subset_bool(wdata->sub, "x_comment_to");
    if (c_x_comment_to)
    {
      draw_header(win, row++, HDR_XCOMMENTTO);
      mutt_paddstr(win, cols, NONULL(e->env->x_comment_to));
    }
  }
  else
  {
    row += draw_envelope_addr(HDR_TO, &e->env->to, win, row, wdata->to_rows);
    row += draw_envelope_addr(HDR_CC, &e->env->cc, win, row, wdata->cc_rows);
    row += draw_envelope_addr(HDR_BCC, &e->env->bcc, win, row, wdata->bcc_rows);
  }
 
  draw_header(win, row++, HDR_SUBJECT);
  mutt_paddstr(win, cols, NONULL(e->env->subject));
 
  row += draw_envelope_addr(HDR_REPLYTO, &e->env->reply_to, win, row, 1);
 
  draw_header(win, row++, HDR_FCC);
  mutt_paddstr(win, cols, fcc);
 
  if (WithCrypto)
    row += draw_crypt_lines(win, wdata, row);
 
  const bool c_compose_show_user_headers = cs_subset_bool(wdata->sub, "compose_show_user_headers");
  if (c_compose_show_user_headers)
    row += draw_envelope_user_hdrs(win, wdata, row);
 
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

env_window_new()

struct MuttWindow * env_window_new	(	struct Email *	e,
		struct Buffer *	fcc,
		struct ConfigSubset *	sub )

Create the Envelope Window.

Parameters

e	Email
fcc	Buffer to save FCC
sub	ConfigSubset

Return values

ptr	New Window

Definition at line 955 of file window.c.

{
  init_header_padding();
 
  struct MuttWindow *win_env = mutt_window_new(WT_CUSTOM, MUTT_WIN_ORIENT_VERTICAL,
                                               MUTT_WIN_SIZE_FIXED, MUTT_WIN_SIZE_UNLIMITED,
                                               HDR_ATTACH_TITLE - 1);
 
  mutt_color_observer_add(env_color_observer, win_env);
  notify_observer_add(e->notify, NT_ALL, env_email_observer, win_env);
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, env_config_observer, win_env);
  notify_observer_add(NeoMutt->notify, NT_HEADER, env_header_observer, win_env);
  notify_observer_add(win_env->notify, NT_WINDOW, env_window_observer, win_env);
 
  struct EnvelopeWindowData *wdata = env_wdata_new();
  wdata->fcc = fcc;
  wdata->email = e;
  wdata->sub = sub;
  wdata->is_news = OptNewsSend;
 
  win_env->wdata = wdata;
  win_env->wdata_free = env_wdata_free;
  win_env->recalc = env_recalc;
  win_env->repaint = env_repaint;
 
  return win_env;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

Prompts

const char* const Prompts[]

Names of header fields used in the envelope, e.g. From:, To:

Definition at line 89 of file window.c.

                              {
  /* L10N: Compose menu field.  May not want to translate. */
  N_("From: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("To: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Cc: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Bcc: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Subject: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Reply-To: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Fcc: "),
  /* L10N: Compose menu field.  Holds "Encrypt", "Sign" related information */
  N_("Security: "),
  /* L10N: This string is used by the compose menu.
     Since it is hidden by default, it does not increase the indentation of
     other compose menu fields.  However, if possible, it should not be longer
     than the other compose menu fields.  Since it shares the row with "Encrypt
     with:", it should not be longer than 15-20 character cells.  */
  N_("Sign as: "),
#ifdef USE_AUTOCRYPT
  // L10N: The compose menu autocrypt line
  N_("Autocrypt: "),
#endif
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Newsgroups: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("Followup-To: "),
  /* L10N: Compose menu field.  May not want to translate. */
  N_("X-Comment-To: "),
  N_("Headers: "),
};

AutocryptRecUiFlags

const char* const AutocryptRecUiFlags[]

static

Initial value:

= {
  
  N_("Off"),
  
  N_("No"),
  
  N_("Discouraged"),
  
  N_("Available"),
  
  N_("Yes"),
}

Autocrypt "recommendation" strings.

Definition at line 127 of file window.c.

                                                 {
  /* L10N: Autocrypt recommendation flag: off.
     This is displayed when Autocrypt is turned off. */
  N_("Off"),
  /* L10N: Autocrypt recommendation flag: no.
     This is displayed when Autocrypt cannot encrypt to the recipients. */
  N_("No"),
  /* L10N: Autocrypt recommendation flag: discouraged.
     This is displayed when Autocrypt believes encryption should not be used.
     This might occur if one of the recipient Autocrypt Keys has not been
     used recently, or if the only key available is a Gossip Header key. */
  N_("Discouraged"),
  /* L10N: Autocrypt recommendation flag: available.
     This is displayed when Autocrypt believes encryption is possible, but
     leaves enabling it up to the sender.  Probably because "prefer encrypt"
     is not set in both the sender and recipient keys. */
  N_("Available"),
  /* L10N: Autocrypt recommendation flag: yes.
     This is displayed when Autocrypt would normally enable encryption
     automatically. */
  N_("Yes"),
};