NeoMutt  2025-01-09-37-ge46230
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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.
 
#define MAX_USER_HDR_ROWS   5
 Maximum number of rows to use for the Headers: field.
 

Functions

static void calc_header_width_padding (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 MuttWindowenv_window_new (struct Email *e, struct Buffer *fcc, struct ConfigSubset *sub)
 Create the Envelope Window.
 

Variables

static int HeaderPadding [HDR_ATTACH_TITLE] = { 0 }
 Number of padding spaces needed after each of the strings in Prompts after translation.
 
static int MaxHeaderWidth = 0
 Widest of the Prompts strings after translation.
 
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

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 82 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 85 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 161 of file window.c.

162{
163 int width;
164
165 HeaderPadding[idx] = mutt_str_len(header);
166 width = mutt_strwidth(header);
167 if (calc_max && (MaxHeaderWidth < width))
168 MaxHeaderWidth = width;
169 HeaderPadding[idx] -= width;
170}
size_t mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:444
static int HeaderPadding[HDR_ATTACH_TITLE]
Number of padding spaces needed after each of the strings in Prompts after translation.
Definition: window.c:88
static int MaxHeaderWidth
Widest of the Prompts strings after translation.
Definition: window.c:90
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
+ 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 180 of file window.c.

181{
182 static bool done = false;
183
184 if (done)
185 return;
186 done = true;
187
188 for (int i = 0; i < HDR_ATTACH_TITLE; i++)
189 {
190 if (i == HDR_CRYPTINFO)
191 continue;
192 calc_header_width_padding(i, _(Prompts[i]), true);
193 }
194
195 /* Don't include "Sign as: " in the MaxHeaderWidth calculation. It
196 * doesn't show up by default, and so can make the indentation of
197 * the other fields look funny. */
199
200 for (int i = 0; i < HDR_ATTACH_TITLE; i++)
201 {
203 if (HeaderPadding[i] < 0)
204 HeaderPadding[i] = 0;
205 }
206}
@ HDR_ATTACH_TITLE
The "-- Attachments" line.
Definition: private.h:51
@ HDR_CRYPTINFO
"Sign as:" field (encryption/signing info)
Definition: private.h:43
const char *const Prompts[]
Names of header fields used in the envelope, e.g. From:, To:
Definition: window.c:93
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:161
#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 217 of file window.c.

218{
219 struct ListHead slist = STAILQ_HEAD_INITIALIZER(slist);
220 mutt_addrlist_write_list(al, &slist);
221
222 short rows = 1;
223 int addr_len;
224 int width_left = cols;
225 struct ListNode *next = NULL;
226 struct ListNode *np = NULL;
227 STAILQ_FOREACH(np, &slist, entries)
228 {
229 next = STAILQ_NEXT(np, entries);
230 addr_len = mutt_strwidth(np->data);
231 if (next)
232 addr_len += 2; // ", "
233
234 try_again:
235 if (addr_len >= width_left)
236 {
237 if (width_left == cols)
238 break;
239
240 rows++;
241 width_left = cols;
242 goto try_again;
243 }
244
245 if (addr_len < width_left)
246 width_left -= addr_len;
247 }
248
249 mutt_list_free(&slist);
250
251 *srows = MIN(rows, MAX_ADDR_ROWS);
252 return *srows;
253}
size_t mutt_addrlist_write_list(const struct AddressList *al, struct ListHead *list)
Write Addresses to a List.
Definition: address.c:1217
#define MAX_ADDR_ROWS
Maximum number of rows to use for the To:, Cc:, Bcc: fields.
Definition: window.c:82
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
#define MIN(a, b)
Definition: memory.h:32
#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:37
char * data
String.
Definition: list.h:38
+ 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 262 of file window.c.

263{
265 *rows = 0; // Neither PGP nor SMIME are built into NeoMutt
266 else if ((e->security & (SEC_ENCRYPT | SEC_SIGN)) != 0)
267 *rows = 2; // 'Security:' and 'Sign as:'
268 else
269 *rows = 1; // Just 'Security:'
270
271#ifdef USE_AUTOCRYPT
272 const bool c_autocrypt = cs_subset_bool(sub, "autocrypt");
273 if (c_autocrypt)
274 *rows += 1;
275#endif
276
277 return *rows;
278}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:96
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:97
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:84
#define WithCrypto
Definition: lib.h:122
#define SEC_SIGN
Email is signed.
Definition: lib.h:85
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:43
+ 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 285 of file window.c.

286{
287 int rows = 0; /* Don't print at all if no custom headers*/
288 struct ListNode *np = NULL;
289 STAILQ_FOREACH(np, hdrs, entries)
290 {
291 if (rows == MAX_USER_HDR_ROWS)
292 break;
293 rows++;
294 }
295 return rows;
296}
#define MAX_USER_HDR_ROWS
Maximum number of rows to use for the Headers: field.
Definition: window.c:85
+ 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 304 of file window.c.

305{
306 int rows = 4; // 'From:', 'Subject:', 'Reply-To:', 'Fcc:'
307 struct Email *e = wdata->email;
308
309 struct Envelope *env = e->env;
310 const int cols = win->state.cols - MaxHeaderWidth;
311
312 if (wdata->is_news)
313 {
314 rows += 2; // 'Newsgroups:' and 'Followup-To:'
315 const bool c_x_comment_to = cs_subset_bool(wdata->sub, "x_comment_to");
316 if (c_x_comment_to)
317 rows++;
318 }
319 else
320 {
321 rows += calc_address(&env->to, cols, &wdata->to_rows);
322 rows += calc_address(&env->cc, cols, &wdata->cc_rows);
323 rows += calc_address(&env->bcc, cols, &wdata->bcc_rows);
324 }
325 rows += calc_security(e, &wdata->sec_rows, wdata->sub);
326 const bool c_compose_show_user_headers = cs_subset_bool(wdata->sub, "compose_show_user_headers");
327 if (c_compose_show_user_headers)
328 rows += calc_user_hdrs(&env->userhdrs);
329
330 return rows;
331}
static int calc_address(struct AddressList *al, short cols, short *srows)
Calculate how many rows an AddressList will need.
Definition: window.c:217
static int calc_user_hdrs(const struct ListHead *hdrs)
Calculate how many rows are needed for user-defined headers.
Definition: window.c:285
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:262
The envelope/body of an email.
Definition: email.h:39
struct Envelope * env
Envelope information.
Definition: email.h:68
bool is_news
Email is a news article.
Definition: wdata.h:48
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:85
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:61
+ 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 340 of file window.c.

341{
343 mutt_window_move(win, row, col);
344 mutt_window_printf(win, "%s", text);
346}
@ MT_COLOR_NORMAL
Plain text.
Definition: color.h:55
@ MT_COLOR_COMPOSE_HEADER
Header labels, e.g. From:
Definition: color.h:42
const 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:63
const struct AttrColor * mutt_curses_set_color_by_id(enum ColorId cid)
Set the colour and attributes by the Colour ID.
Definition: mutt_curses.c:79
int mutt_window_printf(struct MuttWindow *win, const char *fmt,...)
Write a formatted string to a Window.
Definition: mutt_window.c:393
int mutt_window_move(struct MuttWindow *win, int row, int col)
Move the cursor in a Window.
Definition: mutt_window.c:297
+ 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 354 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 371 of file window.c.

373{
374 mutt_window_move(win, row, HeaderPadding[field]);
375 mutt_paddstr(win, win->state.cols - HeaderPadding[field], content);
376}
void mutt_paddstr(struct MuttWindow *win, int n, const char *s)
Display a string on screen, padded if necessary.
Definition: curs_lib.c:342
+ 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 385 of file window.c.

386{
387 struct Email *e = wdata->email;
388
389 draw_header(win, row++, HDR_CRYPT);
390
392 return 0;
393
394 // We'll probably need two lines for 'Security:' and 'Sign as:'
395 int used = 2;
396 if ((e->security & (SEC_ENCRYPT | SEC_SIGN)) == (SEC_ENCRYPT | SEC_SIGN))
397 {
399 mutt_window_addstr(win, _("Sign, Encrypt"));
400 }
401 else if (e->security & SEC_ENCRYPT)
402 {
404 mutt_window_addstr(win, _("Encrypt"));
405 }
406 else if (e->security & SEC_SIGN)
407 {
409 mutt_window_addstr(win, _("Sign"));
410 }
411 else
412 {
413 /* L10N: This refers to the encryption of the email, e.g. "Security: None" */
415 mutt_window_addstr(win, _("None"));
416 used = 1; // 'Sign as:' won't be needed
417 }
419
420 if ((e->security & (SEC_ENCRYPT | SEC_SIGN)))
421 {
422 if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
423 {
424 if ((e->security & SEC_INLINE))
425 mutt_window_addstr(win, _(" (inline PGP)"));
426 else
427 mutt_window_addstr(win, _(" (PGP/MIME)"));
428 }
429 else if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
430 {
431 mutt_window_addstr(win, _(" (S/MIME)"));
432 }
433 }
434
435 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(wdata->sub, "crypt_opportunistic_encrypt");
436 if (c_crypt_opportunistic_encrypt && (e->security & SEC_OPPENCRYPT))
437 mutt_window_addstr(win, _(" (OppEnc mode)"));
438
440
441 if (((WithCrypto & APPLICATION_PGP) != 0) &&
442 (e->security & APPLICATION_PGP) && (e->security & SEC_SIGN))
443 {
444 draw_header(win, row++, HDR_CRYPTINFO);
445 const char *const c_pgp_sign_as = cs_subset_string(wdata->sub, "pgp_sign_as");
446 mutt_window_printf(win, "%s", c_pgp_sign_as ? c_pgp_sign_as : _("<default>"));
447 }
448
449 if (((WithCrypto & APPLICATION_SMIME) != 0) &&
451 {
452 draw_header(win, row++, HDR_CRYPTINFO);
453 const char *const c_smime_sign_as = cs_subset_string(wdata->sub, "smime_sign_as");
454 mutt_window_printf(win, "%s", c_smime_sign_as ? c_smime_sign_as : _("<default>"));
455 }
456
457 const char *const c_smime_encrypt_with = cs_subset_string(wdata->sub, "smime_encrypt_with");
458 if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME) &&
459 (e->security & SEC_ENCRYPT) && c_smime_encrypt_with)
460 {
461 draw_floating(win, 40, row - 1, _("Encrypt with: "));
462 mutt_window_printf(win, "%s", NONULL(c_smime_encrypt_with));
463 }
464
465#ifdef USE_AUTOCRYPT
466 const bool c_autocrypt = cs_subset_bool(wdata->sub, "autocrypt");
467 if (c_autocrypt)
468 {
469 draw_header(win, row, HDR_AUTOCRYPT);
470 if (e->security & SEC_AUTOCRYPT)
471 {
473 mutt_window_addstr(win, _("Encrypt"));
474 }
475 else
476 {
478 mutt_window_addstr(win, _("Off"));
479 }
480
481 /* L10N: The autocrypt compose menu Recommendation field.
482 Displays the output of the recommendation engine
483 (Off, No, Discouraged, Available, Yes) */
484 draw_floating(win, 40, row, _("Recommendation: "));
486
487 used++;
488 }
489#endif
490 return used;
491}
@ MT_COLOR_COMPOSE_SECURITY_ENCRYPT
Mail will be encrypted.
Definition: color.h:44
@ MT_COLOR_COMPOSE_SECURITY_NONE
Mail will not be encrypted or signed.
Definition: color.h:45
@ MT_COLOR_COMPOSE_SECURITY_BOTH
Mail will be encrypted and signed.
Definition: color.h:43
@ MT_COLOR_COMPOSE_SECURITY_SIGN
Mail will be signed.
Definition: color.h:46
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
@ HDR_AUTOCRYPT
"Autocrypt:" and "Recommendation:" fields
Definition: private.h:45
@ HDR_CRYPT
"Security:" field (encryption/signing info)
Definition: private.h:42
static const char *const AutocryptRecUiFlags[]
Autocrypt "recommendation" strings.
Definition: window.c:131
static void draw_header(struct MuttWindow *win, int row, enum HeaderField field)
Draw an aligned label.
Definition: window.c:354
static void draw_floating(struct MuttWindow *win, int col, int row, const char *text)
Draw a floating label.
Definition: window.c:340
int mutt_window_addstr(struct MuttWindow *win, const char *str)
Write a string to a Window.
Definition: mutt_window.c:378
void mutt_window_clrtoeol(struct MuttWindow *win)
Clear to the end of the line.
Definition: mutt_window.c:244
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:91
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:93
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:92
#define NONULL(x)
Definition: string2.h:37
enum AutocryptRec autocrypt_rec
Autocrypt recommendation.
Definition: wdata.h:50
+ 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 502 of file window.c.

504{
505 draw_header(win, row, field);
506
507 struct ListHead list = STAILQ_HEAD_INITIALIZER(list);
508 int count = mutt_addrlist_count_recips(al);
509
510 int lines_used = 1;
511 int width_left = win->state.cols - MaxHeaderWidth;
512 char more[32] = { 0 };
513 int more_len = 0;
514
515 struct Buffer *buf = buf_pool_get();
516 bool in_group = false;
517 char *sep = NULL;
518 struct Address *addr = NULL;
519 TAILQ_FOREACH(addr, al, entries)
520 {
521 struct Address *next = TAILQ_NEXT(addr, entries);
522
523 if (addr->group)
524 {
525 in_group = true;
526 }
527
528 buf_reset(buf);
529 mutt_addr_write(buf, addr, true);
530 size_t addr_len = buf_len(buf);
531
532 sep = "";
533 if (!addr->group)
534 {
535 // group terminator
536 if (in_group && next && !next->mailbox && !next->personal)
537 {
538 sep = ";";
539 addr_len += 1;
540 in_group = false;
541 }
542 else if (next)
543 {
544 sep = ", ";
545 addr_len += 2;
546 }
547 }
548
549 count--;
550 try_again:
551 more_len = snprintf(more, sizeof(more),
552 ngettext("(+%d more)", "(+%d more)", count), count);
553 mutt_debug(LL_DEBUG3, "text: '%s' len: %d\n", more, more_len);
554
555 int reserve = ((count > 0) && (lines_used == max_lines)) ? more_len : 0;
556 mutt_debug(LL_DEBUG3, "processing: %s (al:%zu, wl:%d, r:%d, lu:%d)\n",
557 buf_string(buf), addr_len, width_left, reserve, lines_used);
558 if (addr_len >= (width_left - reserve))
559 {
560 mutt_debug(LL_DEBUG3, "not enough space\n");
561 if (lines_used == max_lines)
562 {
563 mutt_debug(LL_DEBUG3, "no more lines\n");
564 mutt_debug(LL_DEBUG3, "truncating: %s\n", buf_string(buf));
565 mutt_paddstr(win, width_left, buf_string(buf));
566 break;
567 }
568
569 if (width_left == (win->state.cols - MaxHeaderWidth))
570 {
571 mutt_debug(LL_DEBUG3, "couldn't print: %s\n", buf_string(buf));
572 mutt_paddstr(win, width_left, buf_string(buf));
573 break;
574 }
575
576 mutt_debug(LL_DEBUG3, "start a new line\n");
578 row++;
579 lines_used++;
580 width_left = win->state.cols - MaxHeaderWidth;
582 goto try_again;
583 }
584
585 if (addr_len < width_left)
586 {
587 mutt_debug(LL_DEBUG3, "space for: %s\n", buf_string(buf));
589 mutt_window_addstr(win, sep);
590 width_left -= addr_len;
591 }
592 mutt_debug(LL_DEBUG3, "%d addresses remaining\n", count);
593 mutt_debug(LL_DEBUG3, "%zd lines remaining\n", max_lines - lines_used);
594 }
595 mutt_list_free(&list);
596 buf_pool_release(&buf);
597
598 if (count > 0)
599 {
600 mutt_window_move(win, row, win->state.cols - more_len);
602 mutt_window_addstr(win, more);
604 mutt_debug(LL_DEBUG3, "%d more (len %d)\n", count, more_len);
605 }
606 else
607 {
609 }
610
611 for (int i = lines_used; i < max_lines; i++)
612 {
613 mutt_window_move(win, row + i, 0);
615 }
616
617 mutt_debug(LL_DEBUG3, "used %d lines\n", lines_used);
618 return lines_used;
619}
size_t mutt_addr_write(struct Buffer *buf, struct Address *addr, bool display)
Write a single Address to a buffer.
Definition: address.c:1050
int mutt_addrlist_count_recips(const struct AddressList *al)
Count the number of Addresses with valid recipients.
Definition: address.c:872
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:491
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
@ MT_COLOR_BOLD
Bold text.
Definition: color.h:41
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ 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:82
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:743
#define TAILQ_NEXT(elm, field)
Definition: queue.h:850
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:36
+ 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 628 of file window.c.

630{
631 const char *overflow_text = "...";
632 int rows_used = 0;
633
634 struct ListNode *first = STAILQ_FIRST(&wdata->email->env->userhdrs);
635 if (!first)
636 return rows_used;
637
638 /* Draw first entry on same line as prompt */
640 mutt_paddstr(win,
643 first->data);
644 rows_used++;
645
646 /* Draw any following entries on their own line */
647 struct ListNode *np = STAILQ_NEXT(first, entries);
648 if (!np)
649 return rows_used;
650
651 STAILQ_FOREACH_FROM(np, &wdata->email->env->userhdrs, entries)
652 {
653 if ((rows_used == (MAX_USER_HDR_ROWS - 1)) && STAILQ_NEXT(np, entries))
654 {
655 draw_header_content(win, row + rows_used, HDR_CUSTOM_HEADERS, overflow_text);
656 rows_used++;
657 break;
658 }
659 draw_header_content(win, row + rows_used, HDR_CUSTOM_HEADERS, np->data);
660 rows_used++;
661 }
662 return rows_used;
663}
@ HDR_CUSTOM_HEADERS
"Headers:" field
Definition: private.h:50
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:371
#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 670 of file window.c.

671{
672 struct Email *e = wdata->email;
673 const char *fcc = buf_string(wdata->fcc);
674 const int cols = win->state.cols - MaxHeaderWidth;
675
677 int row = draw_envelope_addr(HDR_FROM, &e->env->from, win, 0, 1);
678
679 if (wdata->is_news)
680 {
681 draw_header(win, row++, HDR_NEWSGROUPS);
682 mutt_paddstr(win, cols, NONULL(e->env->newsgroups));
683
684 draw_header(win, row++, HDR_FOLLOWUPTO);
685 mutt_paddstr(win, cols, NONULL(e->env->followup_to));
686
687 const bool c_x_comment_to = cs_subset_bool(wdata->sub, "x_comment_to");
688 if (c_x_comment_to)
689 {
690 draw_header(win, row++, HDR_XCOMMENTTO);
691 mutt_paddstr(win, cols, NONULL(e->env->x_comment_to));
692 }
693 }
694 else
695 {
696 row += draw_envelope_addr(HDR_TO, &e->env->to, win, row, wdata->to_rows);
697 row += draw_envelope_addr(HDR_CC, &e->env->cc, win, row, wdata->cc_rows);
698 row += draw_envelope_addr(HDR_BCC, &e->env->bcc, win, row, wdata->bcc_rows);
699 }
700
701 draw_header(win, row++, HDR_SUBJECT);
702 mutt_paddstr(win, cols, NONULL(e->env->subject));
703
704 row += draw_envelope_addr(HDR_REPLYTO, &e->env->reply_to, win, row, 1);
705
706 draw_header(win, row++, HDR_FCC);
707 mutt_paddstr(win, cols, fcc);
708
709 if (WithCrypto)
710 row += draw_crypt_lines(win, wdata, row);
711
712 const bool c_compose_show_user_headers = cs_subset_bool(wdata->sub, "compose_show_user_headers");
713 if (c_compose_show_user_headers)
714 row += draw_envelope_user_hdrs(win, wdata, row);
715
717}
@ 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:48
@ HDR_XCOMMENTTO
"X-Comment-To:" field
Definition: private.h:49
@ HDR_NEWSGROUPS
"Newsgroups:" field
Definition: private.h:47
@ 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:502
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:628
static int draw_crypt_lines(struct MuttWindow *win, struct EnvelopeWindowData *wdata, int row)
Update the encryption info in the compose window.
Definition: window.c:385
void mutt_window_clear(struct MuttWindow *win)
Clear a Window.
Definition: mutt_window.c:682
struct Buffer * fcc
Where the outgoing Email will be saved.
Definition: wdata.h:41
char *const subject
Email's subject.
Definition: envelope.h:70
char * followup_to
List of 'followup-to' fields.
Definition: envelope.h:80
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:81
char * newsgroups
List of newsgroups.
Definition: envelope.h:78
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 946 of file window.c.

947{
949
952 HDR_ATTACH_TITLE - 1);
953
959
960 struct EnvelopeWindowData *wdata = env_wdata_new();
961 wdata->fcc = fcc;
962 wdata->email = e;
963 wdata->sub = sub;
964 wdata->is_news = OptNewsSend;
965
966 win_env->wdata = wdata;
967 win_env->wdata_free = env_wdata_free;
968 win_env->recalc = env_recalc;
969 win_env->repaint = env_repaint;
970
971 return win_env;
972}
void mutt_color_observer_add(observer_t callback, void *global_data)
Add an observer.
Definition: notify.c:61
struct EnvelopeWindowData * env_wdata_new(void)
Create new Envelope Data.
Definition: wdata.c:51
static void init_header_padding(void)
Calculate how much padding the compose table will need.
Definition: window.c:180
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: globals.c:68
static int env_email_observer(struct NotifyCallback *nc)
Notification that the Email has changed - Implements observer_t -.
Definition: window.c:844
static int env_color_observer(struct NotifyCallback *nc)
Notification that a Color has changed - Implements observer_t -.
Definition: window.c:755
static int env_window_observer(struct NotifyCallback *nc)
Notification that a Window has changed - Implements observer_t -.
Definition: window.c:907
static int env_config_observer(struct NotifyCallback *nc)
Notification that a Config Variable has changed - Implements observer_t -.
Definition: window.c:791
static int env_header_observer(struct NotifyCallback *nc)
Notification that a User Header has changed - Implements observer_t -.
Definition: window.c:868
static int env_recalc(struct MuttWindow *win)
Recalculate the Window data - Implements MuttWindow::recalc() -.
Definition: window.c:722
static int env_repaint(struct MuttWindow *win)
Repaint the Window - Implements MuttWindow::repaint() -.
Definition: window.c:743
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:191
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:182
@ 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:39
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:53
@ MUTT_WIN_SIZE_FIXED
Window has a fixed size.
Definition: mutt_window.h:48
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:57
@ NT_CONFIG
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:43
@ 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: NotifyConfig, EventConfig.
Definition: subset.h:52
struct Notify * notify
Notifications: NotifyEmail, EventEmail.
Definition: email.h:73
Data to fill the Envelope Window.
Definition: wdata.h:38
int(* repaint)(struct MuttWindow *win)
Definition: mutt_window.h:187
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:173
void(* wdata_free)(struct MuttWindow *win, void **ptr)
Definition: mutt_window.h:159
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct Notify * notify
Notifications handler.
Definition: neomutt.h:43
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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 88 of file window.c.

◆ MaxHeaderWidth

int MaxHeaderWidth = 0
static

Widest of the Prompts strings after translation.

Definition at line 90 of file window.c.

◆ Prompts

const char* const Prompts[]

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

Definition at line 93 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 131 of file window.c.