NeoMutt  2018-07-16 +2225-8687db
Teaching an old dog new tricks
DOXYGEN
hdrline.c File Reference

String processing routines to generate the mail index. More...

#include "config.h"
#include <locale.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "mutt/mutt.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "mutt.h"
#include "hdrline.h"
#include "alias.h"
#include "context.h"
#include "core/lib.h"
#include "curs_lib.h"
#include "format_flags.h"
#include "globals.h"
#include "hook.h"
#include "mutt_curses.h"
#include "mutt_menu.h"
#include "mutt_parse.h"
#include "mutt_thread.h"
#include "mutt_window.h"
#include "muttlib.h"
#include "ncrypt/ncrypt.h"
#include "sort.h"

Go to the source code of this file.

Enumerations

enum  FlagChars {
  FLAG_CHAR_TAGGED, FLAG_CHAR_IMPORTANT, FLAG_CHAR_DELETED, FLAG_CHAR_DELETED_ATTACH,
  FLAG_CHAR_REPLIED, FLAG_CHAR_OLD, FLAG_CHAR_NEW, FLAG_CHAR_OLD_THREAD,
  FLAG_CHAR_NEW_THREAD, FLAG_CHAR_SEMPTY, FLAG_CHAR_ZEMPTY
}
 Index into the C_FlagChars variable ($flag_chars) More...
 
enum  CryptChars {
  FLAG_CHAR_CRYPT_GOOD_SIGN, FLAG_CHAR_CRYPT_ENCRYPTED, FLAG_CHAR_CRYPT_SIGNED, FLAG_CHAR_CRYPT_CONTAINS_KEY,
  FLAG_CHAR_CRYPT_NO_CRYPTO
}
 Index into the C_CryptChars variable ($crypt_chars) More...
 
enum  FieldType {
  DISP_TO, DISP_CC, DISP_BCC, DISP_FROM,
  DISP_PLAIN, DISP_MAX
}
 Header types. More...
 

Functions

bool mutt_is_mail_list (const struct Address *addr)
 Is this the email address of a mailing list? More...
 
bool mutt_is_subscribed_list (const struct Address *addr)
 Is this the email address of a user-subscribed mailing list? More...
 
static bool check_for_mailing_list (struct AddressList *al, const char *pfx, char *buf, int buflen)
 Search list of addresses for a mailing list. More...
 
static bool check_for_mailing_list_addr (struct AddressList *al, char *buf, int buflen)
 Check an address list for a mailing list. More...
 
static bool first_mailing_list (char *buf, size_t buflen, struct AddressList *al)
 Get the first mailing list in the list of addresses. More...
 
static size_t add_index_color (char *buf, size_t buflen, MuttFormatFlags flags, char color)
 Insert a color marker into a string. More...
 
static const char * get_nth_wchar (struct MbTable *table, int index)
 Extract one char from a multi-byte table. More...
 
static const char * make_from_prefix (enum FieldType disp)
 Create a prefix for an author field. More...
 
static void make_from (struct Envelope *env, char *buf, size_t buflen, bool do_lists, MuttFormatFlags flags)
 Generate a From: field (with optional prefix) More...
 
static void make_from_addr (struct Envelope *env, char *buf, size_t buflen, bool do_lists)
 Create a 'from' address for a reply email. More...
 
static bool user_in_addr (struct AddressList *al)
 Do any of the addresses refer to the user? More...
 
static int user_is_recipient (struct Email *e)
 Is the user a recipient of the message. More...
 
static char * apply_subject_mods (struct Envelope *env)
 Apply regex modifications to the subject. More...
 
static bool thread_is_new (struct Context *ctx, struct Email *e)
 Does the email thread contain any new emails? More...
 
static bool thread_is_old (struct Context *ctx, struct Email *e)
 Does the email thread contain any unread emails? More...
 
static const char * index_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, unsigned long data, MuttFormatFlags flags)
 Format a string for the index list - Implements format_t. More...
 
void mutt_make_string_flags (char *buf, size_t buflen, const char *s, struct Context *ctx, struct Mailbox *m, struct Email *e, MuttFormatFlags flags)
 Create formatted strings using mailbox expandos. More...
 
void mutt_make_string_info (char *buf, size_t buflen, int cols, const char *s, struct HdrFormatInfo *hfi, MuttFormatFlags flags)
 Create pager status bar string. More...
 

Variables

struct MbTableC_CryptChars
 Config: User-configurable crypto flags: signed, encrypted etc. More...
 
struct MbTableC_FlagChars
 Config: User-configurable index flags: tagged, new, etc. More...
 
struct MbTableC_FromChars
 Config: User-configurable index flags: to address, cc address, etc. More...
 
struct MbTableC_ToChars
 Config: Indicator characters for the 'To' field in the index. More...
 

Detailed Description

String processing routines to generate the mail index.

Authors
  • Michael R. Elkins
  • Richard Russon
  • Ian Zimmerman
  • 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 hdrline.c.

Enumeration Type Documentation

enum FlagChars

Index into the C_FlagChars variable ($flag_chars)

Enumerator
FLAG_CHAR_TAGGED 

Character denoting a tagged email.

FLAG_CHAR_IMPORTANT 

Character denoting a important (flagged) email.

FLAG_CHAR_DELETED 

Character denoting a deleted email.

FLAG_CHAR_DELETED_ATTACH 

Character denoting a deleted attachment.

FLAG_CHAR_REPLIED 

Character denoting an email that has been replied to.

FLAG_CHAR_OLD 

Character denoting an email that has been read.

FLAG_CHAR_NEW 

Character denoting an unread email.

FLAG_CHAR_OLD_THREAD 

Character denoting a thread of emails that has been read.

FLAG_CHAR_NEW_THREAD 

Character denoting a thread containing at least one new email.

FLAG_CHAR_SEMPTY 

Character denoting a read email, $index_format S expando.

FLAG_CHAR_ZEMPTY 

Character denoting a read email, $index_format Z expando.

Definition at line 70 of file hdrline.c.

71 {
83 };
Character denoting a tagged email.
Definition: hdrline.c:72
Character denoting a important (flagged) email.
Definition: hdrline.c:73
Character denoting a thread containing at least one new email.
Definition: hdrline.c:80
Character denoting a read email, $index_format S expando.
Definition: hdrline.c:81
Character denoting a deleted attachment.
Definition: hdrline.c:75
Character denoting an email that has been read.
Definition: hdrline.c:77
Character denoting a thread of emails that has been read.
Definition: hdrline.c:79
Character denoting an email that has been replied to.
Definition: hdrline.c:76
Character denoting a read email, $index_format Z expando.
Definition: hdrline.c:82
Character denoting a deleted email.
Definition: hdrline.c:74
Character denoting an unread email.
Definition: hdrline.c:78
enum CryptChars

Index into the C_CryptChars variable ($crypt_chars)

Enumerator
FLAG_CHAR_CRYPT_GOOD_SIGN 

Character denoting a message signed with a verified key.

FLAG_CHAR_CRYPT_ENCRYPTED 

Character denoting a message is PGP-encrypted.

FLAG_CHAR_CRYPT_SIGNED 

Character denoting a message is signed.

FLAG_CHAR_CRYPT_CONTAINS_KEY 

Character denoting a message contains a PGP key.

FLAG_CHAR_CRYPT_NO_CRYPTO 

Character denoting a message has no cryptography information.

Definition at line 88 of file hdrline.c.

89 {
95 };
Character denoting a message contains a PGP key.
Definition: hdrline.c:93
Character denoting a message signed with a verified key.
Definition: hdrline.c:90
Character denoting a message is PGP-encrypted.
Definition: hdrline.c:91
Character denoting a message has no cryptography information.
Definition: hdrline.c:94
Character denoting a message is signed.
Definition: hdrline.c:92
enum FieldType

Header types.

Strings for printing headers

Enumerator
DISP_TO 

To: string.

DISP_CC 

Cc: string.

DISP_BCC 

Bcc: string.

DISP_FROM 

From: string.

DISP_PLAIN 

Empty string.

DISP_MAX 

Definition at line 239 of file hdrline.c.

240 {
241  DISP_TO,
242  DISP_CC,
243  DISP_BCC,
244  DISP_FROM,
245  DISP_PLAIN,
246  DISP_MAX,
247 };
Bcc: string.
Definition: hdrline.c:243
Cc: string.
Definition: hdrline.c:242
Empty string.
Definition: hdrline.c:245
From: string.
Definition: hdrline.c:244
To: string.
Definition: hdrline.c:241

Function Documentation

bool mutt_is_mail_list ( const struct Address addr)

Is this the email address of a mailing list?

Parameters
addrAddress to test
Return values
trueIf it's a mailing list

Definition at line 102 of file hdrline.c.

103 {
105  return mutt_regexlist_match(&MailLists, addr->mailbox);
106  return false;
107 }
char * mailbox
Mailbox and host address.
Definition: address.h:37
bool mutt_regexlist_match(struct RegexList *rl, const char *str)
Does a string match any Regex in the list?
Definition: regex.c:190
struct RegexList MailLists
List of regexes to match mailing lists.
Definition: email_globals.c:50
struct RegexList UnMailLists
List of regexes to blacklist false matches in MailLists.
Definition: email_globals.c:51
bool mutt_is_subscribed_list ( const struct Address addr)

Is this the email address of a user-subscribed mailing list?

Parameters
addrAddress to test
Return values
trueIf it's a subscribed mailing list

Definition at line 114 of file hdrline.c.

115 {
116  if (!mutt_regexlist_match(&UnMailLists, addr->mailbox) &&
118  {
120  }
121  return false;
122 }
char * mailbox
Mailbox and host address.
Definition: address.h:37
bool mutt_regexlist_match(struct RegexList *rl, const char *str)
Does a string match any Regex in the list?
Definition: regex.c:190
struct RegexList SubscribedLists
List of regexes to match subscribed mailing lists.
Definition: email_globals.c:52
struct RegexList UnMailLists
List of regexes to blacklist false matches in MailLists.
Definition: email_globals.c:51
struct RegexList UnSubscribedLists
List of regexes to blacklist false matches in SubscribedLists.
Definition: email_globals.c:49
static bool check_for_mailing_list ( struct AddressList *  al,
const char *  pfx,
char *  buf,
int  buflen 
)
static

Search list of addresses for a mailing list.

Parameters
alAddressList to search
pfxPrefix string
bufBuffer to store results
buflenBuffer length
Return values
1Mailing list found
0No list found

Search for a mailing list in the list of addresses pointed to by addr. If one is found, print pfx and the name of the list into buf.

Definition at line 136 of file hdrline.c.

138 {
139  struct Address *a = NULL;
140  TAILQ_FOREACH(a, al, entries)
141  {
143  {
144  if (pfx && buf && buflen)
145  snprintf(buf, buflen, "%s%s", pfx, mutt_get_name(a));
146  return true;
147  }
148  }
149  return false;
150 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:719
An email address.
Definition: address.h:34
bool mutt_is_subscribed_list(const struct Address *addr)
Is this the email address of a user-subscribed mailing list?
Definition: hdrline.c:114
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:156
static bool check_for_mailing_list_addr ( struct AddressList *  al,
char *  buf,
int  buflen 
)
static

Check an address list for a mailing list.

Parameters
alAddressList
bufBuffer for the result
buflenLength of buffer
Return values
trueMailing list found

If one is found, print the address of the list into buf.

Definition at line 161 of file hdrline.c.

162 {
163  struct Address *a = NULL;
164  TAILQ_FOREACH(a, al, entries)
165  {
167  {
168  if (buf && buflen)
169  snprintf(buf, buflen, "%s", a->mailbox);
170  return true;
171  }
172  }
173  return false;
174 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:719
An email address.
Definition: address.h:34
char * mailbox
Mailbox and host address.
Definition: address.h:37
bool mutt_is_subscribed_list(const struct Address *addr)
Is this the email address of a user-subscribed mailing list?
Definition: hdrline.c:114
static bool first_mailing_list ( char *  buf,
size_t  buflen,
struct AddressList *  al 
)
static

Get the first mailing list in the list of addresses.

Parameters
bufBuffer for the result
buflenLength of buffer
alAddressList
Return values
trueIf a mailing list was found

Definition at line 183 of file hdrline.c.

184 {
185  struct Address *a = NULL;
186  TAILQ_FOREACH(a, al, entries)
187  {
189  {
190  mutt_save_path(buf, buflen, a);
191  return true;
192  }
193  }
194  return false;
195 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:719
An email address.
Definition: address.h:34
bool mutt_is_subscribed_list(const struct Address *addr)
Is this the email address of a user-subscribed mailing list?
Definition: hdrline.c:114
void mutt_save_path(char *buf, size_t buflen, const struct Address *addr)
Turn an email address into a filename (for saving)
Definition: muttlib.c:797
static size_t add_index_color ( char *  buf,
size_t  buflen,
MuttFormatFlags  flags,
char  color 
)
static

Insert a color marker into a string.

Parameters
bufBuffer to store marker
buflenBuffer length
flagsFlags, see MuttFormatFlags
colorColor, e.g. MT_COLOR_MESSAGE
Return values
numCharacters written

The colors are stored as "magic" strings embedded in the text.

Definition at line 207 of file hdrline.c.

208 {
209  /* only add color markers if we are operating on main index entries. */
210  if (!(flags & MUTT_FORMAT_INDEX))
211  return 0;
212 
213  /* this item is going to be passed to an external filter */
214  if (flags & MUTT_FORMAT_NOFILTER)
215  return 0;
216 
217  if (color == MT_COLOR_INDEX)
218  { /* buf might be uninitialized other cases */
219  const size_t len = mutt_str_strlen(buf);
220  buf += len;
221  buflen -= len;
222  }
223 
224  if (buflen <= 2)
225  return 0;
226 
227  buf[0] = MUTT_SPECIAL_INDEX;
228  buf[1] = color;
229  buf[2] = '\0';
230 
231  return 2;
232 }
size_t mutt_str_strlen(const char *a)
Calculate the length of a string, safely.
Definition: string.c:666
Index: default colour (takes a pattern)
Definition: mutt_curses.h:156
#define MUTT_FORMAT_INDEX
This is a main index entry.
Definition: format_flags.h:36
Colour indicator.
Definition: mutt_menu.h:76
#define MUTT_FORMAT_NOFILTER
Do not allow filtering on this pass.
Definition: format_flags.h:37
static const char* get_nth_wchar ( struct MbTable table,
int  index 
)
static

Extract one char from a multi-byte table.

Parameters
tableMulti-byte table
indexSelect this character
Return values
ptrString pointer to the character

Extract one multi-byte character from a string table. If the index is invalid, then a space character will be returned. If the character selected is '
' (Ctrl-M), then "" will be returned.

Definition at line 259 of file hdrline.c.

260 {
261  if (!table || !table->chars || (index < 0) || (index >= table->len))
262  return " ";
263 
264  if (table->chars[index][0] == '\r')
265  return "";
266 
267  return table->chars[index];
268 }
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
int len
Number of characters.
Definition: mbtable.h:38
static const char* make_from_prefix ( enum FieldType  disp)
static

Create a prefix for an author field.

Parameters
dispType of field
Return values
ptrPrefix string (do not free it)

If $from_chars is set, pick an appropriate character from it. If not, use the default prefix: "To", "Cc", etc

Definition at line 278 of file hdrline.c.

279 {
280  /* need 2 bytes at the end, one for the space, another for NUL */
281  static char padded[8];
282  static const char *long_prefixes[DISP_MAX] = {
283  [DISP_TO] = "To ", [DISP_CC] = "Cc ", [DISP_BCC] = "Bcc ",
284  [DISP_FROM] = "", [DISP_PLAIN] = "",
285  };
286 
287  if (!C_FromChars || !C_FromChars->chars || (C_FromChars->len == 0))
288  return long_prefixes[disp];
289 
290  const char *pchar = get_nth_wchar(C_FromChars, disp);
291  if (mutt_str_strlen(pchar) == 0)
292  return "";
293 
294  snprintf(padded, sizeof(padded), "%s ", pchar);
295  return padded;
296 }
Bcc: string.
Definition: hdrline.c:243
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
Cc: string.
Definition: hdrline.c:242
size_t mutt_str_strlen(const char *a)
Calculate the length of a string, safely.
Definition: string.c:666
struct MbTable * C_FromChars
Config: User-configurable index flags: to address, cc address, etc.
Definition: hdrline.c:64
Empty string.
Definition: hdrline.c:245
From: string.
Definition: hdrline.c:244
static const char * get_nth_wchar(struct MbTable *table, int index)
Extract one char from a multi-byte table.
Definition: hdrline.c:259
To: string.
Definition: hdrline.c:241
int len
Number of characters.
Definition: mbtable.h:38
static void make_from ( struct Envelope env,
char *  buf,
size_t  buflen,
bool  do_lists,
MuttFormatFlags  flags 
)
static

Generate a From: field (with optional prefix)

Parameters
envEnvelope of the email
bufBuffer to store the result
buflenSize of the buffer
do_listsShould we check for mailing lists?
flagsFormat flags, see MuttFormatFlags

Generate the F or L field in $index_format. This is the author, or recipient of the email.

The field can optionally be prefixed by a character from $from_chars. If $from_chars is not set, the prefix will be, "To", "Cc", etc

Definition at line 312 of file hdrline.c.

314 {
315  if (!env || !buf)
316  return;
317 
318  bool me;
319  enum FieldType disp;
320  struct AddressList *name = NULL;
321 
322  me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
323 
324  if (do_lists || me)
325  {
326  if (check_for_mailing_list(&env->to, make_from_prefix(DISP_TO), buf, buflen))
327  return;
328  if (check_for_mailing_list(&env->cc, make_from_prefix(DISP_CC), buf, buflen))
329  return;
330  }
331 
332  if (me && !TAILQ_EMPTY(&env->to))
333  {
334  disp = (flags & MUTT_FORMAT_PLAIN) ? DISP_PLAIN : DISP_TO;
335  name = &env->to;
336  }
337  else if (me && !TAILQ_EMPTY(&env->cc))
338  {
339  disp = DISP_CC;
340  name = &env->cc;
341  }
342  else if (me && !TAILQ_EMPTY(&env->bcc))
343  {
344  disp = DISP_BCC;
345  name = &env->bcc;
346  }
347  else if (!TAILQ_EMPTY(&env->from))
348  {
349  disp = DISP_FROM;
350  name = &env->from;
351  }
352  else
353  {
354  *buf = '\0';
355  return;
356  }
357 
358  snprintf(buf, buflen, "%s%s", make_from_prefix(disp), mutt_get_name(TAILQ_FIRST(name)));
359 }
Bcc: string.
Definition: hdrline.c:243
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:46
Cc: string.
Definition: hdrline.c:242
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:43
const char * name
Definition: pgpmicalg.c:45
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:45
Empty string.
Definition: hdrline.c:245
From: string.
Definition: hdrline.c:244
static const char * make_from_prefix(enum FieldType disp)
Create a prefix for an author field.
Definition: hdrline.c:278
static bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: hdrline.c:136
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
To: string.
Definition: hdrline.c:241
FieldType
Header types.
Definition: hdrline.c:239
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:669
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:44
#define TAILQ_EMPTY(head)
Definition: queue.h:715
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:156
static void make_from_addr ( struct Envelope env,
char *  buf,
size_t  buflen,
bool  do_lists 
)
static

Create a 'from' address for a reply email.

Parameters
envEnvelope of current email
bufBuffer for the result
buflenLength of buffer
do_listsIf true, check for mailing lists

Definition at line 368 of file hdrline.c.

369 {
370  if (!env || !buf)
371  return;
372 
373  bool me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
374 
375  if (do_lists || me)
376  {
377  if (check_for_mailing_list_addr(&env->to, buf, buflen))
378  return;
379  if (check_for_mailing_list_addr(&env->cc, buf, buflen))
380  return;
381  }
382 
383  if (me && !TAILQ_EMPTY(&env->to))
384  snprintf(buf, buflen, "%s", TAILQ_FIRST(&env->to)->mailbox);
385  else if (me && !TAILQ_EMPTY(&env->cc))
386  snprintf(buf, buflen, "%s", TAILQ_FIRST(&env->cc)->mailbox);
387  else if (!TAILQ_EMPTY(&env->from))
388  mutt_str_strfcpy(buf, TAILQ_FIRST(&env->from)->mailbox, buflen);
389  else
390  *buf = '\0';
391 }
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:43
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:45
size_t mutt_str_strfcpy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:750
static bool check_for_mailing_list_addr(struct AddressList *al, char *buf, int buflen)
Check an address list for a mailing list.
Definition: hdrline.c:161
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:669
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:44
#define TAILQ_EMPTY(head)
Definition: queue.h:715
static bool user_in_addr ( struct AddressList *  al)
static

Do any of the addresses refer to the user?

Parameters
alAddressList
Return values
trueIf any of the addresses match one of the user's addresses

Definition at line 398 of file hdrline.c.

399 {
400  struct Address *a = NULL;
401  TAILQ_FOREACH(a, al, entries)
402  if (mutt_addr_is_user(a))
403  return true;
404  return false;
405 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:719
An email address.
Definition: address.h:34
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:669
static int user_is_recipient ( struct Email e)
static

Is the user a recipient of the message.

Parameters
eEmail to test
Return values
0User is not in list
1User is unique recipient
2User is in the TO list
3User is in the CC list
4User is originator
5Sent to a subscribed mailinglist
6User is in the Reply-To list

Definition at line 418 of file hdrline.c.

419 {
420  if (!e || !e->env)
421  return 0;
422 
423  struct Envelope *env = e->env;
424 
425  if (!e->recip_valid)
426  {
427  e->recip_valid = true;
428 
429  if (mutt_addr_is_user(TAILQ_FIRST(&env->from)))
430  e->recipient = 4;
431  else if (user_in_addr(&env->to))
432  {
433  if (TAILQ_NEXT(TAILQ_FIRST(&env->to), entries) || !TAILQ_EMPTY(&env->cc))
434  e->recipient = 2; /* non-unique recipient */
435  else
436  e->recipient = 1; /* unique recipient */
437  }
438  else if (user_in_addr(&env->cc))
439  e->recipient = 3;
440  else if (check_for_mailing_list(&env->to, NULL, NULL, 0))
441  e->recipient = 5;
442  else if (check_for_mailing_list(&env->cc, NULL, NULL, 0))
443  e->recipient = 5;
444  else if (user_in_addr(&env->reply_to))
445  e->recipient = 6;
446  else
447  e->recipient = 0;
448  }
449 
450  return e->recipient;
451 }
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:48
static bool user_in_addr(struct AddressList *al)
Do any of the addresses refer to the user?
Definition: hdrline.c:398
short recipient
User_is_recipient()&#39;s return value, cached.
Definition: email.h:77
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:43
struct Envelope * env
Envelope information.
Definition: email.h:89
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:45
static bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: hdrline.c:136
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:669
bool recip_valid
Is_recipient is valid.
Definition: email.h:58
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:44
#define TAILQ_NEXT(elm, field)
Definition: queue.h:816
#define TAILQ_EMPTY(head)
Definition: queue.h:715
The header of an Email.
Definition: envelope.h:40
static char* apply_subject_mods ( struct Envelope env)
static

Apply regex modifications to the subject.

Parameters
envEnvelope of email
Return values
ptrModified subject
NULLNo modification made

Definition at line 459 of file hdrline.c.

460 {
461  if (!env)
462  return NULL;
463 
465  return env->subject;
466 
467  if (!env->subject || (*env->subject == '\0'))
468  {
469  env->disp_subj = NULL;
470  return NULL;
471  }
472 
474  return env->disp_subj;
475 }
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:54
char * mutt_replacelist_apply(struct ReplaceList *rl, char *buf, size_t buflen, const char *str)
Apply replacements to a buffer.
Definition: regex.c:353
char * subject
Email&#39;s subject.
Definition: envelope.h:52
#define STAILQ_EMPTY(head)
Definition: queue.h:346
struct ReplaceList SubjectRegexList
List of regexes to tidy the view of the email&#39;s subject.
Definition: email_globals.c:53
static bool thread_is_new ( struct Context ctx,
struct Email e 
)
static

Does the email thread contain any new emails?

Parameters
ctxMailbox
eEmail
Return values
trueIf thread contains new mail

Definition at line 483 of file hdrline.c.

484 {
485  return e->collapsed && (e->num_hidden > 1) &&
486  (mutt_thread_contains_unread(ctx, e) == 1);
487 }
size_t num_hidden
Number of hidden messages in this view.
Definition: email.h:75
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:73
#define mutt_thread_contains_unread(ctx, e)
Definition: mutt_thread.h:59
static bool thread_is_old ( struct Context ctx,
struct Email e 
)
static

Does the email thread contain any unread emails?

Parameters
ctxMailbox
eEmail
Return values
trueIf thread contains unread mail

Definition at line 495 of file hdrline.c.

496 {
497  return e->collapsed && (e->num_hidden > 1) &&
498  (mutt_thread_contains_unread(ctx, e) == 2);
499 }
size_t num_hidden
Number of hidden messages in this view.
Definition: email.h:75
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:73
#define mutt_thread_contains_unread(ctx, e)
Definition: mutt_thread.h:59
static const char* index_format_str ( char *  buf,
size_t  buflen,
size_t  col,
int  cols,
char  op,
const char *  src,
const char *  prec,
const char *  if_str,
const char *  else_str,
unsigned long  data,
MuttFormatFlags  flags 
)
static

Format a string for the index list - Implements format_t.

Expando Description
%(fmt) Date/time when the message was received
%a Address of the author
%A Reply-to address (if present; otherwise: address of author)
%b Filename of the original message folder (think mailbox)
%B The list to which the letter was sent, or else the folder name (b)
%C Current message number
%c Number of characters (bytes) in the message
%D Date and time of message using $date_format and local timezone
%d Date and time of message using $date_format and sender's timezone
%e Current message number in thread
%E Number of messages in current thread
%Fp Like F, but plain. No contextual formatting is applied to recipient name
%F Author name, or recipient name if the message is from you
%f Sender (address + real name), either From: or Return-Path:
%Gx Individual message tag (e.g. notmuch tags/imap flags)
%g Message tags (e.g. notmuch tags/imap flags)
%H Spam attribute(s) of this message
%I Initials of author
%i Message-id of the current message
%J Message tags (if present, tree unfolded, and != parent's tags)
%K The list to which the letter was sent (if any; otherwise: empty)
%L Like F, except 'lists' are displayed first
%l Number of lines in the message
%M Number of hidden messages if the thread is collapsed
%m Total number of message in the mailbox
%n Author's real name (or address if missing)
%N Message score
%O Like L, except using address instead of name
%P Progress indicator for the built-in pager (how much of the file has been displayed)
%q Newsgroup name (if compiled with NNTP support)
%R Comma separated list of Cc: recipients
%r Comma separated list of To: recipients
%S Single character status of the message (N/O/D/d/!/r/-)
%s Subject of the message
%t 'To:' field (recipients)
%T The appropriate character from the $to_chars string
%u User (login) name of the author
%v First name of the author, or the recipient if the message is from you
%W Name of organization of author ('Organization:' field)
%x 'X-Comment-To:' field (if present and compiled with NNTP support)
%X Number of MIME attachments
%y 'X-Label:' field (if present)
%Y 'X-Label:' field (if present, tree unfolded, and != parent's x-label)
%zc Message crypto flags
%zs Message status flags
%zt Message tag flags
%Z Combined message flags
%[fmt] Message date/time converted to the local time zone
%{fmt} Message date/time converted to sender's time zone

Definition at line 556 of file hdrline.c.

560 {
561  struct HdrFormatInfo *hfi = (struct HdrFormatInfo *) data;
562  char fmt[128], tmp[1024];
563  char *p = NULL, *tags = NULL;
564  int optional = (flags & MUTT_FORMAT_OPTIONAL);
565  int threads = ((C_Sort & SORT_MASK) == SORT_THREADS);
566  int is_index = (flags & MUTT_FORMAT_INDEX);
567  size_t colorlen;
568 
569  struct Email *e = hfi->email;
570  struct Context *ctx = hfi->ctx;
571  struct Mailbox *m = hfi->mailbox;
572 
573  if (!e || !e->env)
574  return src;
575 
576  const struct Address *reply_to = TAILQ_FIRST(&e->env->reply_to);
577  const struct Address *from = TAILQ_FIRST(&e->env->from);
578  const struct Address *to = TAILQ_FIRST(&e->env->to);
579  const struct Address *cc = TAILQ_FIRST(&e->env->cc);
580 
581  buf[0] = '\0';
582  switch (op)
583  {
584  case 'A':
585  case 'I':
586  if (op == 'A')
587  {
588  if (reply_to && reply_to->mailbox)
589  {
590  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
591  mutt_format_s(buf + colorlen, buflen - colorlen, prec,
592  mutt_addr_for_display(reply_to));
593  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
594  break;
595  }
596  }
597  else
598  {
599  if (mutt_mb_get_initials(mutt_get_name(from), tmp, sizeof(tmp)))
600  {
601  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
602  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
603  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
604  break;
605  }
606  }
607  /* fallthrough */
608 
609  case 'a':
610  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
611  if (from && from->mailbox)
612  {
613  mutt_format_s(buf + colorlen, buflen - colorlen, prec, mutt_addr_for_display(from));
614  }
615  else
616  mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
617  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
618  break;
619 
620  case 'B':
621  case 'K':
622  if (!first_mailing_list(buf, buflen, &e->env->to) &&
623  !first_mailing_list(buf, buflen, &e->env->cc))
624  {
625  buf[0] = '\0';
626  }
627  if (buf[0] != '\0')
628  {
629  mutt_str_strfcpy(tmp, buf, sizeof(tmp));
630  mutt_format_s(buf, buflen, prec, tmp);
631  break;
632  }
633  if (op == 'K')
634  {
635  if (optional)
636  optional = 0;
637  /* break if 'K' returns nothing */
638  break;
639  }
640  /* if 'B' returns nothing */
641  /* fallthrough */
642 
643  case 'b':
644  if (m)
645  {
646  p = strrchr(mutt_b2s(m->pathbuf), '/');
647  if (p)
648  mutt_str_strfcpy(buf, p + 1, buflen);
649  else
650  mutt_str_strfcpy(buf, mutt_b2s(m->pathbuf), buflen);
651  }
652  else
653  mutt_str_strfcpy(buf, "(null)", buflen);
654  mutt_str_strfcpy(tmp, buf, sizeof(tmp));
655  mutt_format_s(buf, buflen, prec, tmp);
656  break;
657 
658  case 'c':
659  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
660  mutt_str_pretty_size(tmp, sizeof(tmp), mutt_email_size(e));
661  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
662  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
663  break;
664 
665  case 'C':
666  colorlen = add_index_color(fmt, sizeof(fmt), flags, MT_COLOR_INDEX_NUMBER);
667  snprintf(fmt + colorlen, sizeof(fmt) - colorlen, "%%%sd", prec);
668  add_index_color(fmt + colorlen, sizeof(fmt) - colorlen, flags, MT_COLOR_INDEX);
669  snprintf(buf, buflen, fmt, e->msgno + 1);
670  break;
671 
672  case 'd':
673  case 'D':
674  case '{':
675  case '[':
676  case '(':
677  case '<':
678  /* preprocess $date_format to handle %Z */
679  {
680  const char *cp = NULL;
681  time_t now;
682  int j = 0;
683 
684  if (optional && ((op == '[') || (op == '(')))
685  {
686  now = time(NULL);
687  struct tm tm = mutt_date_localtime(now);
688  now -= (op == '(') ? e->received : e->date_sent;
689 
690  char *is = (char *) prec;
691  bool invert = false;
692  if (*is == '>')
693  {
694  invert = true;
695  is++;
696  }
697 
698  while (*is && (*is != '?'))
699  {
700  int t = strtol(is, &is, 10);
701  /* semi-broken (assuming 30 days in all months) */
702  switch (*(is++))
703  {
704  case 'y':
705  if (t > 1)
706  {
707  t--;
708  t *= (60 * 60 * 24 * 365);
709  }
710  t += ((tm.tm_mon * 60 * 60 * 24 * 30) + (tm.tm_mday * 60 * 60 * 24) +
711  (tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec);
712  break;
713 
714  case 'm':
715  if (t > 1)
716  {
717  t--;
718  t *= (60 * 60 * 24 * 30);
719  }
720  t += ((tm.tm_mday * 60 * 60 * 24) + (tm.tm_hour * 60 * 60) +
721  (tm.tm_min * 60) + tm.tm_sec);
722  break;
723 
724  case 'w':
725  if (t > 1)
726  {
727  t--;
728  t *= (60 * 60 * 24 * 7);
729  }
730  t += ((tm.tm_wday * 60 * 60 * 24) + (tm.tm_hour * 60 * 60) +
731  (tm.tm_min * 60) + tm.tm_sec);
732  break;
733 
734  case 'd':
735  if (t > 1)
736  {
737  t--;
738  t *= (60 * 60 * 24);
739  }
740  t += ((tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec);
741  break;
742 
743  case 'H':
744  if (t > 1)
745  {
746  t--;
747  t *= (60 * 60);
748  }
749  t += ((tm.tm_min * 60) + tm.tm_sec);
750  break;
751 
752  case 'M':
753  if (t > 1)
754  {
755  t--;
756  t *= (60);
757  }
758  t += (tm.tm_sec);
759  break;
760 
761  default:
762  break;
763  }
764  j += t;
765  }
766 
767  if (j < 0)
768  j *= -1;
769 
770  if (((now > j) || (now < (-1 * j))) ^ invert)
771  optional = 0;
772  break;
773  }
774 
775  p = buf;
776 
777  cp = ((op == 'd') || (op == 'D')) ? (NONULL(C_DateFormat)) : src;
778  bool do_locales;
779  if (*cp == '!')
780  {
781  do_locales = false;
782  cp++;
783  }
784  else
785  do_locales = true;
786 
787  size_t len = buflen - 1;
788  while ((len > 0) &&
789  ((((op == 'd') || (op == 'D')) && *cp) ||
790  ((op == '{') && (*cp != '}')) || ((op == '[') && (*cp != ']')) ||
791  ((op == '(') && (*cp != ')')) || ((op == '<') && (*cp != '>'))))
792  {
793  if (*cp == '%')
794  {
795  cp++;
796  if (((*cp == 'Z') || (*cp == 'z')) && ((op == 'd') || (op == '{')))
797  {
798  if (len >= 5)
799  {
800  sprintf(p, "%c%02u%02u", e->zoccident ? '-' : '+', e->zhours, e->zminutes);
801  p += 5;
802  len -= 5;
803  }
804  else
805  break; /* not enough space left */
806  }
807  else
808  {
809  if (len >= 2)
810  {
811  *p++ = '%';
812  *p++ = *cp;
813  len -= 2;
814  }
815  else
816  break; /* not enough space */
817  }
818  cp++;
819  }
820  else
821  {
822  *p++ = *cp++;
823  len--;
824  }
825  }
826  *p = '\0';
827 
828  struct tm tm;
829  if ((op == '[') || (op == 'D'))
831  else if (op == '(')
832  tm = mutt_date_localtime(e->received);
833  else if (op == '<')
834  {
836  }
837  else
838  {
839  /* restore sender's time zone */
840  now = e->date_sent;
841  if (e->zoccident)
842  now -= (e->zhours * 3600 + e->zminutes * 60);
843  else
844  now += (e->zhours * 3600 + e->zminutes * 60);
845  tm = mutt_date_gmtime(now);
846  }
847 
848  if (!do_locales)
849  setlocale(LC_TIME, "C");
850  strftime(tmp, sizeof(tmp), buf, &tm);
851  if (!do_locales)
852  setlocale(LC_TIME, "");
853 
854  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_DATE);
855  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
856  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
857 
858  if ((len > 0) && (op != 'd') && (op != 'D')) /* Skip ending op */
859  src = cp + 1;
860  break;
861  }
862 
863  case 'e':
864  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
865  snprintf(buf, buflen, fmt, mutt_messages_in_thread(m, e, 1));
866  break;
867 
868  case 'E':
869  if (!optional)
870  {
871  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
872  snprintf(buf, buflen, fmt, mutt_messages_in_thread(m, e, 0));
873  }
874  else if (mutt_messages_in_thread(m, e, 0) <= 1)
875  optional = 0;
876  break;
877 
878  case 'f':
879  tmp[0] = '\0';
880  mutt_addrlist_write(tmp, sizeof(tmp), &e->env->from, true);
881  mutt_format_s(buf, buflen, prec, tmp);
882  break;
883 
884  case 'F':
885  if (!optional)
886  {
887  const bool is_plain = (src[0] == 'p');
888  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
889  make_from(e->env, tmp, sizeof(tmp), false,
890  (is_plain ? MUTT_FORMAT_PLAIN : MUTT_FORMAT_NO_FLAGS));
891  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
892  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
893 
894  if (is_plain)
895  src++;
896  }
897  else if (mutt_addr_is_user(from))
898  {
899  optional = 0;
900  }
901  break;
902 
903  case 'g':
904  tags = driver_tags_get_transformed(&e->tags);
905  if (!optional)
906  {
907  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
908  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
909  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
910  }
911  else if (!tags)
912  optional = 0;
913  FREE(&tags);
914  break;
915 
916  case 'G':
917  {
918  char format[3];
919  char *tag = NULL;
920 
921  if (!optional)
922  {
923  format[0] = op;
924  format[1] = *src;
925  format[2] = '\0';
926 
927  tag = mutt_hash_find(TagFormats, format);
928  if (tag)
929  {
930  tags = driver_tags_get_transformed_for(tag, &e->tags);
931  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAG);
932  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
933  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
934  FREE(&tags);
935  }
936  src++;
937  }
938  else
939  {
940  format[0] = op;
941  format[1] = *prec;
942  format[2] = '\0';
943 
944  tag = mutt_hash_find(TagFormats, format);
945  if (tag)
946  {
947  tags = driver_tags_get_transformed_for(tag, &e->tags);
948  if (!tags)
949  optional = 0;
950  FREE(&tags);
951  }
952  }
953  break;
954  }
955 
956  case 'H':
957  /* (Hormel) spam score */
958  if (optional)
959  optional = e->env->spam ? 1 : 0;
960 
961  if (e->env->spam)
962  mutt_format_s(buf, buflen, prec, NONULL(e->env->spam->data));
963  else
964  mutt_format_s(buf, buflen, prec, "");
965  break;
966 
967  case 'i':
968  mutt_format_s(buf, buflen, prec, e->env->message_id ? e->env->message_id : "<no.id>");
969  break;
970 
971  case 'J':
972  {
973  bool have_tags = true;
974  tags = driver_tags_get_transformed(&e->tags);
975  if (tags)
976  {
977  if (flags & MUTT_FORMAT_TREE)
978  {
979  char *parent_tags = NULL;
980  if (e->thread->prev && e->thread->prev->message)
981  {
982  parent_tags = driver_tags_get_transformed(&e->thread->prev->message->tags);
983  }
984  if (!parent_tags && e->thread->parent && e->thread->parent->message)
985  {
986  parent_tags =
988  }
989  if (parent_tags && (mutt_str_strcasecmp(tags, parent_tags) == 0))
990  have_tags = false;
991  FREE(&parent_tags);
992  }
993  }
994  else
995  have_tags = false;
996 
997  if (optional)
998  optional = have_tags;
999 
1000  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
1001  if (have_tags)
1002  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tags);
1003  else
1004  mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
1005  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1006  FREE(&tags);
1007  break;
1008  }
1009 
1010  case 'l':
1011  if (!optional)
1012  {
1013  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
1014  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
1015  snprintf(buf + colorlen, buflen - colorlen, fmt, (int) e->lines);
1016  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1017  }
1018  else if (e->lines <= 0)
1019  optional = 0;
1020  break;
1021 
1022  case 'L':
1023  if (!optional)
1024  {
1025  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
1026  make_from(e->env, tmp, sizeof(tmp), true, flags);
1027  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1028  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1029  }
1030  else if (!check_for_mailing_list(&e->env->to, NULL, NULL, 0) &&
1031  !check_for_mailing_list(&e->env->cc, NULL, NULL, 0))
1032  {
1033  optional = 0;
1034  }
1035  break;
1036 
1037  case 'm':
1038  if (m)
1039  {
1040  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
1041  snprintf(buf, buflen, fmt, m->msg_count);
1042  }
1043  else
1044  mutt_str_strfcpy(buf, "(null)", buflen);
1045  break;
1046 
1047  case 'n':
1048  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
1049  mutt_format_s(buf + colorlen, buflen - colorlen, prec, mutt_get_name(from));
1050  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1051  break;
1052 
1053  case 'M':
1054  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
1055  if (!optional)
1056  {
1057  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_COLLAPSED);
1058  if (threads && is_index && e->collapsed && (e->num_hidden > 1))
1059  {
1060  snprintf(buf + colorlen, buflen - colorlen, fmt, e->num_hidden);
1061  add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
1062  }
1063  else if (is_index && threads)
1064  {
1065  mutt_format_s(buf + colorlen, buflen - colorlen, prec, " ");
1066  add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
1067  }
1068  else
1069  *buf = '\0';
1070  }
1071  else
1072  {
1073  if (!(threads && is_index && e->collapsed && (e->num_hidden > 1)))
1074  optional = 0;
1075  }
1076  break;
1077 
1078  case 'N':
1079  if (!optional)
1080  {
1081  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
1082  snprintf(buf, buflen, fmt, e->score);
1083  }
1084  else
1085  {
1086  if (e->score == 0)
1087  optional = 0;
1088  }
1089  break;
1090 
1091  case 'O':
1092  if (!optional)
1093  {
1094  make_from_addr(e->env, tmp, sizeof(tmp), true);
1095  if (!C_SaveAddress && (p = strpbrk(tmp, "%@")))
1096  *p = '\0';
1097  mutt_format_s(buf, buflen, prec, tmp);
1098  }
1099  else if (!check_for_mailing_list_addr(&e->env->to, NULL, 0) &&
1100  !check_for_mailing_list_addr(&e->env->cc, NULL, 0))
1101  {
1102  optional = 0;
1103  }
1104  break;
1105 
1106  case 'P':
1107  mutt_str_strfcpy(buf, hfi->pager_progress, buflen);
1108  break;
1109 
1110 #ifdef USE_NNTP
1111  case 'q':
1112  mutt_format_s(buf, buflen, prec, e->env->newsgroups ? e->env->newsgroups : "");
1113  break;
1114 #endif
1115 
1116  case 'r':
1117  tmp[0] = '\0';
1118  mutt_addrlist_write(tmp, sizeof(tmp), &e->env->to, true);
1119  if (optional && (tmp[0] == '\0'))
1120  optional = 0;
1121  mutt_format_s(buf, buflen, prec, tmp);
1122  break;
1123 
1124  case 'R':
1125  tmp[0] = '\0';
1126  mutt_addrlist_write(tmp, sizeof(tmp), &e->env->cc, true);
1127  if (optional && (tmp[0] == '\0'))
1128  optional = 0;
1129  mutt_format_s(buf, buflen, prec, tmp);
1130  break;
1131 
1132  case 's':
1133  {
1134  char *subj = NULL;
1135  if (e->env->disp_subj)
1136  subj = e->env->disp_subj;
1137  else if (!STAILQ_EMPTY(&SubjectRegexList))
1138  subj = apply_subject_mods(e->env);
1139  else
1140  subj = e->env->subject;
1141  if (flags & MUTT_FORMAT_TREE && !e->collapsed)
1142  {
1143  if (flags & MUTT_FORMAT_FORCESUBJ)
1144  {
1145  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
1146  mutt_format_s(buf + colorlen, buflen - colorlen, "", NONULL(subj));
1147  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1148  snprintf(tmp, sizeof(tmp), "%s%s", e->tree, buf);
1149  mutt_format_s_tree(buf, buflen, prec, tmp);
1150  }
1151  else
1152  mutt_format_s_tree(buf, buflen, prec, e->tree);
1153  }
1154  else
1155  {
1156  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
1157  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(subj));
1158  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1159  }
1160  break;
1161  }
1162 
1163  case 'S':
1164  {
1165  const char *wch = NULL;
1166  if (e->deleted)
1168  else if (e->attach_del)
1170  else if (e->tagged)
1172  else if (e->flagged)
1174  else if (e->replied)
1176  else if (e->read && (ctx && (ctx->msgnotreadyet != e->msgno)))
1178  else if (e->old)
1180  else
1182 
1183  snprintf(tmp, sizeof(tmp), "%s", wch);
1184  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
1185  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1186  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1187  break;
1188  }
1189 
1190  case 't':
1191  tmp[0] = '\0';
1192  if (!check_for_mailing_list(&e->env->to, "To ", tmp, sizeof(tmp)) &&
1193  !check_for_mailing_list(&e->env->cc, "Cc ", tmp, sizeof(tmp)))
1194  {
1195  if (to)
1196  snprintf(tmp, sizeof(tmp), "To %s", mutt_get_name(to));
1197  else if (cc)
1198  snprintf(tmp, sizeof(tmp), "Cc %s", mutt_get_name(cc));
1199  }
1200  mutt_format_s(buf, buflen, prec, tmp);
1201  break;
1202 
1203  case 'T':
1204  {
1205  int i;
1206  snprintf(fmt, sizeof(fmt), "%%%ss", prec);
1207  snprintf(buf, buflen, fmt,
1208  (C_ToChars && ((i = user_is_recipient(e))) < C_ToChars->len) ?
1209  C_ToChars->chars[i] :
1210  " ");
1211  break;
1212  }
1213 
1214  case 'u':
1215  if (from && from->mailbox)
1216  {
1217  mutt_str_strfcpy(tmp, mutt_addr_for_display(from), sizeof(tmp));
1218  p = strpbrk(tmp, "%@");
1219  if (p)
1220  *p = '\0';
1221  }
1222  else
1223  tmp[0] = '\0';
1224  mutt_format_s(buf, buflen, prec, tmp);
1225  break;
1226 
1227  case 'v':
1228  if (mutt_addr_is_user(from))
1229  {
1230  if (to)
1231  mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(to));
1232  else if (cc)
1233  mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(cc));
1234  else
1235  *tmp = '\0';
1236  }
1237  else
1238  mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(from));
1239  p = strpbrk(tmp, " %@");
1240  if (p)
1241  *p = '\0';
1242  mutt_format_s(buf, buflen, prec, tmp);
1243  break;
1244 
1245  case 'W':
1246  if (!optional)
1247  {
1248  mutt_format_s(buf, buflen, prec, e->env->organization ? e->env->organization : "");
1249  }
1250  else if (!e->env->organization)
1251  optional = 0;
1252  break;
1253 
1254 #ifdef USE_NNTP
1255  case 'x':
1256  if (!optional)
1257  {
1258  mutt_format_s(buf, buflen, prec, e->env->x_comment_to ? e->env->x_comment_to : "");
1259  }
1260  else if (!e->env->x_comment_to)
1261  optional = 0;
1262  break;
1263 #endif
1264 
1265  case 'X':
1266  {
1267  int count = mutt_count_body_parts(m, e);
1268 
1269  /* The recursion allows messages without depth to return 0. */
1270  if (optional)
1271  optional = count != 0;
1272 
1273  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
1274  snprintf(buf, buflen, fmt, count);
1275  break;
1276  }
1277 
1278  case 'y':
1279  if (optional)
1280  optional = e->env->x_label ? 1 : 0;
1281 
1282  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
1283  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(e->env->x_label));
1284  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1285  break;
1286 
1287  case 'Y':
1288  {
1289  bool label = true;
1290  if (e->env->x_label)
1291  {
1292  struct Email *e_tmp = NULL;
1293  if (flags & MUTT_FORMAT_TREE && (e->thread->prev && e->thread->prev->message &&
1294  e->thread->prev->message->env->x_label))
1295  {
1296  e_tmp = e->thread->prev->message;
1297  }
1298  else if (flags & MUTT_FORMAT_TREE &&
1299  (e->thread->parent && e->thread->parent->message &&
1300  e->thread->parent->message->env->x_label))
1301  {
1302  e_tmp = e->thread->parent->message;
1303  }
1304  if (e_tmp && (mutt_str_strcasecmp(e->env->x_label, e_tmp->env->x_label) == 0))
1305  label = false;
1306  }
1307  else
1308  label = false;
1309 
1310  if (optional)
1311  optional = label;
1312 
1313  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
1314  if (label)
1315  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(e->env->x_label));
1316  else
1317  mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
1318  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1319  break;
1320  }
1321 
1322  case 'z':
1323  if (src[0] == 's') /* status: deleted/new/old/replied */
1324  {
1325  const char *ch = NULL;
1326  if (e->deleted)
1328  else if (e->attach_del)
1330  else if (threads && thread_is_new(ctx, e))
1332  else if (threads && thread_is_old(ctx, e))
1334  else if (e->read && (ctx && (ctx->msgnotreadyet != e->msgno)))
1335  {
1336  if (e->replied)
1338  else
1340  }
1341  else
1342  {
1343  if (e->old)
1345  else
1347  }
1348 
1349  snprintf(tmp, sizeof(tmp), "%s", ch);
1350  src++;
1351  }
1352  else if (src[0] == 'c') /* crypto */
1353  {
1354  const char *ch = "";
1355  if ((WithCrypto != 0) && (e->security & SEC_GOODSIGN))
1357  else if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
1359  else if ((WithCrypto != 0) && (e->security & SEC_SIGN))
1361  else if (((WithCrypto & APPLICATION_PGP) != 0) && ((e->security & PGP_KEY) == PGP_KEY))
1362  {
1364  }
1365  else
1367 
1368  snprintf(tmp, sizeof(tmp), "%s", ch);
1369  src++;
1370  }
1371  else if (src[0] == 't') /* tagged, flagged, recipient */
1372  {
1373  const char *ch = "";
1374  if (e->tagged)
1376  else if (e->flagged)
1378  else
1380 
1381  snprintf(tmp, sizeof(tmp), "%s", ch);
1382  src++;
1383  }
1384  else /* fallthrough */
1385  break;
1386 
1387  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
1388  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1389  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1390  break;
1391 
1392  case 'Z':
1393  {
1394  /* New/Old for threads; replied; New/Old for messages */
1395  const char *first = NULL;
1396  if (threads && thread_is_new(ctx, e))
1398  else if (threads && thread_is_old(ctx, e))
1400  else if (e->read && (ctx && (ctx->msgnotreadyet != e->msgno)))
1401  {
1402  if (e->replied)
1404  else
1406  }
1407  else
1408  {
1409  if (e->old)
1411  else
1413  }
1414 
1415  /* Marked for deletion; deleted attachments; crypto */
1416  const char *second = "";
1417  if (e->deleted)
1419  else if (e->attach_del)
1421  else if ((WithCrypto != 0) && (e->security & SEC_GOODSIGN))
1423  else if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
1425  else if ((WithCrypto != 0) && (e->security & SEC_SIGN))
1427  else if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & PGP_KEY))
1429  else
1431 
1432  /* Tagged, flagged and recipient flag */
1433  const char *third = "";
1434  if (e->tagged)
1436  else if (e->flagged)
1438  else
1440 
1441  snprintf(tmp, sizeof(tmp), "%s%s%s", first, second, third);
1442  }
1443 
1444  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
1445  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1446  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1447  break;
1448 
1449  case '@':
1450  {
1451  const char *end = src;
1452  static unsigned char recurse = 0;
1453 
1454  while ((*end != '\0') && (*end != '@'))
1455  end++;
1456  if ((*end == '@') && (recurse < 20))
1457  {
1458  recurse++;
1459  mutt_str_substr_copy(src, end, tmp, sizeof(tmp));
1460  mutt_expando_format(tmp, sizeof(tmp), col, cols,
1461  NONULL(mutt_idxfmt_hook(tmp, m, e)),
1462  index_format_str, data, flags);
1463  mutt_format_s_x(buf, buflen, prec, tmp, true);
1464  recurse--;
1465 
1466  src = end + 1;
1467  break;
1468  }
1469  }
1470  /* fallthrough */
1471 
1472  default:
1473  snprintf(buf, buflen, "%%%s%c", prec, op);
1474  break;
1475  }
1476 
1477  if (optional)
1478  {
1479  mutt_expando_format(buf, buflen, col, cols, if_str, index_format_str,
1480  (unsigned long) hfi, flags);
1481  }
1482  else if (flags & MUTT_FORMAT_OPTIONAL)
1483  {
1484  mutt_expando_format(buf, buflen, col, cols, else_str, index_format_str,
1485  (unsigned long) hfi, flags);
1486  }
1487 
1488  return src;
1489 }
Index: subject field (takes a pattern)
Definition: mutt_curses.h:160
struct Context * ctx
Definition: hdrline.h:46
The "current" mailbox.
Definition: context.h:39
Character denoting a tagged email.
Definition: hdrline.c:72
void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src, format_t *callback, unsigned long data, MuttFormatFlags flags)
Expand expandos (x) in a string.
Definition: muttlib.c:841
Character denoting a important (flagged) email.
Definition: hdrline.c:73
int lines
How many lines in the body of this message?
Definition: email.h:84
#define NONULL(x)
Definition: string2.h:37
int msg_count
Total number of messages.
Definition: mailbox.h:103
The envelope/body of an email.
Definition: email.h:37
#define TAILQ_FIRST(head)
Definition: queue.h:717
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
Index: tags field (g, J)
Definition: mutt_curses.h:167
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:48
struct tm mutt_date_localtime(time_t t)
Converts calendar time to a broken-down time structure expressed in user timezone.
Definition: date.c:713
#define MUTT_FORMAT_FORCESUBJ
Print the subject even if unchanged.
Definition: format_flags.h:31
struct MuttThread * thread
Thread of Emails.
Definition: email.h:94
static bool thread_is_new(struct Context *ctx, struct Email *e)
Does the email thread contain any new emails?
Definition: hdrline.c:483
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:54
Character denoting a thread containing at least one new email.
Definition: hdrline.c:80
bool attach_del
Has an attachment marked for deletion.
Definition: email.h:49
int msgnotreadyet
which msg "new" in pager, -1 if none
Definition: context.h:47
void * mutt_hash_find(const struct Hash *table, const char *strkey)
Find the HashElem data in a Hash table element using a key.
Definition: hash.c:379
WHERE struct Hash * TagFormats
Hash table of tag-formats (tag -> format string)
Definition: globals.h:59
Character denoting a message contains a PGP key.
Definition: hdrline.c:93
An email address.
Definition: address.h:34
#define MUTT_DATE_NOW
Constant representing the &#39;current time&#39;, see: mutt_date_gmtime(), mutt_date_localtime() ...
Definition: date.h:36
struct MuttThread * parent
Parent of this Thread.
Definition: thread.h:45
char * mailbox
Mailbox and host address.
Definition: address.h:37
Character denoting a read email, $index_format S expando.
Definition: hdrline.c:81
struct TagHead tags
For drivers that support server tagging.
Definition: email.h:106
struct tm mutt_date_gmtime(time_t t)
Converts calendar time to a broken-down time structure expressed in UTC timezone. ...
Definition: date.c:731
size_t mutt_addrlist_write(char *buf, size_t buflen, const struct AddressList *al, bool display)
Write an Address to a buffer.
Definition: address.c:1134
char * driver_tags_get_transformed(struct TagHead *head)
Get transformed tags.
Definition: tags.c:131
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:121
bool zoccident
True, if west of UTC, False if east.
Definition: email.h:65
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
struct MbTable * C_ToChars
Config: Indicator characters for the &#39;To&#39; field in the index.
Definition: hdrline.c:65
static char * apply_subject_mods(struct Envelope *env)
Apply regex modifications to the subject.
Definition: hdrline.c:459
static void make_from(struct Envelope *env, char *buf, size_t buflen, bool do_lists, MuttFormatFlags flags)
Generate a From: field (with optional prefix)
Definition: hdrline.c:312
bool tagged
Email is tagged.
Definition: email.h:44
bool read
Email is read.
Definition: email.h:51
const char * mutt_addr_for_display(const struct Address *a)
Convert an Address for display purposes.
Definition: address.c:973
char * message_id
Message ID.
Definition: envelope.h:55
struct MuttThread * prev
Previous sibling Thread.
Definition: thread.h:48
#define MUTT_FORMAT_TREE
Draw the thread tree.
Definition: format_flags.h:32
bool old
Email is seen, but unread.
Definition: email.h:50
Data passed to index_format_str()
Definition: hdrline.h:44
size_t mutt_email_size(const struct Email *e)
compute the size of an email
Definition: email.c:109
#define SEC_GOODSIGN
Email has a valid signature.
Definition: ncrypt.h:123
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:43
Index: default colour (takes a pattern)
Definition: mutt_curses.h:156
struct Envelope * env
Envelope information.
Definition: email.h:89
Character denoting a deleted attachment.
Definition: hdrline.c:75
struct Mailbox * mailbox
Definition: hdrline.h:47
Index: index number.
Definition: mutt_curses.h:165
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:45
Character denoting an email that has been read.
Definition: hdrline.c:77
static int user_is_recipient(struct Email *e)
Is the user a recipient of the message.
Definition: hdrline.c:418
Character denoting a thread of emails that has been read.
Definition: hdrline.c:79
WHERE short C_Sort
Config: Sort method for the index.
Definition: sort.h:59
int score
Message score.
Definition: email.h:88
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:81
#define mutt_b2s(buf)
Definition: buffer.h:42
char * x_comment_to
List of &#39;X-comment-to&#39; fields.
Definition: envelope.h:64
const char * mutt_idxfmt_hook(const char *name, struct Mailbox *m, struct Email *e)
Get index-format-hook format string.
Definition: hook.c:880
Index: tag field (g, takes a pattern)
Definition: mutt_curses.h:159
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:122
Index: flags field (takes a pattern)
Definition: mutt_curses.h:158
Character denoting an email that has been replied to.
Definition: hdrline.c:76
Index: date field.
Definition: mutt_curses.h:163
A mailbox.
Definition: mailbox.h:93
void mutt_format_s_x(char *buf, size_t buflen, const char *prec, const char *s, bool arboreal)
Format a string like snprintf()
Definition: curs_lib.c:1102
static void make_from_addr(struct Envelope *env, char *buf, size_t buflen, bool do_lists)
Create a &#39;from&#39; address for a reply email.
Definition: hdrline.c:368
size_t num_hidden
Number of hidden messages in this view.
Definition: email.h:75
#define PGP_KEY
Definition: ncrypt.h:139
static bool thread_is_old(struct Context *ctx, struct Email *e)
Does the email thread contain any unread emails?
Definition: hdrline.c:495
Index: author field (takes a pattern)
Definition: mutt_curses.h:157
Character denoting a message signed with a verified key.
Definition: hdrline.c:90
char * data
Pointer to data.
Definition: buffer.h:35
bool mutt_mb_get_initials(const char *name, char *buf, size_t buflen)
Turn a name into initials.
Definition: mbyte.c:84
size_t mutt_str_strfcpy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:750
static size_t add_index_color(char *buf, size_t buflen, MuttFormatFlags flags, char color)
Insert a color marker into a string.
Definition: hdrline.c:207
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:73
char * driver_tags_get_transformed_for(const char *name, struct TagHead *head)
Get transformed tag for a tag name from a header.
Definition: tags.c:170
static bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: hdrline.c:136
Character denoting a message is PGP-encrypted.
Definition: hdrline.c:91
int mutt_messages_in_thread(struct Mailbox *m, struct Email *e, int flag)
Count the messages in a thread.
Definition: mutt_thread.c:1396
unsigned int zhours
Hours away from UTC.
Definition: email.h:63
char * tree
Character string to print thread tree.
Definition: email.h:93
SecurityFlags security
bit 0-8: flags, bit 9,10: application.
Definition: email.h:39
struct Email * message
Email this Thread refers to.
Definition: thread.h:49
static const char * get_nth_wchar(struct MbTable *table, int index)
Extract one char from a multi-byte table.
Definition: hdrline.c:259
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:130
struct Buffer * pathbuf
Definition: mailbox.h:95
Character denoting a read email, $index_format Z expando.
Definition: hdrline.c:82
#define MUTT_FORMAT_INDEX
This is a main index entry.
Definition: format_flags.h:36
struct Buffer * spam
Spam header.
Definition: envelope.h:66
char * subject
Email&#39;s subject.
Definition: envelope.h:52
void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s)
Format a simple string.
Definition: curs_lib.c:1139
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
bool flagged
Marked important?
Definition: email.h:43
char * newsgroups
List of newsgroups.
Definition: envelope.h:61
Character denoting a deleted email.
Definition: hdrline.c:74
struct MbTable * C_FlagChars
Config: User-configurable index flags: tagged, new, etc.
Definition: hdrline.c:63
bool deleted
Email is deleted.
Definition: email.h:45
Index: size field.
Definition: mutt_curses.h:166
bool replied
Email has been replied to.
Definition: email.h:54
static bool check_for_mailing_list_addr(struct AddressList *al, char *buf, int buflen)
Check an address list for a mailing list.
Definition: hdrline.c:161
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
WHERE char * C_DateFormat
Config: strftime format string for the d expando.
Definition: globals.h:101
Character denoting an unread email.
Definition: hdrline.c:78
Character denoting a message has no cryptography information.
Definition: hdrline.c:94
#define FREE(x)
Definition: memory.h:40
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:669
const char * pager_progress
Definition: hdrline.h:49
char * organization
Organisation header.
Definition: envelope.h:59
Character denoting a message is signed.
Definition: hdrline.c:92
#define STAILQ_EMPTY(head)
Definition: queue.h:346
#define MUTT_FORMAT_OPTIONAL
Allow optional field processing.
Definition: format_flags.h:33
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:44
Index: number of messages in collapsed thread.
Definition: mutt_curses.h:162
Index: label field.
Definition: mutt_curses.h:164
int mutt_count_body_parts(struct Mailbox *m, struct Email *e)
Count the MIME Body parts.
Definition: mutt_parse.c:216
void mutt_str_pretty_size(char *buf, size_t buflen, size_t num)
Display an abbreviated size, like 3.4K.
Definition: string.c:1047
struct MbTable * C_CryptChars
Config: User-configurable crypto flags: signed, encrypted etc.
Definition: hdrline.c:62
struct Email * email
Definition: hdrline.h:48
Sort by email threads.
Definition: sort.h:56
char * x_label
X-Label.
Definition: envelope.h:58
#define WithCrypto
Definition: ncrypt.h:156
#define SORT_MASK
Mask for the sort id.
Definition: sort.h:85
unsigned int zminutes
Minutes away from UTC.
Definition: email.h:64
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:82
static bool first_mailing_list(char *buf, size_t buflen, struct AddressList *al)
Get the first mailing list in the list of addresses.
Definition: hdrline.c:183
WHERE bool C_SaveAddress
Config: Use sender&#39;s full address as a default save folder.
Definition: globals.h:246
int len
Number of characters.
Definition: mbtable.h:38
void mutt_format_s_tree(char *buf, size_t buflen, const char *prec, const char *s)
Format a simple string with tree characters.
Definition: curs_lib.c:1151
int msgno
Number displayed to the user.
Definition: email.h:86
static const char * index_format_str(char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, unsigned long data, MuttFormatFlags flags)
Format a string for the index list - Implements format_t.
Definition: hdrline.c:556
char * mutt_str_substr_copy(const char *begin, const char *end, char *buf, size_t buflen)
Copy a sub-string into a buffer.
Definition: string.c:556
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:156
struct ReplaceList SubjectRegexList
List of regexes to tidy the view of the email&#39;s subject.
Definition: email_globals.c:53
void mutt_make_string_flags ( char *  buf,
size_t  buflen,
const char *  s,
struct Context ctx,
struct Mailbox m,
struct Email e,
MuttFormatFlags  flags 
)

Create formatted strings using mailbox expandos.

Parameters
bufBuffer for the result
buflenBuffer length
sprintf-line format string
ctxMailbox Context
mMailbox
eEmail
flagsFlags, see MuttFormatFlags

Definition at line 1501 of file hdrline.c.

1503 {
1504  struct HdrFormatInfo hfi;
1505 
1506  hfi.email = e;
1507  hfi.ctx = ctx;
1508  hfi.mailbox = m;
1509  hfi.pager_progress = 0;
1510 
1511  mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, s,
1512  index_format_str, (unsigned long) &hfi, flags);
1513 }
struct Context * ctx
Definition: hdrline.h:46
void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src, format_t *callback, unsigned long data, MuttFormatFlags flags)
Expand expandos (x) in a string.
Definition: muttlib.c:841
struct Mailbox * mailbox
Definition: context.h:53
Data passed to index_format_str()
Definition: hdrline.h:44
struct MuttWindow * MuttIndexWindow
Index Window.
Definition: mutt_window.c:39
struct Email * email
Definition: hdrline.h:48
static const char * index_format_str(char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, unsigned long data, MuttFormatFlags flags)
Format a string for the index list - Implements format_t.
Definition: hdrline.c:556
void mutt_make_string_info ( char *  buf,
size_t  buflen,
int  cols,
const char *  s,
struct HdrFormatInfo hfi,
MuttFormatFlags  flags 
)

Create pager status bar string.

Parameters
bufBuffer for the result
buflenBuffer length
colsNumber of screen columns
sprintf-line format string
hfiMailbox data to pass to the formatter
flagsFlags, see MuttFormatFlags

Definition at line 1524 of file hdrline.c.

1526 {
1527  mutt_expando_format(buf, buflen, 0, cols, s, index_format_str, (unsigned long) hfi, flags);
1528 }
void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src, format_t *callback, unsigned long data, MuttFormatFlags flags)
Expand expandos (x) in a string.
Definition: muttlib.c:841
static const char * index_format_str(char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, unsigned long data, MuttFormatFlags flags)
Format a string for the index list - Implements format_t.
Definition: hdrline.c:556

Variable Documentation

struct MbTable* C_CryptChars

Config: User-configurable crypto flags: signed, encrypted etc.

Definition at line 62 of file hdrline.c.

struct MbTable* C_FlagChars

Config: User-configurable index flags: tagged, new, etc.

Definition at line 63 of file hdrline.c.

struct MbTable* C_FromChars

Config: User-configurable index flags: to address, cc address, etc.

Definition at line 64 of file hdrline.c.

struct MbTable* C_ToChars

Config: Indicator characters for the 'To' field in the index.

Definition at line 65 of file hdrline.c.