mview.h File Reference

View of a Mailbox. More...

#include <stdbool.h>
#include <sys/types.h>

Include dependency graph for mview.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	MailboxView
	View of a Mailbox. More...
struct	EventMview
	An Event that happened to an MailboxView. More...

Enumerations
enum	NotifyMview { NT_MVIEW_ADD = 1 , NT_MVIEW_DELETE , NT_MVIEW_CHANGE }
	Types of MailboxView Event. More...

Functions
void	mview_free (struct MailboxView **ptr)
	Free a MailboxView.
int	mview_mailbox_observer (struct NotifyCallback *nc)
	Notification that a Mailbox has changed - Implements observer_t -.
struct MailboxView *	mview_new (struct Mailbox *m, struct Notify *parent)
	Create a new MailboxView.
void	mview_update (struct MailboxView *mv)
	Update the MailboxView's message counts.
bool	mview_has_limit (const struct MailboxView *mv)
	Is a limit active?
struct Mailbox *	mview_mailbox (struct MailboxView *mv)
	Wrapper to get the mailbox in a MailboxView, or NULL.
bool	message_is_tagged (struct Email *e)
	Is a message in the index tagged (and within limit)
struct Email *	mutt_get_virt_email (struct Mailbox *m, int vnum)
	Get a virtual Email.
int	ea_add_tagged (struct EmailArray *ea, struct MailboxView *mv, struct Email *e, bool use_tagged)
	Get an array of the tagged Emails.
bool	mutt_limit_current_thread (struct MailboxView *mv, struct Email *e)
	Limit the email view to the current thread.

Detailed Description

View of a Mailbox.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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.h.

Enumeration Type Documentation

NotifyMview

enum NotifyMview

Types of MailboxView Event.

Observers of NT_MVIEW will be passed an EventMview.

Enumerator
NT_MVIEW_ADD	The Mview has been opened.
NT_MVIEW_DELETE	The Mview is about to be destroyed.
NT_MVIEW_CHANGE	The Mview has changed.

Definition at line 60 of file mview.h.

{
  NT_MVIEW_ADD = 1, 
  NT_MVIEW_DELETE,  
  NT_MVIEW_CHANGE,  
};

Function Documentation

mview_free()

void mview_free

(

struct MailboxView **

ptr

)

Free a MailboxView.

Parameters

[out]

ptr

MailboxView to free

Definition at line 50 of file mview.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct MailboxView *mv = *ptr;
 
  struct EventMview ev_m = { mv };
  mutt_debug(LL_NOTIFY, "NT_MVIEW_DELETE: %p\n", (void *) mv);
  notify_send(mv->notify, NT_MVIEW, NT_MVIEW_DELETE, &ev_m);
 
  if (mv->mailbox)
  {
    notify_observer_remove(mv->mailbox->notify, mview_mailbox_observer, mv);
 
    // Disconnect the Emails before freeing the Threads
    for (int i = 0; i < mv->mailbox->msg_count; i++)
    {
      struct Email *e = mv->mailbox->emails[i];
      if (!e)
        continue;
      e->thread = NULL;
      e->threaded = false;
    }
  }
 
  mutt_thread_ctx_free(&mv->threads);
  notify_free(&mv->notify);
  FREE(&mv->pattern);
  mutt_pattern_free(&mv->limit_pattern);
 
  *ptr = NULL;
  FREE(&mv);
}

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

m	Mailbox
parent	Notification parent

Return values

ptr	New MailboxView

Definition at line 91 of file mview.c.

{
  if (!m)
    return NULL;
 
  struct MailboxView *mv = MUTT_MEM_CALLOC(1, struct MailboxView);
 
  mv->notify = notify_new();
  notify_set_parent(mv->notify, parent);
  struct EventMview ev_m = { mv };
  mutt_debug(LL_NOTIFY, "NT_MVIEW_ADD: %p\n", (void *) mv);
  notify_send(mv->notify, NT_MVIEW, NT_MVIEW_ADD, &ev_m);
  // If the Mailbox is closed, mv->mailbox must be set to NULL
  notify_observer_add(m->notify, NT_MAILBOX, mview_mailbox_observer, mv);
 
  mv->mailbox = m;
  mv->threads = mutt_thread_ctx_init(mv);
  mv->msg_in_pager = -1;
  mv->collapsed = false;
  mview_update(mv);
 
  return mv;
}

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

mv	Mailbox View

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

Definition at line 139 of file mview.c.

{
  if (!mv || !mv->mailbox)
    return;
 
  struct Mailbox *m = mv->mailbox;
 
  mutt_hash_free(&m->subj_hash);
  mutt_hash_free(&m->id_hash);
 
  /* reset counters */
  m->msg_unread = 0;
  m->msg_flagged = 0;
  m->msg_new = 0;
  m->msg_deleted = 0;
  m->msg_tagged = 0;
  m->vcount = 0;
  m->changed = false;
 
  mutt_clear_threads(mv->threads);
 
  const bool c_score = cs_subset_bool(NeoMutt->sub, "score");
  struct Email *e = NULL;
  for (int msgno = 0; msgno < m->msg_count; msgno++)
  {
    e = m->emails[msgno];
    if (!e)
      continue;
 
    if (WithCrypto)
    {
      /* NOTE: this _must_ be done before the check for mailcap! */
      e->security = crypt_query(e->body);
    }
 
    if (mview_has_limit(mv))
    {
      e->vnum = -1;
    }
    else
    {
      m->v2r[m->vcount] = msgno;
      e->vnum = m->vcount++;
    }
    e->msgno = msgno;
 
    if (e->env->supersedes)
    {
      struct Email *e2 = NULL;
 
      if (!m->id_hash)
        m->id_hash = mutt_make_id_hash(m);
 
      e2 = mutt_hash_find(m->id_hash, e->env->supersedes);
      if (e2)
      {
        e2->superseded = true;
        if (c_score)
          mutt_score_message(mv->mailbox, e2, true);
      }
    }
 
    /* add this message to the hash tables */
    if (m->id_hash && e->env->message_id)
      mutt_hash_insert(m->id_hash, e->env->message_id, e);
    if (m->subj_hash && e->env->real_subj)
      mutt_hash_insert(m->subj_hash, e->env->real_subj, e);
    mutt_label_hash_add(m, e);
 
    if (c_score)
      mutt_score_message(mv->mailbox, e, false);
 
    if (e->changed)
      m->changed = true;
    if (e->flagged)
      m->msg_flagged++;
    if (e->deleted)
      m->msg_deleted++;
    if (e->tagged)
      m->msg_tagged++;
    if (!e->read)
    {
      m->msg_unread++;
      if (!e->old)
        m->msg_new++;
    }
  }
 
  /* rethread from scratch */
  mutt_sort_headers(mv, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mview_has_limit()

bool mview_has_limit

(

const struct MailboxView *

mv

)

Is a limit active?

Parameters

mv	MailboxView

Return values

true	A limit is active
false	No limit is active

Definition at line 439 of file mview.c.

{
  return mv && mv->pattern;
}

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

mv	MailboxView

Return values

ptr	The mailbox in the MailboxView
NULL	MailboxView is NULL or doesn't have a mailbox

Definition at line 450 of file mview.c.

{
  return mv ? mv->mailbox : NULL;
}

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

e

Email

Return values

true	The message is both tagged and within limit

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

Definition at line 364 of file mview.c.

{
  return e->visible && e->tagged;
}

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

m	Mailbox
vnum	Virtual index number

Return values

ptr	Email
NULL	No Email selected, or bad index values

This safely gets the result of the following:

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

Definition at line 418 of file mview.c.

{
  if (!m || !m->emails || !m->v2r)
    return NULL;
 
  if ((vnum < 0) || (vnum >= m->vcount))
    return NULL;
 
  int inum = m->v2r[vnum];
  if ((inum < 0) || (inum >= m->msg_count))
    return NULL;
 
  return m->emails[inum];
}

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

ea	Empty EmailArray to populate
mv	Current Mailbox
e	Current Email
use_tagged	Use tagged Emails

Return values

num	Number of selected emails
-1	Error

Definition at line 378 of file mview.c.

{
  if (use_tagged)
  {
    if (!mv || !mv->mailbox || !mv->mailbox->emails)
      return -1;
 
    struct Mailbox *m = mv->mailbox;
    for (int i = 0; i < m->msg_count; i++)
    {
      e = m->emails[i];
      if (!e)
        break;
      if (!message_is_tagged(e))
        continue;
 
      ARRAY_ADD(ea, e);
    }
  }
  else
  {
    if (!e)
      return -1;
 
    ARRAY_ADD(ea, e);
  }
 
  return ARRAY_SIZE(ea);
}

Here is the call graph for this function:

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

mv	Mailbox View
e	Email

Return values

true	Success
false	Failure

Definition at line 481 of file mview.c.

{
  if (!mv || !mv->mailbox || !e)
    return false;
 
  struct Mailbox *m = mv->mailbox;
 
  struct MuttThread *me = top_of_thread(e);
  if (!me)
    return false;
 
  m->vcount = 0;
  mv->vsize = 0;
  mv->collapsed = false;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    e = m->emails[i];
    if (!e)
      break;
 
    e->vnum = -1;
    e->visible = false;
    e->collapsed = false;
    e->num_hidden = 0;
 
    if (top_of_thread(e) == me)
    {
      struct Body *body = e->body;
 
      e->vnum = m->vcount;
      e->visible = true;
      m->v2r[m->vcount] = i;
      m->vcount++;
      mv->vsize += (body->length + body->offset - body->hdr_offset);
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: