NeoMutt  2024-02-01-23-g345d7b
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
hdrline.c File Reference

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

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "hdrline.h"
#include "attach/lib.h"
#include "color/lib.h"
#include "ncrypt/lib.h"
#include "format_flags.h"
#include "hook.h"
#include "maillist.h"
#include "mutt_thread.h"
#include "muttlib.h"
#include "mx.h"
#include "sort.h"
#include "subjectrx.h"
#include "notmuch/lib.h"
+ Include dependency graph for hdrline.c:

Go to the source code of this file.

Data Structures

struct  HdrFormatInfo
 Data passed to index_format_str() More...
 

Enumerations

enum  FieldType {
  DISP_TO , DISP_CC , DISP_BCC , DISP_FROM ,
  DISP_PLAIN , DISP_MAX
}
 Header types. More...
 

Functions

static size_t add_index_color (char *buf, size_t buflen, MuttFormatFlags flags, enum ColorId color)
 Insert a color marker into a string.
 
static const char * make_from_prefix (enum FieldType disp)
 Create a prefix for an author field.
 
static void make_from (struct Envelope *env, char *buf, size_t buflen, bool do_lists, MuttFormatFlags flags)
 Generate a From: field (with optional prefix)
 
static void make_from_addr (struct Envelope *env, char *buf, size_t buflen, bool do_lists)
 Create a 'from' address for a reply email.
 
static bool user_in_addr (struct AddressList *al)
 Do any of the addresses refer to the user?
 
static enum ToChars user_is_recipient (struct Email *e)
 Is the user a recipient of the message.
 
static bool thread_is_new (struct Email *e)
 Does the email thread contain any new emails?
 
static bool thread_is_old (struct Email *e)
 Does the email thread contain any unread emails?
 
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, intptr_t data, MuttFormatFlags flags)
 Format a string for the index list - Implements format_t -.
 
void mutt_make_string (struct Buffer *buf, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
 Create formatted strings using mailbox expandos.
 

Detailed Description

String processing routines to generate the mail index.

Authors
  • Michael R. Elkins
  • Ian Zimmerman
  • Richard Russon
  • Stefan Assmann
  • Victor Fernandes
  • Pietro Cerutti
  • Ashish Panigrahi
  • Tóth János
  • наб
  • Dennis Schön

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

◆ FieldType

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

85{
86 DISP_TO,
87 DISP_CC,
88 DISP_BCC,
89 DISP_FROM,
92};
@ DISP_PLAIN
Empty string.
Definition: hdrline.c:90
@ DISP_TO
To: string.
Definition: hdrline.c:86
@ DISP_CC
Cc: string.
Definition: hdrline.c:87
@ DISP_BCC
Bcc: string.
Definition: hdrline.c:88
@ DISP_MAX
Definition: hdrline.c:91
@ DISP_FROM
From: string.
Definition: hdrline.c:89

Function Documentation

◆ add_index_color()

static size_t add_index_color ( char *  buf,
size_t  buflen,
MuttFormatFlags  flags,
enum ColorId  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 104 of file hdrline.c.

105{
106 /* only add color markers if we are operating on main index entries. */
107 if (!(flags & MUTT_FORMAT_INDEX))
108 return 0;
109
110 /* this item is going to be passed to an external filter */
111 if (flags & MUTT_FORMAT_NOFILTER)
112 return 0;
113
114 if (color == MT_COLOR_INDEX)
115 { /* buf might be uninitialized other cases */
116 const size_t len = mutt_str_len(buf);
117 buf += len;
118 buflen -= len;
119 }
120
121 if (buflen <= 2)
122 return 0;
123
124 buf[0] = MUTT_SPECIAL_INDEX;
125 buf[1] = color;
126 buf[2] = '\0';
127
128 return 2;
129}
@ MT_COLOR_INDEX
Index: default colour.
Definition: color.h:83
#define MUTT_FORMAT_NOFILTER
Do not allow filtering on this pass.
Definition: format_flags.h:37
#define MUTT_FORMAT_INDEX
This is a main index entry.
Definition: format_flags.h:36
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:545
@ MUTT_SPECIAL_INDEX
Colour indicator.
Definition: mutt_thread.h:73
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ make_from_prefix()

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

140{
141 /* need 2 bytes at the end, one for the space, another for NUL */
142 static char padded[8];
143 static const char *long_prefixes[DISP_MAX] = {
144 [DISP_TO] = "To ", [DISP_CC] = "Cc ", [DISP_BCC] = "Bcc ",
145 [DISP_FROM] = "", [DISP_PLAIN] = "",
146 };
147
148 const struct MbTable *c_from_chars = cs_subset_mbtable(NeoMutt->sub, "from_chars");
149
150 if (!c_from_chars || !c_from_chars->chars || (c_from_chars->len == 0))
151 return long_prefixes[disp];
152
153 const char *pchar = mbtable_get_nth_wchar(c_from_chars, disp);
154 if (mutt_str_len(pchar) == 0)
155 return "";
156
157 snprintf(padded, sizeof(padded), "%s ", pchar);
158 return padded;
159}
struct MbTable * cs_subset_mbtable(const struct ConfigSubset *sub, const char *name)
Get a Multibyte table config item by name.
Definition: helpers.c:120
const char * mbtable_get_nth_wchar(const struct MbTable *table, int index)
Extract one char from a multi-byte table.
Definition: mbtable.c:331
Multibyte character table.
Definition: mbtable.h:36
int len
Number of characters.
Definition: mbtable.h:38
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ make_from()

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

177{
178 if (!env || !buf)
179 return;
180
181 bool me;
182 enum FieldType disp;
183 struct AddressList *name = NULL;
184
186
187 if (do_lists || me)
188 {
189 if (check_for_mailing_list(&env->to, make_from_prefix(DISP_TO), buf, buflen))
190 return;
191 if (check_for_mailing_list(&env->cc, make_from_prefix(DISP_CC), buf, buflen))
192 return;
193 }
194
195 if (me && !TAILQ_EMPTY(&env->to))
196 {
197 disp = (flags & MUTT_FORMAT_PLAIN) ? DISP_PLAIN : DISP_TO;
198 name = &env->to;
199 }
200 else if (me && !TAILQ_EMPTY(&env->cc))
201 {
202 disp = DISP_CC;
203 name = &env->cc;
204 }
205 else if (me && !TAILQ_EMPTY(&env->bcc))
206 {
207 disp = DISP_BCC;
208 name = &env->bcc;
209 }
210 else if (!TAILQ_EMPTY(&env->from))
211 {
212 disp = DISP_FROM;
213 name = &env->from;
214 }
215 else
216 {
217 *buf = '\0';
218 return;
219 }
220
221 snprintf(buf, buflen, "%s%s", make_from_prefix(disp), mutt_get_name(TAILQ_FIRST(name)));
222}
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:605
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
static const char * make_from_prefix(enum FieldType disp)
Create a prefix for an author field.
Definition: hdrline.c:139
FieldType
Header types.
Definition: hdrline.c:85
bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: maillist.c:79
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_EMPTY(head)
Definition: queue.h:721
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:134
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ make_from_addr()

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

232{
233 if (!env || !buf)
234 return;
235
236 bool me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
237
238 if (do_lists || me)
239 {
240 if (check_for_mailing_list_addr(&env->to, buf, buflen))
241 return;
242 if (check_for_mailing_list_addr(&env->cc, buf, buflen))
243 return;
244 }
245
246 if (me && !TAILQ_EMPTY(&env->to))
247 snprintf(buf, buflen, "%s", buf_string(TAILQ_FIRST(&env->to)->mailbox));
248 else if (me && !TAILQ_EMPTY(&env->cc))
249 snprintf(buf, buflen, "%s", buf_string(TAILQ_FIRST(&env->cc)->mailbox));
250 else if (!TAILQ_EMPTY(&env->from))
251 mutt_str_copy(buf, buf_string(TAILQ_FIRST(&env->from)->mailbox), buflen);
252 else
253 *buf = '\0';
254}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:97
bool check_for_mailing_list_addr(struct AddressList *al, char *buf, int buflen)
Check an address list for a mailing list.
Definition: maillist.c:103
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:630
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ user_in_addr()

static bool user_in_addr ( struct AddressList *  al)
static

Do any of the addresses refer to the user?

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

Definition at line 261 of file hdrline.c.

262{
263 struct Address *a = NULL;
264 TAILQ_FOREACH(a, al, entries)
265 if (mutt_addr_is_user(a))
266 return true;
267 return false;
268}
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
An email address.
Definition: address.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ user_is_recipient()

static enum ToChars user_is_recipient ( struct Email e)
static

Is the user a recipient of the message.

Parameters
eEmail to test
Return values
enumCharacter index into the $to_chars config variable

Definition at line 275 of file hdrline.c.

276{
277 if (!e || !e->env)
279
280 struct Envelope *env = e->env;
281
282 if (!e->recip_valid)
283 {
284 e->recip_valid = true;
285
287 {
289 }
290 else if (user_in_addr(&env->to))
291 {
292 if (TAILQ_NEXT(TAILQ_FIRST(&env->to), entries) || !TAILQ_EMPTY(&env->cc))
293 e->recipient = FLAG_CHAR_TO_TO; /* non-unique recipient */
294 else
295 e->recipient = FLAG_CHAR_TO_UNIQUE; /* unique recipient */
296 }
297 else if (user_in_addr(&env->cc))
298 {
300 }
301 else if (check_for_mailing_list(&env->to, NULL, NULL, 0))
302 {
304 }
305 else if (check_for_mailing_list(&env->cc, NULL, NULL, 0))
306 {
308 }
309 else if (user_in_addr(&env->reply_to))
310 {
312 }
313 else
314 {
316 }
317 }
318
319 return e->recipient;
320}
static bool user_in_addr(struct AddressList *al)
Do any of the addresses refer to the user?
Definition: hdrline.c:261
@ FLAG_CHAR_TO_ORIGINATOR
Character denoting that the user is originator.
Definition: hdrline.h:73
@ FLAG_CHAR_TO_UNIQUE
Character denoting that the user is unique recipient.
Definition: hdrline.h:70
@ FLAG_CHAR_TO_NOT_IN_THE_LIST
Character denoting that the user is not in list.
Definition: hdrline.h:69
@ FLAG_CHAR_TO_TO
Character denoting that the user is in the TO list.
Definition: hdrline.h:71
@ FLAG_CHAR_TO_CC
Character denoting that the user is in the CC list.
Definition: hdrline.h:72
@ FLAG_CHAR_TO_REPLY_TO
Character denoting that the user is in the Reply-To list.
Definition: hdrline.h:75
@ FLAG_CHAR_TO_SUBSCRIBED_LIST
Character denoting that the message is sent to a subscribed mailing list.
Definition: hdrline.h:74
#define TAILQ_NEXT(elm, field)
Definition: queue.h:832
bool recip_valid
Is_recipient is valid.
Definition: email.h:107
struct Envelope * env
Envelope information.
Definition: email.h:68
short recipient
User_is_recipient()'s return value, cached.
Definition: email.h:119
The header of an Email.
Definition: envelope.h:57
struct AddressList reply_to
Email's 'reply-to'.
Definition: envelope.h:64
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ thread_is_new()

static bool thread_is_new ( struct Email e)
static

Does the email thread contain any new emails?

Parameters
eEmail
Return values
trueThread contains new mail

Definition at line 327 of file hdrline.c.

328{
329 return e->collapsed && (e->num_hidden > 1) && (mutt_thread_contains_unread(e) == 1);
330}
#define mutt_thread_contains_unread(e)
Definition: mutt_thread.h:109
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:123
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:126
+ Here is the caller graph for this function:

◆ thread_is_old()

static bool thread_is_old ( struct Email e)
static

Does the email thread contain any unread emails?

Parameters
eEmail
Return values
trueThread contains unread mail

Definition at line 337 of file hdrline.c.

338{
339 return e->collapsed && (e->num_hidden > 1) && (mutt_thread_contains_unread(e) == 2);
340}
+ Here is the caller graph for this function:

◆ mutt_make_string()

void mutt_make_string ( struct Buffer buf,
int  cols,
const char *  s,
struct Mailbox m,
int  inpgr,
struct Email e,
MuttFormatFlags  flags,
const char *  progress 
)

Create formatted strings using mailbox expandos.

Parameters
bufBuffer for the result
colsNumber of screen columns (OPTIONAL)
sprintf-line format string
mMailbox
inpgrMessage shown in the pager
eEmail
flagsFlags, see MuttFormatFlags
progressPager progress string
See also
index_format_str()

Definition at line 1438 of file hdrline.c.

1441{
1442 struct HdrFormatInfo hfi = { 0 };
1443
1444 hfi.email = e;
1445 hfi.mailbox = m;
1446 hfi.msg_in_pager = inpgr;
1447 hfi.pager_progress = progress;
1448
1449 mutt_expando_format(buf->data, buf->dsize, 0, cols, s, index_format_str,
1450 (intptr_t) &hfi, flags);
1451}
void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src, format_t callback, intptr_t data, MuttFormatFlags flags)
Expand expandos (x) in a string -.
Definition: muttlib.c:740
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, intptr_t data, MuttFormatFlags flags)
Format a string for the index list - Implements format_t -.
Definition: hdrline.c:399
size_t dsize
Length of data.
Definition: buffer.h:39
char * data
Pointer to data.
Definition: buffer.h:37
Data passed to index_format_str()
Definition: hdrline.c:72
struct Email * email
Current Email.
Definition: hdrline.c:75
int msg_in_pager
Index of Email displayed in the Pager.
Definition: hdrline.c:74
struct Mailbox * mailbox
Current Mailbox.
Definition: hdrline.c:73
const char * pager_progress
String representing Pager position through Email.
Definition: hdrline.c:76
+ Here is the call graph for this function:
+ Here is the caller graph for this function: