NeoMutt  2018-07-16 +2388-bcedc8
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 "core/lib.h"
#include "hdrline.h"
#include "alias.h"
#include "context.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"
+ Include dependency graph for hdrline.c:

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 69 of file hdrline.c.

70 {
82 };
Character denoting a tagged email.
Definition: hdrline.c:71
Character denoting a important (flagged) email.
Definition: hdrline.c:72
Character denoting a thread containing at least one new email.
Definition: hdrline.c:79
Character denoting a read email, $index_format S expando.
Definition: hdrline.c:80
Character denoting a deleted attachment.
Definition: hdrline.c:74
Character denoting an email that has been read.
Definition: hdrline.c:76
Character denoting a thread of emails that has been read.
Definition: hdrline.c:78
Character denoting an email that has been replied to.
Definition: hdrline.c:75
Character denoting a read email, $index_format Z expando.
Definition: hdrline.c:81
Character denoting a deleted email.
Definition: hdrline.c:73
Character denoting an unread email.
Definition: hdrline.c:77
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 87 of file hdrline.c.

88 {
94 };
Character denoting a message contains a PGP key.
Definition: hdrline.c:92
Character denoting a message signed with a verified key.
Definition: hdrline.c:89
Character denoting a message is PGP-encrypted.
Definition: hdrline.c:90
Character denoting a message has no cryptography information.
Definition: hdrline.c:93
Character denoting a message is signed.
Definition: hdrline.c:91
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 238 of file hdrline.c.

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

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 101 of file hdrline.c.

102 {
104  return mutt_regexlist_match(&MailLists, addr->mailbox);
105  return false;
106 }
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:191
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

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 113 of file hdrline.c.

114 {
115  if (!mutt_regexlist_match(&UnMailLists, addr->mailbox) &&
117  {
119  }
120  return false;
121 }
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:191
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

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 135 of file hdrline.c.

137 {
138  struct Address *a = NULL;
139  TAILQ_FOREACH(a, al, entries)
140  {
142  {
143  if (pfx && buf && buflen)
144  snprintf(buf, buflen, "%s%s", pfx, mutt_get_name(a));
145  return true;
146  }
147  }
148  return false;
149 }
#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:113
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:155

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 160 of file hdrline.c.

161 {
162  struct Address *a = NULL;
163  TAILQ_FOREACH(a, al, entries)
164  {
166  {
167  if (buf && buflen)
168  snprintf(buf, buflen, "%s", a->mailbox);
169  return true;
170  }
171  }
172  return false;
173 }
#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:113

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 182 of file hdrline.c.

183 {
184  struct Address *a = NULL;
185  TAILQ_FOREACH(a, al, entries)
186  {
188  {
189  mutt_save_path(buf, buflen, a);
190  return true;
191  }
192  }
193  return false;
194 }
#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:113
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:794

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 206 of file hdrline.c.

207 {
208  /* only add color markers if we are operating on main index entries. */
209  if (!(flags & MUTT_FORMAT_INDEX))
210  return 0;
211 
212  /* this item is going to be passed to an external filter */
213  if (flags & MUTT_FORMAT_NOFILTER)
214  return 0;
215 
216  if (color == MT_COLOR_INDEX)
217  { /* buf might be uninitialized other cases */
218  const size_t len = mutt_str_strlen(buf);
219  buf += len;
220  buflen -= len;
221  }
222 
223  if (buflen <= 2)
224  return 0;
225 
226  buf[0] = MUTT_SPECIAL_INDEX;
227  buf[1] = color;
228  buf[2] = '\0';
229 
230  return 2;
231 }
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

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 258 of file hdrline.c.

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

+ Here is the caller graph for this function:

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 277 of file hdrline.c.

278 {
279  /* need 2 bytes at the end, one for the space, another for NUL */
280  static char padded[8];
281  static const char *long_prefixes[DISP_MAX] = {
282  [DISP_TO] = "To ", [DISP_CC] = "Cc ", [DISP_BCC] = "Bcc ",
283  [DISP_FROM] = "", [DISP_PLAIN] = "",
284  };
285 
286  if (!C_FromChars || !C_FromChars->chars || (C_FromChars->len == 0))
287  return long_prefixes[disp];
288 
289  const char *pchar = get_nth_wchar(C_FromChars, disp);
290  if (mutt_str_strlen(pchar) == 0)
291  return "";
292 
293  snprintf(padded, sizeof(padded), "%s ", pchar);
294  return padded;
295 }
Bcc: string.
Definition: hdrline.c:242
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
Cc: string.
Definition: hdrline.c:241
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:63
Empty string.
Definition: hdrline.c:244
From: string.
Definition: hdrline.c:243
static const char * get_nth_wchar(struct MbTable *table, int index)
Extract one char from a multi-byte table.
Definition: hdrline.c:258
To: string.
Definition: hdrline.c:240
int len
Number of characters.
Definition: mbtable.h:38

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 311 of file hdrline.c.

313 {
314  if (!env || !buf)
315  return;
316 
317  bool me;
318  enum FieldType disp;
319  struct AddressList *name = NULL;
320 
321  me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
322 
323  if (do_lists || me)
324  {
325  if (check_for_mailing_list(&env->to, make_from_prefix(DISP_TO), buf, buflen))
326  return;
327  if (check_for_mailing_list(&env->cc, make_from_prefix(DISP_CC), buf, buflen))
328  return;
329  }
330 
331  if (me && !TAILQ_EMPTY(&env->to))
332  {
333  disp = (flags & MUTT_FORMAT_PLAIN) ? DISP_PLAIN : DISP_TO;
334  name = &env->to;
335  }
336  else if (me && !TAILQ_EMPTY(&env->cc))
337  {
338  disp = DISP_CC;
339  name = &env->cc;
340  }
341  else if (me && !TAILQ_EMPTY(&env->bcc))
342  {
343  disp = DISP_BCC;
344  name = &env->bcc;
345  }
346  else if (!TAILQ_EMPTY(&env->from))
347  {
348  disp = DISP_FROM;
349  name = &env->from;
350  }
351  else
352  {
353  *buf = '\0';
354  return;
355  }
356 
357  snprintf(buf, buflen, "%s%s", make_from_prefix(disp), mutt_get_name(TAILQ_FIRST(name)));
358 }
Bcc: string.
Definition: hdrline.c:242
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
Cc: string.
Definition: hdrline.c:241
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
const char * name
Definition: pgpmicalg.c:45
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
Empty string.
Definition: hdrline.c:244
From: string.
Definition: hdrline.c:243
static const char * make_from_prefix(enum FieldType disp)
Create a prefix for an author field.
Definition: hdrline.c:277
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:135
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
To: string.
Definition: hdrline.c:240
FieldType
Header types.
Definition: hdrline.c:238
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:668
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#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:155

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 367 of file hdrline.c.

368 {
369  if (!env || !buf)
370  return;
371 
372  bool me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
373 
374  if (do_lists || me)
375  {
376  if (check_for_mailing_list_addr(&env->to, buf, buflen))
377  return;
378  if (check_for_mailing_list_addr(&env->cc, buf, buflen))
379  return;
380  }
381 
382  if (me && !TAILQ_EMPTY(&env->to))
383  snprintf(buf, buflen, "%s", TAILQ_FIRST(&env->to)->mailbox);
384  else if (me && !TAILQ_EMPTY(&env->cc))
385  snprintf(buf, buflen, "%s", TAILQ_FIRST(&env->cc)->mailbox);
386  else if (!TAILQ_EMPTY(&env->from))
387  mutt_str_strfcpy(buf, TAILQ_FIRST(&env->from)->mailbox, buflen);
388  else
389  *buf = '\0';
390 }
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
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:160
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:668
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:715

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 397 of file hdrline.c.

398 {
399  struct Address *a = NULL;
400  TAILQ_FOREACH(a, al, entries)
401  if (mutt_addr_is_user(a))
402  return true;
403  return false;
404 }
#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:668

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 417 of file hdrline.c.

418 {
419  if (!e || !e->env)
420  return 0;
421 
422  struct Envelope *env = e->env;
423 
424  if (!e->recip_valid)
425  {
426  e->recip_valid = true;
427 
428  if (mutt_addr_is_user(TAILQ_FIRST(&env->from)))
429  e->recipient = 4;
430  else if (user_in_addr(&env->to))
431  {
432  if (TAILQ_NEXT(TAILQ_FIRST(&env->to), entries) || !TAILQ_EMPTY(&env->cc))
433  e->recipient = 2; /* non-unique recipient */
434  else
435  e->recipient = 1; /* unique recipient */
436  }
437  else if (user_in_addr(&env->cc))
438  e->recipient = 3;
439  else if (check_for_mailing_list(&env->to, NULL, NULL, 0))
440  e->recipient = 5;
441  else if (check_for_mailing_list(&env->cc, NULL, NULL, 0))
442  e->recipient = 5;
443  else if (user_in_addr(&env->reply_to))
444  e->recipient = 6;
445  else
446  e->recipient = 0;
447  }
448 
449  return e->recipient;
450 }
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:62
static bool user_in_addr(struct AddressList *al)
Do any of the addresses refer to the user?
Definition: hdrline.c:397
short recipient
User_is_recipient()&#39;s return value, cached.
Definition: email.h:79
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct Envelope * env
Envelope information.
Definition: email.h:91
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
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:135
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:668
bool recip_valid
Is_recipient is valid.
Definition: email.h:60
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#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:54

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 458 of file hdrline.c.

459 {
460  if (!env)
461  return NULL;
462 
464  return env->subject;
465 
466  if (!env->subject || (*env->subject == '\0'))
467  {
468  env->disp_subj = NULL;
469  return NULL;
470  }
471 
473  return env->disp_subj;
474 }
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:68
char * mutt_replacelist_apply(struct ReplaceList *rl, char *buf, size_t buflen, const char *str)
Apply replacements to a buffer.
Definition: regex.c:352
char * subject
Email&#39;s subject.
Definition: envelope.h:66
#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

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 482 of file hdrline.c.

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

+ Here is the caller graph for this function:

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 494 of file hdrline.c.

495 {
496  return e->collapsed && (e->num_hidden > 1) &&
497  (mutt_thread_contains_unread(ctx, e) == 2);
498 }
size_t num_hidden
Number of hidden messages in this view.
Definition: email.h:77
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:75
#define mutt_thread_contains_unread(ctx, e)
Definition: mutt_thread.h:60

+ Here is the caller graph for this function:

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 555 of file hdrline.c.

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

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 1500 of file hdrline.c.

1502 {
1503  struct HdrFormatInfo hfi;
1504 
1505  hfi.email = e;
1506  hfi.ctx = ctx;
1507  hfi.mailbox = m;
1508  hfi.pager_progress = 0;
1509 
1510  mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, s,
1511  index_format_str, (unsigned long) &hfi, flags);
1512 }
struct Context * ctx
Definition: hdrline.h:47
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:838
struct Mailbox * mailbox
Definition: context.h:50
Data passed to index_format_str()
Definition: hdrline.h:45
struct MuttWindow * MuttIndexWindow
Index Window.
Definition: mutt_window.c:40
struct Email * email
Definition: hdrline.h:49
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:555

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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 1523 of file hdrline.c.

1525 {
1526  mutt_expando_format(buf, buflen, 0, cols, s, index_format_str, (unsigned long) hfi, flags);
1527 }
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:838
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:555

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Variable Documentation

struct MbTable* C_CryptChars

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

Definition at line 61 of file hdrline.c.

struct MbTable* C_FlagChars

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

Definition at line 62 of file hdrline.c.

struct MbTable* C_FromChars

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

Definition at line 63 of file hdrline.c.

struct MbTable* C_ToChars

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

Definition at line 64 of file hdrline.c.