NeoMutt  2020-06-26-30-g76c339
Teaching an old dog new tricks
DOXYGEN
context.h File Reference

The "currently-open" mailbox. More...

#include <stdbool.h>
#include <sys/types.h>
+ Include dependency graph for context.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  Context
 The "current" mailbox. More...
 
struct  EventContext
 An Event that happened to an Context. More...
 

Enumerations

enum  NotifyContext { NT_CONTEXT_OPEN = 1, NT_CONTEXT_CLOSE }
 Types of Context Event. More...
 

Functions

void ctx_free (struct Context **ptr)
 Free a Context. More...
 
int ctx_mailbox_observer (struct NotifyCallback *nc)
 Watch for changes affecting the Context - Implements observer_t. More...
 
struct Contextctx_new (void)
 Create a new Context. More...
 
void ctx_update (struct Context *ctx)
 Update the Context's message counts. More...
 
void ctx_update_tables (struct Context *ctx, bool committing)
 Update a Context structure's internal tables. More...
 
bool message_is_tagged (struct Context *ctx, struct Email *e)
 Is a message in the index tagged (and within limit) More...
 
bool message_is_visible (struct Context *ctx, struct Email *e)
 Is a message in the index within limit. More...
 
struct Emailmutt_get_virt_email (struct Mailbox *m, int vnum)
 Get a virtual Email. More...
 
int el_add_tagged (struct EmailList *el, struct Context *ctx, struct Email *e, bool use_tagged)
 Get a list of the tagged Emails. More...
 

Detailed Description

The "currently-open" 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 context.h.

Enumeration Type Documentation

◆ NotifyContext

Types of Context Event.

Observers of NT_CONTEXT will be passed an EventContext.

Enumerator
NT_CONTEXT_OPEN 

The Context has been opened.

NT_CONTEXT_CLOSE 

The Context is about to be destroyed.

Definition at line 59 of file context.h.

60 {
61  NT_CONTEXT_OPEN = 1,
63 };
The Context has been opened.
Definition: context.h:61
The Context is about to be destroyed.
Definition: context.h:62

Function Documentation

◆ ctx_free()

void ctx_free ( struct Context **  ptr)

Free a Context.

Parameters
[out]ptrContext to free

Definition at line 48 of file context.c.

49 {
50  if (!ptr || !*ptr)
51  return;
52 
53  struct Context *ctx = *ptr;
54 
55  struct EventContext ev_ctx = { ctx };
57 
58  if (ctx->mailbox)
60 
62  notify_free(&ctx->notify);
63 
64  FREE(ptr);
65 }
The "current" mailbox.
Definition: context.h:37
int ctx_mailbox_observer(struct NotifyCallback *nc)
Watch for changes affecting the Context - Implements observer_t.
Definition: context.c:290
struct HashTable * thread_hash
Hash Table for threading.
Definition: context.h:43
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:447
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:62
struct Mailbox * mailbox
Definition: context.h:50
struct Notify * notify
Notifications handler.
Definition: context.h:51
The Context is about to be destroyed.
Definition: context.h:62
Context has changed, NotifyContext, EventContext.
Definition: notify_type.h:37
#define FREE(x)
Definition: memory.h:40
bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
Remove an observer from an object.
Definition: notify.c:185
struct Notify * notify
Notifications handler.
Definition: mailbox.h:139
An Event that happened to an Context.
Definition: context.h:68
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:137
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_mailbox_observer()

int ctx_mailbox_observer ( struct NotifyCallback nc)

Watch for changes affecting the Context - Implements observer_t.

Definition at line 290 of file context.c.

291 {
292  if (!nc->global_data)
293  return -1;
294  if (nc->event_type != NT_MAILBOX)
295  return 0;
296 
297  struct Context *ctx = nc->global_data;
298 
299  switch (nc->event_subtype)
300  {
301  case NT_MAILBOX_CLOSED:
302  mutt_clear_threads(ctx);
303  ctx_cleanup(ctx);
304  break;
305  case NT_MAILBOX_INVALID:
306  ctx_update(ctx);
307  break;
308  case NT_MAILBOX_UPDATE:
309  ctx_update_tables(ctx, true);
310  break;
311  case NT_MAILBOX_RESORT:
312  mutt_sort_headers(ctx, true);
313  break;
314  }
315 
316  return 0;
317 }
void ctx_update_tables(struct Context *ctx, bool committing)
Update a Context structure&#39;s internal tables.
Definition: context.c:200
The "current" mailbox.
Definition: context.h:37
Update internal tables.
Definition: mailbox.h:167
Email list was changed.
Definition: mailbox.h:165
Mailbox was closed.
Definition: mailbox.h:164
int event_subtype
Send: Event subtype, e.g. NT_ACCOUNT_ADD.
Definition: observer.h:42
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:41
void * global_data
Data from notify_observer_add()
Definition: observer.h:44
Email list needs resorting.
Definition: mailbox.h:166
static void ctx_cleanup(struct Context *ctx)
Release memory and initialize a Context object.
Definition: context.c:85
void mutt_sort_headers(struct Context *ctx, bool init)
Sort emails by their headers.
Definition: sort.c:364
void ctx_update(struct Context *ctx)
Update the Context&#39;s message counts.
Definition: context.c:105
void mutt_clear_threads(struct Context *ctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:601
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_new()

struct Context* ctx_new ( void  )

Create a new Context.

Return values
ptrNew Context

Definition at line 71 of file context.c.

72 {
73  struct Context *ctx = mutt_mem_calloc(1, sizeof(struct Context));
74 
75  ctx->notify = notify_new();
77 
78  return ctx;
79 }
The "current" mailbox.
Definition: context.h:37
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
Container for Accounts, Notifications.
Definition: neomutt.h:36
struct Notify * notify
Notifications handler.
Definition: context.h:51
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:49
struct Notify * notify
Notifications handler.
Definition: neomutt.h:38
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:82
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_update()

void ctx_update ( struct Context ctx)

Update the Context's message counts.

Parameters
ctxMailbox

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

Definition at line 105 of file context.c.

106 {
107  if (!ctx || !ctx->mailbox)
108  return;
109 
110  struct Mailbox *m = ctx->mailbox;
111 
113  mutt_hash_free(&m->id_hash);
114 
115  /* reset counters */
116  m->msg_unread = 0;
117  m->msg_flagged = 0;
118  m->msg_new = 0;
119  m->msg_deleted = 0;
120  m->msg_tagged = 0;
121  m->vcount = 0;
122  m->changed = false;
123 
124  mutt_clear_threads(ctx);
125 
126  struct Email *e = NULL;
127  for (int msgno = 0; msgno < m->msg_count; msgno++)
128  {
129  e = m->emails[msgno];
130  if (!e)
131  continue;
132 
133  if (WithCrypto)
134  {
135  /* NOTE: this _must_ be done before the check for mailcap! */
136  e->security = crypt_query(e->content);
137  }
138 
139  if (ctx->pattern)
140  {
141  e->vnum = -1;
142  }
143  else
144  {
145  m->v2r[m->vcount] = msgno;
146  e->vnum = m->vcount++;
147  }
148  e->msgno = msgno;
149 
150  if (e->env->supersedes)
151  {
152  struct Email *e2 = NULL;
153 
154  if (!m->id_hash)
155  m->id_hash = mutt_make_id_hash(m);
156 
157  e2 = mutt_hash_find(m->id_hash, e->env->supersedes);
158  if (e2)
159  {
160  e2->superseded = true;
161  if (C_Score)
162  mutt_score_message(ctx->mailbox, e2, true);
163  }
164  }
165 
166  /* add this message to the hash tables */
167  if (m->id_hash && e->env->message_id)
169  if (m->subj_hash && e->env->real_subj)
171  mutt_label_hash_add(m, e);
172 
173  if (C_Score)
174  mutt_score_message(ctx->mailbox, e, false);
175 
176  if (e->changed)
177  m->changed = true;
178  if (e->flagged)
179  m->msg_flagged++;
180  if (e->deleted)
181  m->msg_deleted++;
182  if (e->tagged)
183  m->msg_tagged++;
184  if (!e->read)
185  {
186  m->msg_unread++;
187  if (!e->old)
188  m->msg_new++;
189  }
190  }
191 
192  mutt_sort_headers(ctx, true); /* rethread from scratch */
193 }
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:354
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
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:327
int msg_count
Total number of messages.
Definition: mailbox.h:91
#define WithCrypto
Definition: lib.h:163
The envelope/body of an email.
Definition: email.h:37
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:96
int msg_unread
Number of unread messages.
Definition: mailbox.h:92
char * supersedes
Supersedes header.
Definition: envelope.h:70
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:447
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:93
struct HashTable * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1455
struct Body * content
List of MIME parts.
Definition: email.h:90
void mutt_score_message(struct Mailbox *m, struct Email *e, bool upd_mbox)
Apply scoring to an email.
Definition: score.c:174
char * real_subj
Offset of the real subject.
Definition: envelope.h:67
bool changed
Email has been edited.
Definition: email.h:48
void mutt_label_hash_add(struct Mailbox *m, struct Email *e)
Add a message&#39;s labels to the Hash Table.
Definition: mutt_header.c:372
int vcount
The number of virtual messages.
Definition: mailbox.h:102
bool tagged
Email is tagged.
Definition: email.h:44
bool read
Email is read.
Definition: email.h:51
char * message_id
Message ID.
Definition: envelope.h:69
struct Mailbox * mailbox
Definition: context.h:50
struct HashTable * id_hash
Hash Table by msg id.
Definition: mailbox.h:127
bool old
Email is seen, but unread.
Definition: email.h:50
struct Envelope * env
Envelope information.
Definition: email.h:89
bool superseded
Got superseded?
Definition: email.h:53
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:128
void mutt_sort_headers(struct Context *ctx, bool init)
Sort emails by their headers.
Definition: sort.c:364
A mailbox.
Definition: mailbox.h:81
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:97
int vnum
Virtual message number.
Definition: email.h:87
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
void mutt_clear_threads(struct Context *ctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:601
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:101
bool flagged
Marked important?
Definition: email.h:43
int msg_new
Number of new messages.
Definition: mailbox.h:95
bool deleted
Email is deleted.
Definition: email.h:45
WHERE bool C_Score
Config: Use message scoring.
Definition: globals.h:242
bool changed
Mailbox has been modified.
Definition: mailbox.h:114
char * pattern
Limit pattern string.
Definition: context.h:40
SecurityFlags crypt_query(struct Body *m)
Check out the type of encryption used.
Definition: crypt.c:695
int msgno
Number displayed to the user.
Definition: email.h:86
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_update_tables()

void ctx_update_tables ( struct Context ctx,
bool  committing 
)

Update a Context structure's internal tables.

Parameters
ctxMailbox
committingCommit the changes?

Definition at line 200 of file context.c.

201 {
202  if (!ctx || !ctx->mailbox)
203  return;
204 
205  struct Mailbox *m = ctx->mailbox;
206 
207  int i, j, padding;
208 
209  /* update memory to reflect the new state of the mailbox */
210  m->vcount = 0;
211  ctx->vsize = 0;
212  m->msg_tagged = 0;
213  m->msg_deleted = 0;
214  m->msg_new = 0;
215  m->msg_unread = 0;
216  m->changed = false;
217  m->msg_flagged = 0;
218  padding = mx_msg_padding_size(m);
219  for (i = 0, j = 0; i < m->msg_count; i++)
220  {
221  if (!m->emails[i])
222  break;
223  if (!m->emails[i]->quasi_deleted &&
224  ((committing && (!m->emails[i]->deleted || ((m->type == MUTT_MAILDIR) && C_MaildirTrash))) ||
225  (!committing && m->emails[i]->active)))
226  {
227  if (i != j)
228  {
229  m->emails[j] = m->emails[i];
230  m->emails[i] = NULL;
231  }
232  m->emails[j]->msgno = j;
233  if (m->emails[j]->vnum != -1)
234  {
235  m->v2r[m->vcount] = j;
236  m->emails[j]->vnum = m->vcount++;
237  struct Body *b = m->emails[j]->content;
238  ctx->vsize += b->length + b->offset - b->hdr_offset + padding;
239  }
240 
241  if (committing)
242  {
243  m->emails[j]->changed = false;
244  m->emails[j]->env->changed = false;
245  }
246  else if (m->emails[j]->changed)
247  m->changed = true;
248 
249  if (!committing || ((m->type == MUTT_MAILDIR) && C_MaildirTrash))
250  {
251  if (m->emails[j]->deleted)
252  m->msg_deleted++;
253  }
254 
255  if (m->emails[j]->tagged)
256  m->msg_tagged++;
257  if (m->emails[j]->flagged)
258  m->msg_flagged++;
259  if (!m->emails[j]->read)
260  {
261  m->msg_unread++;
262  if (!m->emails[j]->old)
263  m->msg_new++;
264  }
265 
266  j++;
267  }
268  else
269  {
270  if ((m->type == MUTT_NOTMUCH) || (m->type == MUTT_MH) ||
271  (m->type == MUTT_MAILDIR) || (m->type == MUTT_IMAP))
272  {
273  mailbox_size_sub(m, m->emails[i]);
274  }
275  /* remove message from the hash tables */
276  if (m->subj_hash && m->emails[i]->env->real_subj)
277  mutt_hash_delete(m->subj_hash, m->emails[i]->env->real_subj, m->emails[i]);
278  if (m->id_hash && m->emails[i]->env->message_id)
279  mutt_hash_delete(m->id_hash, m->emails[i]->env->message_id, m->emails[i]);
280  mutt_label_hash_remove(m, m->emails[i]);
281  email_free(&m->emails[i]);
282  }
283  }
284  m->msg_count = j;
285 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
int msg_count
Total number of messages.
Definition: mailbox.h:91
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:96
int msg_unread
Number of unread messages.
Definition: mailbox.h:92
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:93
struct Body * content
List of MIME parts.
Definition: email.h:90
LOFF_T offset
offset where the actual data begins
Definition: body.h:44
char * real_subj
Offset of the real subject.
Definition: envelope.h:67
bool changed
Email has been edited.
Definition: email.h:48
void mutt_label_hash_remove(struct Mailbox *m, struct Email *e)
Remove a message&#39;s labels from the Hash Table.
Definition: mutt_header.c:385
int vcount
The number of virtual messages.
Definition: mailbox.h:102
The body of an email.
Definition: body.h:34
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:88
bool tagged
Email is tagged.
Definition: email.h:44
bool read
Email is read.
Definition: email.h:51
char * message_id
Message ID.
Definition: envelope.h:69
struct Mailbox * mailbox
Definition: context.h:50
struct HashTable * id_hash
Hash Table by msg id.
Definition: mailbox.h:127
bool old
Email is seen, but unread.
Definition: email.h:50
struct Envelope * env
Envelope information.
Definition: email.h:89
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:128
&#39;Maildir&#39; Mailbox type
Definition: mailbox.h:51
bool quasi_deleted
Deleted from neomutt, but not modified on disk.
Definition: email.h:47
off_t vsize
Definition: context.h:39
bool active
Message is not to be removed.
Definition: email.h:59
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
A mailbox.
Definition: mailbox.h:81
WHERE bool C_MaildirTrash
Config: Use the maildir &#39;trashed&#39; flag, rather than deleting.
Definition: globals.h:232
&#39;MH&#39; Mailbox type
Definition: mailbox.h:50
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:97
int vnum
Virtual message number.
Definition: email.h:87
&#39;Notmuch&#39; (virtual) Mailbox type
Definition: mailbox.h:54
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:101
bool flagged
Marked important?
Definition: email.h:43
int msg_new
Number of new messages.
Definition: mailbox.h:95
bool deleted
Email is deleted.
Definition: email.h:45
void mutt_hash_delete(struct HashTable *table, const char *strkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:419
bool changed
Mailbox has been modified.
Definition: mailbox.h:114
int mx_msg_padding_size(struct Mailbox *m)
Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
Definition: mx.c:1544
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:42
void mailbox_size_sub(struct Mailbox *m, const struct Email *e)
Subtract an email&#39;s size from the total size of a Mailbox.
Definition: mailbox.c:198
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:41
&#39;IMAP&#39; Mailbox type
Definition: mailbox.h:53
int msgno
Number displayed to the user.
Definition: email.h:86
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ message_is_tagged()

bool message_is_tagged ( struct Context ctx,
struct Email e 
)

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

Parameters
ctxOpen mailbox
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 343 of file context.c.

344 {
345  return message_is_visible(ctx, e) && e->tagged;
346 }
bool tagged
Email is tagged.
Definition: email.h:44
bool message_is_visible(struct Context *ctx, struct Email *e)
Is a message in the index within limit.
Definition: context.c:327
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ message_is_visible()

bool message_is_visible ( struct Context ctx,
struct Email e 
)

Is a message in the index within limit.

Parameters
ctxContext
eEmail
Return values
trueThe message is within limit

If no limit is in effect, all the messages are visible.

Definition at line 327 of file context.c.

328 {
329  if (!ctx || !e)
330  return false;
331 
332  return !ctx->pattern || e->limited;
333 }
bool limited
Is this message in a limited view?
Definition: email.h:74
char * pattern
Limit pattern string.
Definition: context.h:40
+ 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 405 of file context.c.

406 {
407  if (!m || !m->emails || !m->v2r)
408  return NULL;
409 
410  if ((vnum < 0) || (vnum >= m->vcount))
411  return NULL;
412 
413  int inum = m->v2r[vnum];
414  if ((inum < 0) || (inum >= m->msg_count))
415  return NULL;
416 
417  return m->emails[inum];
418 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
int msg_count
Total number of messages.
Definition: mailbox.h:91
int vcount
The number of virtual messages.
Definition: mailbox.h:102
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:101
+ Here is the caller graph for this function:

◆ el_add_tagged()

int el_add_tagged ( struct EmailList *  el,
struct Context ctx,
struct Email e,
bool  use_tagged 
)

Get a list of the tagged Emails.

Parameters
elEmpty EmailList to populate
ctxCurrent Mailbox
eCurrent Email
use_taggedUse tagged Emails
Return values
numNumber of selected emails
-1Error

Definition at line 357 of file context.c.

358 {
359  int count = 0;
360 
361  if (use_tagged)
362  {
363  if (!ctx || !ctx->mailbox || !ctx->mailbox->emails)
364  return -1;
365 
366  struct Mailbox *m = ctx->mailbox;
367  for (size_t i = 0; i < m->msg_count; i++)
368  {
369  e = m->emails[i];
370  if (!e)
371  break;
372  if (!message_is_tagged(ctx, e))
373  continue;
374 
375  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
376  en->email = e;
377  STAILQ_INSERT_TAIL(el, en, entries);
378  count++;
379  }
380  }
381  else
382  {
383  if (!e)
384  return -1;
385 
386  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
387  en->email = e;
388  STAILQ_INSERT_TAIL(el, en, entries);
389  count = 1;
390  }
391 
392  return count;
393 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
bool message_is_tagged(struct Context *ctx, struct Email *e)
Is a message in the index tagged (and within limit)
Definition: context.c:343
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
int msg_count
Total number of messages.
Definition: mailbox.h:91
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:386
struct Mailbox * mailbox
Definition: context.h:50
A mailbox.
Definition: mailbox.h:81
struct Email * email
Email in the list.
Definition: email.h:116
List of Emails.
Definition: email.h:114
+ Here is the call graph for this function:
+ Here is the caller graph for this function: