NeoMutt  2023-05-17-56-ga67199
Teaching an old dog new tricks
DOXYGEN
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 "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. More...
 
#define MAX_USER_HDR_ROWS   5
 Maximum number of rows to use for the Headers: field. More...
 

Functions

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

Variables

static int HeaderPadding [HDR_ATTACH_TITLE] = { 0 }
 Number of padding spaces needed after each of the strings in Prompts after translation. More...
 
static int MaxHeaderWidth = 0
 Widest of the Prompts strings after translation. More...
 
const char *const Prompts []
 Names of header fields used in the envelope, e.g. From:, To: More...
 
static const char *const AutocryptRecUiFlags []
 Autocrypt "recommendation" strings. More...
 

Detailed Description

Envelope Window.

Authors
  • Richard Russon

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 81 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 84 of file window.c.

Function Documentation

◆ calc_header_width_padding()

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

Calculate the width needed for the compose labels.

Parameters
idxStore the result at this index of HeaderPadding
headerHeader string
calc_maxIf true, calculate the maximum width

Definition at line 166 of file window.c.

167{
168 int width;
169
170 HeaderPadding[idx] = mutt_str_len(header);
171 width = mutt_strwidth(header);
172 if (calc_max && (MaxHeaderWidth < width))
173 MaxHeaderWidth = width;
174 HeaderPadding[idx] -= width;
175}
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:914
static int HeaderPadding[HDR_ATTACH_TITLE]
Number of padding spaces needed after each of the strings in Prompts after translation.
Definition: window.c:87
static int MaxHeaderWidth
Widest of the Prompts strings after translation.
Definition: window.c:89
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568
+ 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 HeaderPadding to strlen - width. Then, afterwards, we go through and add max_width to each entry.

Definition at line 185 of file window.c.

186{
187 static bool done = false;
188
189 if (done)
190 return;
191 done = true;
192
193 for (int i = 0; i < HDR_ATTACH_TITLE; i++)
194 {
195 if (i == HDR_CRYPTINFO)
196 continue;
197 calc_header_width_padding(i, _(Prompts[i]), true);
198 }
199
200 /* Don't include "Sign as: " in the MaxHeaderWidth calculation. It
201 * doesn't show up by default, and so can make the indentation of
202 * the other fields look funny. */
204
205 for (int i = 0; i < HDR_ATTACH_TITLE; i++)
206 {
208 if (HeaderPadding[i] < 0)
209 HeaderPadding[i] = 0;
210 }
211}
@ HDR_ATTACH_TITLE
The "-- Attachments" line.
Definition: private.h:56
@ HDR_CRYPTINFO
"Sign as:" field (encryption/signing info)
Definition: private.h:46
const char *const Prompts[]
Names of header fields used in the envelope, e.g. From:, To:
Definition: window.c:92
static void calc_header_width_padding(int idx, const char *header, bool calc_max)
Calculate the width needed for the compose labels.
Definition: window.c:166
#define _(a)
Definition: message.h:28
+ 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]alAddress List
[in]colsScreen columns available
[out]srowsRows needed
Return values
numRows needed
Note
Number of rows is capped at MAX_ADDR_ROWS

Definition at line 222 of file window.c.

223{
224 struct ListHead slist = STAILQ_HEAD_INITIALIZER(slist);
225 mutt_addrlist_write_list(al, &slist);
226
227 int rows = 1;
228 int addr_len;
229 int width_left = cols;
230 struct ListNode *next = NULL;
231 struct ListNode *np = NULL;
232 STAILQ_FOREACH(np, &slist, entries)
233 {
234 next = STAILQ_NEXT(np, entries);
235 addr_len = mutt_strwidth(np->data);
236 if (next)
237 addr_len += 2; // ", "
238
239 try_again:
240 if (addr_len >= width_left)
241 {
242 if (width_left == cols)
243 break;
244
245 rows++;
246 width_left = cols;
247 goto try_again;
248 }
249
250 if (addr_len < width_left)
251 width_left -= addr_len;
252 }
253
254 mutt_list_free(&slist);
255
256 *srows = MIN(rows, MAX_ADDR_ROWS);
257 return *srows;
258}
size_t mutt_addrlist_write_list(const struct AddressList *al, struct ListHead *list)
Write Addresses to a List.
Definition: address.c:1206
#define MAX_ADDR_ROWS
Maximum number of rows to use for the To:, Cc:, Bcc: fields.
Definition: window.c:81
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:122
#define MIN(a, b)
Definition: memory.h:31
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
+ 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
eEmail
rowsRows needed
subConfigSubset
Return values
numRows needed

Definition at line 267 of file window.c.

268{
270 *rows = 0; // Neither PGP nor SMIME are built into NeoMutt
271 else if ((e->security & (SEC_ENCRYPT | SEC_SIGN)) != 0)
272 *rows = 2; // 'Security:' and 'Sign as:'
273 else
274 *rows = 1; // Just 'Security:'
275
276#ifdef USE_AUTOCRYPT
277 const bool c_autocrypt = cs_subset_bool(sub, "autocrypt");
278 if (c_autocrypt)
279 *rows += 1;
280#endif
281
282 return *rows;
283}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define WithCrypto
Definition: lib.h:116
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:41
+ 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
hdrsHeader List
Return values
numRows needed, limited to MAX_USER_HDR_ROWS

Definition at line 290 of file window.c.

291{
292 int rows = 0; /* Don't print at all if no custom headers*/
293 struct ListNode *np = NULL;
294 STAILQ_FOREACH(np, hdrs, entries)
295 {
296 if (rows == MAX_USER_HDR_ROWS)
297 break;
298 rows++;
299 }
300 return rows;
301}
#define MAX_USER_HDR_ROWS
Maximum number of rows to use for the Headers: field.
Definition: window.c:84
+ 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
winWindow to draw on
wdataEnvelope Window data
Return values
numRows needed

Definition at line 309 of file window.c.

310{
311 int rows = 4; // 'From:', 'Subject:', 'Reply-To:', 'Fcc:'
312#ifdef MIXMASTER
313 rows++;
314#endif
315
316 struct Email *e = wdata->email;
317 struct Envelope *env = e->env;
318 const int cols = win->state.cols - MaxHeaderWidth;
319
320#ifdef USE_NNTP
321 if (wdata->is_news)
322 {
323 rows += 2; // 'Newsgroups:' and 'Followup-To:'
324 const bool c_x_comment_to = cs_subset_bool(wdata->sub, "x_comment_to");
325 if (c_x_comment_to)
326 rows++;
327 }
328 else
329#endif
330 {
331 rows += calc_address(&env->to, cols, &wdata->to_rows);
332 rows += calc_address(&env->cc, cols, &wdata->cc_rows);
333 rows += calc_address(&env->bcc, cols, &wdata->bcc_rows);
334 }
335 rows += calc_security(e, &wdata->sec_rows, wdata->sub);
336 const bool c_compose_show_user_headers = cs_subset_bool(wdata->sub, "compose_show_user_headers");
337 if (c_compose_show_user_headers)
338 rows += calc_user_hdrs(&env->userhdrs);
339
340 return rows;
341}
static int calc_address(struct AddressList *al, short cols, short *srows)
Calculate how many rows an AddressList will need.
Definition: window.c:222
static int calc_user_hdrs(const struct ListHead *hdrs)
Calculate how many rows are needed for user-defined headers.
Definition: window.c:290
static int calc_security(struct Email *e, short *rows, const struct ConfigSubset *sub)
Calculate how many rows the security info will need.
Definition: window.c:267
The envelope/body of an email.
Definition: email.h:37
struct Envelope * env
Envelope information.
Definition: email.h:66
bool is_news
Email is a news article.
Definition: wdata.h:49
struct Email * email
Email being composed.
Definition: wdata.h:40
short sec_rows
Number of rows used by the security fields.
Definition: wdata.h:46
short cc_rows
Number of rows used by the 'Cc:' field.
Definition: wdata.h:44
struct ConfigSubset * sub
Inherited config items.
Definition: wdata.h:39
short to_rows
Number of rows used by the 'To:' field.
Definition: wdata.h:43
short bcc_rows
Number of rows used by the 'Bcc:' field.
Definition: wdata.h:45
The header of an Email.
Definition: envelope.h:57
struct ListHead userhdrs
user defined headers
Definition: envelope.h:87
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
+ 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
winWindow to draw on
colColumn to draw at
rowRow to draw at
textText to display

Definition at line 350 of file window.c.

351{
353 mutt_window_mvprintw(win, col, row, "%s", text);
355}
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:57
@ MT_COLOR_COMPOSE_HEADER
Header labels, e.g. From:
Definition: color.h:44
struct AttrColor * mutt_curses_set_normal_backed_color_by_id(enum ColorId cid)
Set the colour and attributes by the colour id.
Definition: mutt_curses.c:65
struct AttrColor * mutt_curses_set_color_by_id(enum ColorId cid)
Set the colour and attributes by the colour id.
Definition: mutt_curses.c:81
int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt,...)
Move the cursor and write a formatted string to a Window.
Definition: mutt_window.c:323
+ 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
winWindow to draw on
rowRow to draw at
fieldField to display, e.g. HDR_FROM

Definition at line 363 of file window.c.

+ 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
winWindow to draw on
rowRow to draw at
fieldField to display, e.g. HDR_FROM
contentText to display

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

Definition at line 379 of file window.c.

381{
382 mutt_window_move(win, HeaderPadding[field], row);
383 mutt_paddstr(win, win->state.cols - HeaderPadding[field], content);
384}
void mutt_paddstr(struct MuttWindow *win, int n, const char *s)
Display a string on screen, padded if necessary.
Definition: curs_lib.c:819
int mutt_window_move(struct MuttWindow *win, int col, int row)
Move the cursor in a Window.
Definition: mutt_window.c:294
+ 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
winWindow to draw on
wdataEnvelope Window data
rowWindow row to start drawing
Return values
numNumber of lines used

Definition at line 393 of file window.c.

394{
395 struct Email *e = wdata->email;
396
397 draw_header(win, row++, HDR_CRYPT);
398
400 return 0;
401
402 // We'll probably need two lines for 'Security:' and 'Sign as:'
403 int used = 2;
404 if ((e->security & (SEC_ENCRYPT | SEC_SIGN)) == (SEC_ENCRYPT | SEC_SIGN))
405 {
407 mutt_window_addstr(win, _("Sign, Encrypt"));
408 }
409 else if (e->security & SEC_ENCRYPT)
410 {
412 mutt_window_addstr(win, _("Encrypt"));
413 }
414 else if (e->security & SEC_SIGN)
415 {
417 mutt_window_addstr(win, _("Sign"));
418 }
419 else
420 {
421 /* L10N: This refers to the encryption of the email, e.g. "Security: None" */
423 mutt_window_addstr(win, _("None"));
424 used = 1; // 'Sign as:' won't be needed
425 }
427
428 if ((e->security & (SEC_ENCRYPT | SEC_SIGN)))
429 {
430 if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
431 {
432 if ((e->security & SEC_INLINE))
433 mutt_window_addstr(win, _(" (inline PGP)"));
434 else
435 mutt_window_addstr(win, _(" (PGP/MIME)"));
436 }
437 else if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
438 {
439 mutt_window_addstr(win, _(" (S/MIME)"));
440 }
441 }
442
443 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(wdata->sub, "crypt_opportunistic_encrypt");
444 if (c_crypt_opportunistic_encrypt && (e->security & SEC_OPPENCRYPT))
445 mutt_window_addstr(win, _(" (OppEnc mode)"));
446
448
449 if (((WithCrypto & APPLICATION_PGP) != 0) &&
450 (e->security & APPLICATION_PGP) && (e->security & SEC_SIGN))
451 {
452 draw_header(win, row++, HDR_CRYPTINFO);
453 const char *const c_pgp_sign_as = cs_subset_string(wdata->sub, "pgp_sign_as");
454 mutt_window_printf(win, "%s", c_pgp_sign_as ? c_pgp_sign_as : _("<default>"));
455 }
456
457 if (((WithCrypto & APPLICATION_SMIME) != 0) &&
459 {
460 draw_header(win, row++, HDR_CRYPTINFO);
461 const char *const c_smime_sign_as = cs_subset_string(wdata->sub, "smime_sign_as");
462 mutt_window_printf(win, "%s", c_smime_sign_as ? c_smime_sign_as : _("<default>"));
463 }
464
465 const char *const c_smime_encrypt_with = cs_subset_string(wdata->sub, "smime_encrypt_with");
466 if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME) &&
467 (e->security & SEC_ENCRYPT) && c_smime_encrypt_with)
468 {
469 draw_floating(win, 40, row - 1, _("Encrypt with: "));
470 mutt_window_printf(win, "%s", NONULL(c_smime_encrypt_with));
471 }
472
473#ifdef USE_AUTOCRYPT
474 const bool c_autocrypt = cs_subset_bool(wdata->sub, "autocrypt");
475 if (c_autocrypt)
476 {
477 draw_header(win, row, HDR_AUTOCRYPT);
478 if (e->security & SEC_AUTOCRYPT)
479 {
481 mutt_window_addstr(win, _("Encrypt"));
482 }
483 else
484 {
486 mutt_window_addstr(win, _("Off"));
487 }
488
489 /* L10N: The autocrypt compose menu Recommendation field.
490 Displays the output of the recommendation engine
491 (Off, No, Discouraged, Available, Yes) */
492 draw_floating(win, 40, row, _("Recommendation: "));
494
495 used++;
496 }
497#endif
498 return used;
499}
@ MT_COLOR_COMPOSE_SECURITY_ENCRYPT
Mail will be encrypted.
Definition: color.h:46
@ MT_COLOR_COMPOSE_SECURITY_NONE
Mail will not be encrypted or signed.
Definition: color.h:47
@ MT_COLOR_COMPOSE_SECURITY_BOTH
Mail will be encrypted and signed.
Definition: color.h:45
@ MT_COLOR_COMPOSE_SECURITY_SIGN
Mail will be signed.
Definition: color.h:48
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
@ HDR_AUTOCRYPT
"Autocrypt:" and "Recommendation:" fields
Definition: private.h:48
@ HDR_CRYPT
"Security:" field (encryption/signing info)
Definition: private.h:45
static const char *const AutocryptRecUiFlags[]
Autocrypt "recommendation" strings.
Definition: window.c:136
static void draw_header(struct MuttWindow *win, int row, enum HeaderField field)
Draw an aligned label.
Definition: window.c:363
static void draw_floating(struct MuttWindow *win, int col, int row, const char *text)
Draw a floating label.
Definition: window.c:350
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:425
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:410
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:241
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:85
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:87
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:86
#define NONULL(x)
Definition: string2.h:37
enum AutocryptRec autocrypt_rec
Autocrypt recommendation.
Definition: wdata.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ draw_mix_line()

static void draw_mix_line ( struct ListHead *  chain,
struct MuttWindow win,
int  row 
)
static

Redraw the Mixmaster chain.

Parameters
chainList of chain links
winWindow to draw on
rowWindow row to start drawing

Definition at line 508 of file window.c.

509{
510 char *t = NULL;
511
512 draw_header(win, row, HDR_MIX);
513
514 if (STAILQ_EMPTY(chain))
515 {
516 mutt_window_addstr(win, _("<no chain defined>"));
518 return;
519 }
520
521 int c = 12;
522 struct ListNode *np = NULL;
523 STAILQ_FOREACH(np, chain, entries)
524 {
525 t = np->data;
526 if (t && (t[0] == '0') && (t[1] == '\0'))
527 t = "<random>";
528
529 if (c + mutt_str_len(t) + 2 >= win->state.cols)
530 break;
531
532 mutt_window_addstr(win, NONULL(t));
533 if (STAILQ_NEXT(np, entries))
534 mutt_window_addstr(win, ", ");
535
536 c += mutt_str_len(t) + 2;
537 }
538}
@ HDR_MIX
"Mix:" field (Mixmaster chain)
Definition: private.h:43
#define STAILQ_EMPTY(head)
Definition: queue.h:348
+ 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
fieldField to display, e.g. HDR_FROM
alAddress list to write
winWindow
rowWindow row to start drawing
max_linesHow many lines may be used
Return values
numLines used

Definition at line 550 of file window.c.

552{
553 draw_header(win, row, field);
554
555 struct ListHead list = STAILQ_HEAD_INITIALIZER(list);
556 int count = mutt_addrlist_count_recips(al);
557
558 int lines_used = 1;
559 int width_left = win->state.cols - MaxHeaderWidth;
560 char more[32] = { 0 };
561 int more_len = 0;
562
563 struct Buffer *buf = buf_pool_get();
564 bool in_group = false;
565 char *sep = NULL;
566 struct Address *addr = NULL;
567 TAILQ_FOREACH(addr, al, entries)
568 {
569 struct Address *next = TAILQ_NEXT(addr, entries);
570
571 if (addr->group)
572 {
573 in_group = true;
574 }
575
576 buf_reset(buf);
577 mutt_addr_write(buf, addr, true);
578 size_t addr_len = buf_len(buf);
579
580 sep = "";
581 if (!addr->group)
582 {
583 // group terminator
584 if (in_group && next && !next->mailbox && !next->personal)
585 {
586 sep = ";";
587 addr_len += 1;
588 in_group = false;
589 }
590 else if (next)
591 {
592 sep = ", ";
593 addr_len += 2;
594 }
595 }
596
597 count--;
598 try_again:
599 more_len = snprintf(more, sizeof(more),
600 ngettext("(+%d more)", "(+%d more)", count), count);
601 mutt_debug(LL_DEBUG3, "text: '%s' len: %d\n", more, more_len);
602
603 int reserve = ((count > 0) && (lines_used == max_lines)) ? more_len : 0;
604 mutt_debug(LL_DEBUG3, "processing: %s (al:%d, wl:%d, r:%d, lu:%d)\n", buf,
605 addr_len, width_left, reserve, lines_used);
606 if (addr_len >= (width_left - reserve))
607 {
608 mutt_debug(LL_DEBUG3, "not enough space\n");
609 if (lines_used == max_lines)
610 {
611 mutt_debug(LL_DEBUG3, "no more lines\n");
612 mutt_debug(LL_DEBUG3, "truncating: %s\n", buf);
613 mutt_paddstr(win, width_left, buf_string(buf));
614 break;
615 }
616
617 if (width_left == (win->state.cols - MaxHeaderWidth))
618 {
619 mutt_debug(LL_DEBUG3, "couldn't print: %s\n", buf);
620 mutt_paddstr(win, width_left, buf_string(buf));
621 break;
622 }
623
624 mutt_debug(LL_DEBUG3, "start a new line\n");
626 row++;
627 lines_used++;
628 width_left = win->state.cols - MaxHeaderWidth;
630 goto try_again;
631 }
632
633 if (addr_len < width_left)
634 {
635 mutt_debug(LL_DEBUG3, "space for: %s\n", buf);
637 mutt_window_addstr(win, sep);
638 width_left -= addr_len;
639 }
640 mutt_debug(LL_DEBUG3, "%d addresses remaining\n", count);
641 mutt_debug(LL_DEBUG3, "%ld lines remaining\n", max_lines - lines_used);
642 }
643 mutt_list_free(&list);
644 buf_pool_release(&buf);
645
646 if (count > 0)
647 {
648 mutt_window_move(win, win->state.cols - more_len, row);
650 mutt_window_addstr(win, more);
652 mutt_debug(LL_DEBUG3, "%d more (len %d)\n", count, more_len);
653 }
654 else
655 {
657 }
658
659 for (int i = lines_used; i < max_lines; i++)
660 {
661 mutt_window_move(win, 0, row + i);
663 }
664
665 mutt_debug(LL_DEBUG3, "used %d lines\n", lines_used);
666 return lines_used;
667}
size_t mutt_addr_write(struct Buffer *buf, struct Address *addr, bool display)
Write a single Address to a buffer.
Definition: address.c:1035
int mutt_addrlist_count_recips(const struct AddressList *al)
Count the number of Addresses with valid recipients.
Definition: address.c:857
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:460
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:88
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:90
@ MT_COLOR_BOLD
Bold text.
Definition: color.h:43
#define mutt_debug(LEVEL,...)
Definition: logging2.h:87
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:45
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_NEXT(elm, field)
Definition: queue.h:832
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
bool group
Group mailbox?
Definition: address.h:39
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
String manipulation buffer.
Definition: buffer.h:34
+ 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
winWindow to draw on
wdataEnvelope Window data
rowWindow row to start drawing from
Return values
numRows used

Definition at line 676 of file window.c.

678{
679 const char *overflow_text = "...";
680 int rows_used = 0;
681
682 struct ListNode *first = STAILQ_FIRST(&wdata->email->env->userhdrs);
683 if (!first)
684 return rows_used;
685
686 /* Draw first entry on same line as prompt */
688 mutt_paddstr(win,
691 first->data);
692 rows_used++;
693
694 /* Draw any following entries on their own line */
695 struct ListNode *np = STAILQ_NEXT(first, entries);
696 if (!np)
697 return rows_used;
698
699 STAILQ_FOREACH_FROM(np, &wdata->email->env->userhdrs, entries)
700 {
701 if ((rows_used == (MAX_USER_HDR_ROWS - 1)) && STAILQ_NEXT(np, entries))
702 {
703 draw_header_content(win, row + rows_used, HDR_CUSTOM_HEADERS, overflow_text);
704 rows_used++;
705 break;
706 }
707 draw_header_content(win, row + rows_used, HDR_CUSTOM_HEADERS, np->data);
708 rows_used++;
709 }
710 return rows_used;
711}
@ HDR_CUSTOM_HEADERS
"Headers:" field
Definition: private.h:55
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.
Definition: window.c:379
#define STAILQ_FIRST(head)
Definition: queue.h:350
#define STAILQ_FOREACH_FROM(var, head, field)
Definition: queue.h:357
+ 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
winWindow to draw on
wdataEnvelope Window data

Definition at line 718 of file window.c.

719{
720 struct Email *e = wdata->email;
721 const char *fcc = buf_string(wdata->fcc);
722 const int cols = win->state.cols - MaxHeaderWidth;
723
725 int row = draw_envelope_addr(HDR_FROM, &e->env->from, win, 0, 1);
726
727#ifdef USE_NNTP
728 if (wdata->is_news)
729 {
730 draw_header(win, row++, HDR_NEWSGROUPS);
731 mutt_paddstr(win, cols, NONULL(e->env->newsgroups));
732
733 draw_header(win, row++, HDR_FOLLOWUPTO);
734 mutt_paddstr(win, cols, NONULL(e->env->followup_to));
735
736 const bool c_x_comment_to = cs_subset_bool(wdata->sub, "x_comment_to");
737 if (c_x_comment_to)
738 {
739 draw_header(win, row++, HDR_XCOMMENTTO);
740 mutt_paddstr(win, cols, NONULL(e->env->x_comment_to));
741 }
742 }
743 else
744#endif
745 {
746 row += draw_envelope_addr(HDR_TO, &e->env->to, win, row, wdata->to_rows);
747 row += draw_envelope_addr(HDR_CC, &e->env->cc, win, row, wdata->cc_rows);
748 row += draw_envelope_addr(HDR_BCC, &e->env->bcc, win, row, wdata->bcc_rows);
749 }
750
751 draw_header(win, row++, HDR_SUBJECT);
752 mutt_paddstr(win, cols, NONULL(e->env->subject));
753
754 row += draw_envelope_addr(HDR_REPLYTO, &e->env->reply_to, win, row, 1);
755
756 draw_header(win, row++, HDR_FCC);
757 mutt_paddstr(win, cols, fcc);
758
759 if (WithCrypto)
760 row += draw_crypt_lines(win, wdata, row);
761
762#ifdef MIXMASTER
763 draw_mix_line(&e->chain, win, row++);
764#endif
765 const bool c_compose_show_user_headers = cs_subset_bool(wdata->sub, "compose_show_user_headers");
766 if (c_compose_show_user_headers)
767 row += draw_envelope_user_hdrs(win, wdata, row);
768
770}
@ HDR_SUBJECT
"Subject:" field
Definition: private.h:39
@ HDR_REPLYTO
"Reply-To:" field
Definition: private.h:40
@ HDR_FCC
"Fcc:" (save folder) field
Definition: private.h:41
@ HDR_CC
"Cc:" field
Definition: private.h:37
@ HDR_TO
"To:" field
Definition: private.h:36
@ HDR_BCC
"Bcc:" field
Definition: private.h:38
@ HDR_FOLLOWUPTO
"Followup-To:" field
Definition: private.h:52
@ HDR_XCOMMENTTO
"X-Comment-To:" field
Definition: private.h:53
@ HDR_NEWSGROUPS
"Newsgroups:" field
Definition: private.h:51
@ HDR_FROM
"From:" field
Definition: private.h:35
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.
Definition: window.c:550
static void draw_mix_line(struct ListHead *chain, struct MuttWindow *win, int row)
Redraw the Mixmaster chain.
Definition: window.c:508
static int draw_envelope_user_hdrs(struct MuttWindow *win, struct EnvelopeWindowData *wdata, int row)
Write user-defined headers to the compose window.
Definition: window.c:676
static int draw_crypt_lines(struct MuttWindow *win, struct EnvelopeWindowData *wdata, int row)
Update the encryption info in the compose window.
Definition: window.c:393
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition: mutt_window.c:696
struct ListHead chain
Mixmaster chain.
Definition: email.h:89
struct Buffer * fcc
Where the outgoing Email will be saved.
Definition: wdata.h:41
char * followup_to
List of 'followup-to' fields.
Definition: envelope.h:81
struct AddressList reply_to
Email's 'reply-to'.
Definition: envelope.h:64
char * x_comment_to
List of 'X-comment-to' fields.
Definition: envelope.h:82
char * newsgroups
List of newsgroups.
Definition: envelope.h:79
char * subject
Email's subject.
Definition: envelope.h:70
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
+ 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
eEmail
fccBuffer to save FCC
subConfigSubset
Return values
ptrNew Window

Definition at line 999 of file window.c.

1000{
1002
1005 HDR_ATTACH_TITLE - 1);
1006
1012
1013 struct EnvelopeWindowData *wdata = env_wdata_new();
1014 wdata->fcc = fcc;
1015 wdata->email = e;
1016 wdata->sub = sub;
1017 wdata->is_news = OptNewsSend;
1018
1019 win_env->wdata = wdata;
1020 win_env->wdata_free = env_wdata_free;
1021 win_env->recalc = env_recalc;
1022 win_env->repaint = env_repaint;
1023
1024 return win_env;
1025}
struct EnvelopeWindowData * env_wdata_new(void)
Create new Envelope Data.
Definition: wdata.c:48
static void init_header_padding(void)
Calculate how much padding the compose table will need.
Definition: window.c:185
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: globals.c:80
static int env_email_observer(struct NotifyCallback *nc)
Notification that the Email has changed - Implements observer_t -.
Definition: window.c:897
static int env_color_observer(struct NotifyCallback *nc)
Notification that a Color has changed - Implements observer_t -.
Definition: window.c:808
static int env_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: window.c:960
static int env_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: window.c:844
static int env_header_observer(struct NotifyCallback *nc)
Notification that a User Header has changed - Implements observer_t -.
Definition: window.c:921
static int env_recalc(struct MuttWindow *win)
Recalculate the Window data - Implements MuttWindow::recalc() -.
Definition: window.c:775
static int env_repaint(struct MuttWindow *win)
Repaint the Window - Implements MuttWindow::repaint() -.
Definition: window.c:796
void env_wdata_free(struct MuttWindow *win, void **ptr)
Free the Envelope Data - Implements MuttWindow::wdata_free() -.
Definition: wdata.c:39
bool notify_observer_add(struct Notify *notify, enum NotifyType type, observer_t callback, void *global_data)
Add an observer to an object.
Definition: notify.c:189
struct MuttWindow * mutt_window_new(enum WindowType type, enum MuttWindowOrientation orient, enum MuttWindowSize size, int cols, int rows)
Create a new Window.
Definition: mutt_window.c:180
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:95
@ MUTT_WIN_ORIENT_VERTICAL
Window uses all available vertical space.
Definition: mutt_window.h:38
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:52
@ MUTT_WIN_SIZE_FIXED
Window has a fixed size.
Definition: mutt_window.h:47
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:55
@ NT_CONFIG
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:43
@ NT_COLOR
Colour has changed, NotifyColor, EventColor.
Definition: notify_type.h:41
@ NT_HEADER
A header has changed, NotifyHeader EventHeader.
Definition: notify_type.h:47
@ NT_ALL
Register for all notifications.
Definition: notify_type.h:35
struct Notify * notify
Notifications: NotifyEmail, EventEmail.
Definition: email.h:71
Data to fill the Envelope Window.
Definition: wdata.h:38
int(* repaint)(struct MuttWindow *win)
Definition: mutt_window.h:181
void * wdata
Private data.
Definition: mutt_window.h:145
struct Notify * notify
Notifications: NotifyWindow, EventWindow.
Definition: mutt_window.h:138
int(* recalc)(struct MuttWindow *win)
Definition: mutt_window.h:170
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:159
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct Notify * notify
Notifications handler.
Definition: neomutt.h:38
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ HeaderPadding

int HeaderPadding[HDR_ATTACH_TITLE] = { 0 }
static

Number of padding spaces needed after each of the strings in Prompts after translation.

Definition at line 87 of file window.c.

◆ MaxHeaderWidth

int MaxHeaderWidth = 0
static

Widest of the Prompts strings after translation.

Definition at line 89 of file window.c.

◆ Prompts

const char* const Prompts[]

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

Definition at line 92 of file window.c.

◆ AutocryptRecUiFlags

const char* const AutocryptRecUiFlags[]
static
Initial value:
= {
N_("Off"),
N_("No"),
N_("Discouraged"),
N_("Available"),
N_("Yes"),
}
#define N_(a)
Definition: message.h:32

Autocrypt "recommendation" strings.

Definition at line 136 of file window.c.