NeoMutt  2023-05-17-56-ga67199
Teaching an old dog new tricks
DOXYGEN
mview.c File Reference

View of a Mailbox. More...

#include "config.h"
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "mview.h"
#include "imap/lib.h"
#include "ncrypt/lib.h"
#include "pattern/lib.h"
#include "mutt_header.h"
#include "mutt_thread.h"
#include "mx.h"
#include "score.h"
#include "sort.h"
+ Include dependency graph for mview.c:

Go to the source code of this file.

Functions

void mview_free (struct MailboxView **ptr)
 Free a MailboxView. More...
 
struct MailboxViewmview_new (struct Mailbox *m, struct Notify *parent)
 Create a new MailboxView. More...
 
static void mview_clean (struct MailboxView *mv)
 Release memory and initialize a MailboxView. More...
 
void mview_update (struct MailboxView *mv)
 Update the MailboxView's message counts. More...
 
static void update_tables (struct MailboxView *mv)
 Update a MailboxView's internal tables. More...
 
int mview_mailbox_observer (struct NotifyCallback *nc)
 Notification that a Mailbox has changed - Implements observer_t -. More...
 
bool message_is_tagged (struct Email *e)
 Is a message in the index tagged (and within limit) More...
 
int ea_add_tagged (struct EmailArray *ea, struct MailboxView *mv, struct Email *e, bool use_tagged)
 Get an array of the tagged Emails. More...
 
struct Emailmutt_get_virt_email (struct Mailbox *m, int vnum)
 Get a virtual Email. More...
 
bool mview_has_limit (const struct MailboxView *mv)
 Is a limit active? More...
 
struct Mailboxmview_mailbox (struct MailboxView *mv)
 Wrapper to get the mailbox in a MailboxView, or NULL. More...
 
static struct MuttThreadtop_of_thread (struct Email *e)
 Find the first email in the current thread. More...
 
bool mutt_limit_current_thread (struct MailboxView *mv, struct Email *e)
 Limit the email view to the current thread. More...
 

Detailed Description

View of a Mailbox.

Authors
  • Richard Russon

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file mview.c.

Function Documentation

◆ mview_free()

void mview_free ( struct MailboxView **  ptr)

Free a MailboxView.

Parameters
[out]ptrMailboxView to free

Definition at line 49 of file mview.c.

50{
51 if (!ptr || !*ptr)
52 return;
53
54 struct MailboxView *mv = *ptr;
55
56 struct EventMview ev_m = { mv };
57 mutt_debug(LL_NOTIFY, "NT_MVIEW_DELETE: %p\n", mv);
59
60 if (mv->mailbox)
62
65 FREE(&mv->pattern);
67
68 FREE(&mv);
69 *ptr = NULL;
70}
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: compile.c:777
#define mutt_debug(LEVEL,...)
Definition: logging2.h:87
int mview_mailbox_observer(struct NotifyCallback *nc)
Notification that a Mailbox has changed - Implements observer_t -.
Definition: mview.c:314
@ LL_NOTIFY
Log of notifications.
Definition: logging2.h:48
#define FREE(x)
Definition: memory.h:43
bool notify_observer_remove(struct Notify *notify, const observer_t callback, const void *global_data)
Remove an observer from an object.
Definition: notify.c:228
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:171
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:73
void mutt_thread_ctx_free(struct ThreadsContext **ptr)
Finalize a threading context.
Definition: mutt_thread.c:365
@ NT_MVIEW_DELETE
The Mview is about to be destroyed.
Definition: mview.h:62
@ NT_MVIEW
MailboxView has changed, NotifyMview, EventMview.
Definition: notify_type.h:50
An Event that happened to an MailboxView.
Definition: mview.h:70
struct MailboxView * mv
The MailboxView this Event relates to.
Definition: mview.h:71
View of a Mailbox.
Definition: mview.h:39
struct Notify * notify
Notifications: NotifyMview, EventMview.
Definition: mview.h:51
struct PatternList * limit_pattern
Compiled limit pattern.
Definition: mview.h:42
struct ThreadsContext * threads
Threads context.
Definition: mview.h:43
struct Mailbox * mailbox
Current Mailbox.
Definition: mview.h:50
char * pattern
Limit pattern string.
Definition: mview.h:41
struct Notify * notify
Notifications: NotifyMailbox, EventMailbox.
Definition: mailbox.h:143
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mview_new()

struct MailboxView * mview_new ( struct Mailbox m,
struct Notify parent 
)

Create a new MailboxView.

Parameters
mMailbox
parentNotification parent
Return values
ptrNew MailboxView

Definition at line 78 of file mview.c.

79{
80 if (!m)
81 return NULL;
82
83 struct MailboxView *mv = mutt_mem_calloc(1, sizeof(struct MailboxView));
84
85 mv->notify = notify_new();
86 notify_set_parent(mv->notify, parent);
87 struct EventMview ev_m = { mv };
88 mutt_debug(LL_NOTIFY, "NT_MVIEW_ADD: %p\n", mv);
90 // If the Mailbox is closed, mv->mailbox must be set to NULL
92
93 mv->mailbox = m;
95 mv->msg_in_pager = -1;
96 mv->collapsed = false;
98
99 return mv;
100}
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
bool notify_observer_add(struct Notify *notify, enum NotifyType type, observer_t callback, void *global_data)
Add an observer to an object.
Definition: notify.c:189
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:60
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:93
struct ThreadsContext * mutt_thread_ctx_init(struct MailboxView *mv)
Initialize a threading context.
Definition: mutt_thread.c:354
void mview_update(struct MailboxView *mv)
Update the MailboxView's message counts.
Definition: mview.c:126
@ NT_MVIEW_ADD
The Mview has been opened.
Definition: mview.h:61
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:49
bool collapsed
Are all threads collapsed?
Definition: mview.h:48
int msg_in_pager
Message currently shown in the pager.
Definition: mview.h:44
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mview_clean()

static void mview_clean ( struct MailboxView mv)
static

Release memory and initialize a MailboxView.

Parameters
mvMailboxView to cleanup

Definition at line 106 of file mview.c.

107{
108 FREE(&mv->pattern);
110 if (mv->mailbox)
112
113 struct Notify *notify = mv->notify;
114 struct Mailbox *m = mv->mailbox;
115 memset(mv, 0, sizeof(struct MailboxView));
116 mv->notify = notify;
117 mv->mailbox = m;
118}
A mailbox.
Definition: mailbox.h:79
Notification API.
Definition: notify.c:51
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mview_update()

void mview_update ( struct MailboxView mv)

Update the MailboxView's message counts.

Parameters
mvMailbox View

this routine is called to update the counts in the MailboxView structure

Definition at line 126 of file mview.c.

127{
128 if (!mv || !mv->mailbox)
129 return;
130
131 struct Mailbox *m = mv->mailbox;
132
135
136 /* reset counters */
137 m->msg_unread = 0;
138 m->msg_flagged = 0;
139 m->msg_new = 0;
140 m->msg_deleted = 0;
141 m->msg_tagged = 0;
142 m->vcount = 0;
143 m->changed = false;
144
146
147 const bool c_score = cs_subset_bool(NeoMutt->sub, "score");
148 struct Email *e = NULL;
149 for (int msgno = 0; msgno < m->msg_count; msgno++)
150 {
151 e = m->emails[msgno];
152 if (!e)
153 continue;
154
155 if (WithCrypto)
156 {
157 /* NOTE: this _must_ be done before the check for mailcap! */
158 e->security = crypt_query(e->body);
159 }
160
161 if (mview_has_limit(mv))
162 {
163 e->vnum = -1;
164 }
165 else
166 {
167 m->v2r[m->vcount] = msgno;
168 e->vnum = m->vcount++;
169 }
170 e->msgno = msgno;
171
172 if (e->env->supersedes)
173 {
174 struct Email *e2 = NULL;
175
176 if (!m->id_hash)
178
179 e2 = mutt_hash_find(m->id_hash, e->env->supersedes);
180 if (e2)
181 {
182 e2->superseded = true;
183 if (c_score)
184 mutt_score_message(mv->mailbox, e2, true);
185 }
186 }
187
188 /* add this message to the hash tables */
189 if (m->id_hash && e->env->message_id)
191 if (m->subj_hash && e->env->real_subj)
194
195 if (c_score)
196 mutt_score_message(mv->mailbox, e, false);
197
198 if (e->changed)
199 m->changed = true;
200 if (e->flagged)
201 m->msg_flagged++;
202 if (e->deleted)
203 m->msg_deleted++;
204 if (e->tagged)
205 m->msg_tagged++;
206 if (!e->read)
207 {
208 m->msg_unread++;
209 if (!e->old)
210 m->msg_new++;
211 }
212 }
213
214 /* rethread from scratch */
215 mutt_sort_headers(mv, true);
216}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
SecurityFlags crypt_query(struct Body *b)
Check out the type of encryption used.
Definition: crypt.c:677
struct HashElem * mutt_hash_insert(struct HashTable *table, const char *strkey, void *data)
Add a new element to the Hash Table (with string keys)
Definition: hash.c:335
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:362
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:457
void mutt_label_hash_add(struct Mailbox *m, struct Email *e)
Add a message's labels to the Hash Table.
Definition: mutt_header.c:429
void mutt_clear_threads(struct ThreadsContext *tctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:712
struct HashTable * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1696
bool mview_has_limit(const struct MailboxView *mv)
Is a limit active?
Definition: mview.c:428
#define WithCrypto
Definition: lib.h:116
void mutt_score_message(struct Mailbox *m, struct Email *e, bool upd_mbox)
Apply scoring to an email.
Definition: score.c:161
void mutt_sort_headers(struct MailboxView *mv, bool init)
Sort emails by their headers.
Definition: sort.c:358
The envelope/body of an email.
Definition: email.h:37
bool read
Email is read.
Definition: email.h:48
struct Envelope * env
Envelope information.
Definition: email.h:66
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:41
struct Body * body
List of MIME parts.
Definition: email.h:67
bool old
Email is seen, but unread.
Definition: email.h:47
bool changed
Email has been edited.
Definition: email.h:75
bool flagged
Marked important?
Definition: email.h:45
int vnum
Virtual message number.
Definition: email.h:113
int msgno
Number displayed to the user.
Definition: email.h:110
bool deleted
Email is deleted.
Definition: email.h:76
bool tagged
Email is tagged.
Definition: email.h:106
bool superseded
Got superseded?
Definition: email.h:50
char * supersedes
Supersedes header.
Definition: envelope.h:74
char * message_id
Message ID.
Definition: envelope.h:73
char * real_subj
Offset of the real subject.
Definition: envelope.h:71
int vcount
The number of virtual messages.
Definition: mailbox.h:99
bool changed
Mailbox has been modified.
Definition: mailbox.h:110
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:98
int msg_new
Number of new messages.
Definition: mailbox.h:92
int msg_count
Total number of messages.
Definition: mailbox.h:88
struct HashTable * subj_hash
Hash Table: "subject" -> Email.
Definition: mailbox.h:124
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
struct HashTable * id_hash
Hash Table: "message-id" -> Email.
Definition: mailbox.h:123
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:94
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ update_tables()

static void update_tables ( struct MailboxView mv)
static

Update a MailboxView's internal tables.

Parameters
mvMailbox

Definition at line 222 of file mview.c.

223{
224 if (!mv || !mv->mailbox)
225 return;
226
227 struct Mailbox *m = mv->mailbox;
228
229 int i, j, padding;
230
231 /* update memory to reflect the new state of the mailbox */
232 m->vcount = 0;
233 mv->vsize = 0;
234 m->msg_tagged = 0;
235 m->msg_deleted = 0;
236 m->msg_new = 0;
237 m->msg_unread = 0;
238 m->changed = false;
239 m->msg_flagged = 0;
240 padding = mx_msg_padding_size(m);
241 const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
242 for (i = 0, j = 0; i < m->msg_count; i++)
243 {
244 if (!m->emails[i])
245 break;
246 if (!m->emails[i]->quasi_deleted &&
247 (!m->emails[i]->deleted || ((m->type == MUTT_MAILDIR) && c_maildir_trash)))
248 {
249 if (i != j)
250 {
251 m->emails[j] = m->emails[i];
252 m->emails[i] = NULL;
253 }
254 m->emails[j]->msgno = j;
255 if (m->emails[j]->vnum != -1)
256 {
257 m->v2r[m->vcount] = j;
258 m->emails[j]->vnum = m->vcount++;
259 struct Body *b = m->emails[j]->body;
260 mv->vsize += b->length + b->offset - b->hdr_offset + padding;
261 }
262
263 m->emails[j]->changed = false;
264 m->emails[j]->env->changed = false;
265
266 if ((m->type == MUTT_MAILDIR) && c_maildir_trash)
267 {
268 if (m->emails[j]->deleted)
269 m->msg_deleted++;
270 }
271
272 if (m->emails[j]->tagged)
273 m->msg_tagged++;
274 if (m->emails[j]->flagged)
275 m->msg_flagged++;
276 if (!m->emails[j]->read)
277 {
278 m->msg_unread++;
279 if (!m->emails[j]->old)
280 m->msg_new++;
281 }
282
283 j++;
284 }
285 else
286 {
287 if ((m->type == MUTT_NOTMUCH) || (m->type == MUTT_MH) ||
288 (m->type == MUTT_MAILDIR) || (m->type == MUTT_IMAP))
289 {
290 mailbox_size_sub(m, m->emails[i]);
291 }
292 /* remove message from the hash tables */
293 if (m->subj_hash && m->emails[i]->env->real_subj)
295 if (m->id_hash && m->emails[i]->env->message_id)
298
299#ifdef USE_IMAP
300 if (m->type == MUTT_IMAP)
302#endif
303
304 mailbox_gc_add(m->emails[i]);
305 m->emails[i] = NULL;
306 }
307 }
308 m->msg_count = j;
309}
void mutt_hash_delete(struct HashTable *table, const char *strkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:427
void imap_notify_delete_email(struct Mailbox *m, struct Email *e)
Inform IMAP that an Email has been deleted.
Definition: imap.c:639
void mailbox_size_sub(struct Mailbox *m, const struct Email *e)
Subtract an email's size from the total size of a Mailbox.
Definition: mailbox.c:248
void mailbox_gc_add(struct Email *e)
Add an Email to the garbage-collection set.
Definition: mailbox.c:287
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
@ MUTT_MH
'MH' Mailbox type
Definition: mailbox.h:47
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
@ MUTT_MAILDIR
'Maildir' Mailbox type
Definition: mailbox.h:48
void mutt_label_hash_remove(struct Mailbox *m, struct Email *e)
Remove a message's labels from the Hash Table.
Definition: mutt_header.c:442
int mx_msg_padding_size(struct Mailbox *m)
Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
Definition: mx.c:1570
The body of an email.
Definition: body.h:36
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:80
bool quasi_deleted
Deleted from neomutt, but not modified on disk.
Definition: email.h:102
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:92
off_t vsize
Size (in bytes) of the messages shown.
Definition: mview.h:40
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ message_is_tagged()

bool message_is_tagged ( struct Email e)

Is a message in the index tagged (and within limit)

Parameters
eEmail
Return values
trueThe message is both tagged and within limit

If a limit is in effect, the message must be visible within it.

Definition at line 353 of file mview.c.

354{
355 return e->visible && e->tagged;
356}
bool visible
Is this message part of the view?
Definition: email.h:120
+ Here is the caller graph for this function:

◆ ea_add_tagged()

int ea_add_tagged ( struct EmailArray *  ea,
struct MailboxView mv,
struct Email e,
bool  use_tagged 
)

Get an array of the tagged Emails.

Parameters
eaEmpty EmailArray to populate
mvCurrent Mailbox
eCurrent Email
use_taggedUse tagged Emails
Return values
numNumber of selected emails
-1Error

Definition at line 367 of file mview.c.

368{
369 if (use_tagged)
370 {
371 if (!mv || !mv->mailbox || !mv->mailbox->emails)
372 return -1;
373
374 struct Mailbox *m = mv->mailbox;
375 for (int i = 0; i < m->msg_count; i++)
376 {
377 e = m->emails[i];
378 if (!e)
379 break;
380 if (!message_is_tagged(e))
381 continue;
382
383 ARRAY_ADD(ea, e);
384 }
385 }
386 else
387 {
388 if (!e)
389 return -1;
390
391 ARRAY_ADD(ea, e);
392 }
393
394 return ARRAY_SIZE(ea);
395}
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:155
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:86
bool message_is_tagged(struct Email *e)
Is a message in the index tagged (and within limit)
Definition: mview.c:353
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_get_virt_email()

struct Email * mutt_get_virt_email ( struct Mailbox m,
int  vnum 
)

Get a virtual Email.

Parameters
mMailbox
vnumVirtual index number
Return values
ptrEmail
NULLNo Email selected, or bad index values

This safely gets the result of the following:

  • mailbox->emails[mailbox->v2r[vnum]]

Definition at line 407 of file mview.c.

408{
409 if (!m || !m->emails || !m->v2r)
410 return NULL;
411
412 if ((vnum < 0) || (vnum >= m->vcount))
413 return NULL;
414
415 int inum = m->v2r[vnum];
416 if ((inum < 0) || (inum >= m->msg_count))
417 return NULL;
418
419 return m->emails[inum];
420}
+ Here is the caller graph for this function:

◆ mview_has_limit()

bool mview_has_limit ( const struct MailboxView mv)

Is a limit active?

Parameters
mvMailboxView
Return values
trueA limit is active
falseNo limit is active

Definition at line 428 of file mview.c.

429{
430 return mv && mv->pattern;
431}
+ Here is the caller graph for this function:

◆ mview_mailbox()

struct Mailbox * mview_mailbox ( struct MailboxView mv)

Wrapper to get the mailbox in a MailboxView, or NULL.

Parameters
mvMailboxView
Return values
ptrThe mailbox in the MailboxView
NULLMailboxView is NULL or doesn't have a mailbox

Definition at line 439 of file mview.c.

440{
441 return mv ? mv->mailbox : NULL;
442}
+ Here is the caller graph for this function:

◆ top_of_thread()

static struct MuttThread * top_of_thread ( struct Email e)
static

Find the first email in the current thread.

Parameters
eCurrent Email
Return values
ptrSuccess, email found
NULLError

Definition at line 450 of file mview.c.

451{
452 if (!e)
453 return NULL;
454
455 struct MuttThread *t = e->thread;
456
457 while (t && t->parent)
458 t = t->parent;
459
460 return t;
461}
struct MuttThread * thread
Thread of Emails.
Definition: email.h:118
An Email conversation.
Definition: thread.h:34
struct MuttThread * parent
Parent of this Thread.
Definition: thread.h:44
+ Here is the caller graph for this function:

◆ mutt_limit_current_thread()

bool mutt_limit_current_thread ( struct MailboxView mv,
struct Email e 
)

Limit the email view to the current thread.

Parameters
mvMailbox View
eEmail
Return values
trueSuccess
falseFailure

Definition at line 470 of file mview.c.

471{
472 if (!mv || !mv->mailbox || !e)
473 return false;
474
475 struct Mailbox *m = mv->mailbox;
476
477 struct MuttThread *me = top_of_thread(e);
478 if (!me)
479 return false;
480
481 m->vcount = 0;
482 mv->vsize = 0;
483 mv->collapsed = false;
484
485 for (int i = 0; i < m->msg_count; i++)
486 {
487 e = m->emails[i];
488 if (!e)
489 break;
490
491 e->vnum = -1;
492 e->visible = false;
493 e->collapsed = false;
494 e->num_hidden = 0;
495
496 if (top_of_thread(e) == me)
497 {
498 struct Body *body = e->body;
499
500 e->vnum = m->vcount;
501 e->visible = true;
502 m->v2r[m->vcount] = i;
503 m->vcount++;
504 mv->vsize += (body->length + body->offset - body->hdr_offset);
505 }
506 }
507 return true;
508}
static struct MuttThread * top_of_thread(struct Email *e)
Find the first email in the current thread.
Definition: mview.c:450
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:119
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:122
+ Here is the call graph for this function:
+ Here is the caller graph for this function: