mutt_thread.h File Reference

Create/manipulate threading in emails. More...

#include "email/lib.h"
#include <stdbool.h>
#include <stdint.h>
#include <sys/types.h>

Include dependency graph for mutt_thread.h:

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

Go to the source code of this file.

Data Structures
struct	ThreadsContext
	The "current" threading state. More...

Macros
#define	MUTT_THREAD_NO_FLAGS   0
	No flags are set.
#define	MUTT_THREAD_COLLAPSE   (1 << 0)
	Collapse an email thread.
#define	MUTT_THREAD_UNCOLLAPSE   (1 << 1)
	Uncollapse an email thread.
#define	MUTT_THREAD_UNREAD   (1 << 2)
	Count unread emails in a thread.
#define	MUTT_THREAD_NEXT_UNREAD   (1 << 3)
	Find the next unread email.
#define	MUTT_THREAD_FLAGGED   (1 << 4)
	Count flagged emails in a thread.
#define	mutt_collapse_thread(e)
#define	mutt_uncollapse_thread(e)
#define	mutt_thread_contains_unread(e)
#define	mutt_thread_contains_flagged(e)
#define	mutt_thread_next_unread(e)
#define	mutt_using_threads()
#define	mutt_next_thread(e)
#define	mutt_previous_thread(e)
#define	mutt_next_subthread(e)
#define	mutt_previous_subthread(e)

Typedefs
typedef uint8_t	MuttThreadFlags
	Flags, e.g. MUTT_THREAD_COLLAPSE.

Enumerations
enum	TreeChar {   MUTT_TREE_LLCORNER = 1 , MUTT_TREE_ULCORNER , MUTT_TREE_LTEE , MUTT_TREE_HLINE ,   MUTT_TREE_VLINE , MUTT_TREE_SPACE , MUTT_TREE_RARROW , MUTT_TREE_STAR ,   MUTT_TREE_HIDDEN , MUTT_TREE_EQUALS , MUTT_TREE_TTEE , MUTT_TREE_BTEE ,   MUTT_TREE_MISSING , MUTT_TREE_MAX , MUTT_SPECIAL_INDEX = MUTT_TREE_MAX }
	Tree characters for menus. More...
enum	MessageInThread { MIT_NUM_MESSAGES , MIT_POSITION }
	Flags for mutt_messages_in_thread() More...
enum	UseThreads { UT_UNSET , UT_FLAT , UT_THREADS , UT_REVERSE }
	Which threading style is active, $use_threads. More...

Functions
int	mutt_traverse_thread (struct Email *e, MuttThreadFlags flag)
	Recurse through an email thread, matching messages.
enum UseThreads	mutt_thread_style (void)
	Which threading style is active?
const char *	get_use_threads_str (enum UseThreads value)
	Convert UseThreads enum to string.
int	sort_validator (const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "sort" config variable - Implements ConfigDef::validator() -.
int	mutt_aside_thread (struct Email *e, bool forwards, bool subthreads)
	Find the next/previous (sub)thread.
struct ThreadsContext *	mutt_thread_ctx_init (struct MailboxView *mv)
	Initialize a threading context.
void	mutt_thread_ctx_free (struct ThreadsContext **ptr)
	Finalize a threading context.
void	mutt_thread_collapse_collapsed (struct ThreadsContext *tctx)
	Re-collapse threads marked as collapsed.
void	mutt_thread_collapse (struct ThreadsContext *tctx, bool collapse)
	Toggle collapse.
bool	mutt_thread_can_collapse (struct Email *e)
	Check whether a thread can be collapsed.
void	mutt_clear_threads (struct ThreadsContext *tctx)
	Clear the threading of message in a mailbox.
void	mutt_draw_tree (struct ThreadsContext *tctx)
	Draw a tree of threaded emails.
bool	mutt_link_threads (struct Email *parent, struct EmailArray *children, struct Mailbox *m)
	Forcibly link threads together.
struct HashTable *	mutt_make_id_hash (struct Mailbox *m)
	Create a Hash Table for message-ids.
int	mutt_messages_in_thread (struct Mailbox *m, struct Email *e, enum MessageInThread mit)
	Count the messages in a thread.
int	mutt_parent_message (struct Email *e, bool find_root)
	Find the parent of a message.
off_t	mutt_set_vnum (struct Mailbox *m)
	Set the virtual index number of all the messages in a mailbox.
void	mutt_sort_threads (struct ThreadsContext *tctx, bool init)
	Sort email threads.

Variables
const struct EnumDef	UseThreadsTypeDef
	Data for the $use_threads enumeration.

Detailed Description

Create/manipulate threading in emails.

Authors

• Richard Russon
• Pietro Cerutti
• Eric Blake

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

Macro Definition Documentation

MUTT_THREAD_NO_FLAGS

#define MUTT_THREAD_NO_FLAGS   0

No flags are set.

Definition at line 76 of file mutt_thread.h.

MUTT_THREAD_COLLAPSE

#define MUTT_THREAD_COLLAPSE   (1 << 0)

Collapse an email thread.

Definition at line 77 of file mutt_thread.h.

MUTT_THREAD_UNCOLLAPSE

#define MUTT_THREAD_UNCOLLAPSE   (1 << 1)

Uncollapse an email thread.

Definition at line 78 of file mutt_thread.h.

MUTT_THREAD_UNREAD

#define MUTT_THREAD_UNREAD   (1 << 2)

Count unread emails in a thread.

Definition at line 79 of file mutt_thread.h.

MUTT_THREAD_NEXT_UNREAD

#define MUTT_THREAD_NEXT_UNREAD   (1 << 3)

Find the next unread email.

Definition at line 80 of file mutt_thread.h.

MUTT_THREAD_FLAGGED

#define MUTT_THREAD_FLAGGED   (1 << 4)

Count flagged emails in a thread.

Definition at line 81 of file mutt_thread.h.

mutt_collapse_thread

#define mutt_collapse_thread

(

e

)

Value:

mutt_traverse_thread(e, MUTT_THREAD_COLLAPSE)

Definition at line 106 of file mutt_thread.h.

mutt_uncollapse_thread

#define mutt_uncollapse_thread

(

e

)

Value:

mutt_traverse_thread(e, MUTT_THREAD_UNCOLLAPSE)

Definition at line 107 of file mutt_thread.h.

mutt_thread_contains_unread

#define mutt_thread_contains_unread

(

e

)

Value:

mutt_traverse_thread(e, MUTT_THREAD_UNREAD)

Definition at line 108 of file mutt_thread.h.

mutt_thread_contains_flagged

#define mutt_thread_contains_flagged

(

e

)

Value:

mutt_traverse_thread(e, MUTT_THREAD_FLAGGED)

Definition at line 109 of file mutt_thread.h.

mutt_thread_next_unread

#define mutt_thread_next_unread

(

e

)

Value:

mutt_traverse_thread(e, MUTT_THREAD_NEXT_UNREAD)

Definition at line 110 of file mutt_thread.h.

mutt_using_threads

#define mutt_using_threads

(

)

Value:

(mutt_thread_style() > UT_FLAT)

Definition at line 113 of file mutt_thread.h.

mutt_next_thread

#define mutt_next_thread

(

e

)

Value:

mutt_aside_thread(e, true,  false)

Definition at line 118 of file mutt_thread.h.

mutt_previous_thread

#define mutt_previous_thread

(

e

)

Value:

mutt_aside_thread(e, false, false)

Definition at line 119 of file mutt_thread.h.

mutt_next_subthread

#define mutt_next_subthread

(

e

)

Value:

mutt_aside_thread(e, true,  true)

Definition at line 120 of file mutt_thread.h.

mutt_previous_subthread

#define mutt_previous_subthread

(

e

)

Value:

mutt_aside_thread(e, false, true)

Definition at line 121 of file mutt_thread.h.

Typedef Documentation

MuttThreadFlags

typedef uint8_t MuttThreadFlags

Flags, e.g. MUTT_THREAD_COLLAPSE.

Definition at line 75 of file mutt_thread.h.

Enumeration Type Documentation

TreeChar

enum TreeChar

Tree characters for menus.

See also

linearize_tree(), print_enriched_string()

Enumerator
MUTT_TREE_LLCORNER	Lower left corner.
MUTT_TREE_ULCORNER	Upper left corner.
MUTT_TREE_LTEE	Left T-piece.
MUTT_TREE_HLINE	Horizontal line.
MUTT_TREE_VLINE	Vertical line.
MUTT_TREE_SPACE	Blank space.
MUTT_TREE_RARROW	Right arrow.
MUTT_TREE_STAR	Star character (for threads)
MUTT_TREE_HIDDEN	Ampersand character (for threads)
MUTT_TREE_EQUALS	Equals (for threads)
MUTT_TREE_TTEE	Top T-piece.
MUTT_TREE_BTEE	Bottom T-piece.
MUTT_TREE_MISSING	Question mark.
MUTT_TREE_MAX
MUTT_SPECIAL_INDEX	Colour indicator.

Definition at line 55 of file mutt_thread.h.

{
  MUTT_TREE_LLCORNER = 1, 
  MUTT_TREE_ULCORNER,     
  MUTT_TREE_LTEE,         
  MUTT_TREE_HLINE,        
  MUTT_TREE_VLINE,        
  MUTT_TREE_SPACE,        
  MUTT_TREE_RARROW,       
  MUTT_TREE_STAR,         
  MUTT_TREE_HIDDEN,       
  MUTT_TREE_EQUALS,       
  MUTT_TREE_TTEE,         
  MUTT_TREE_BTEE,         
  MUTT_TREE_MISSING,      
  MUTT_TREE_MAX,
 
  MUTT_SPECIAL_INDEX = MUTT_TREE_MAX, 
};

MessageInThread

enum MessageInThread

Flags for mutt_messages_in_thread()

Enumerator
MIT_NUM_MESSAGES	How many messages are in the thread.
MIT_POSITION	Our position in the thread.

Definition at line 86 of file mutt_thread.h.

{
  MIT_NUM_MESSAGES, 
  MIT_POSITION,     
};

UseThreads

enum UseThreads

Which threading style is active, $use_threads.

Enumerator
UT_UNSET	Not yet set by user, stick to legacy semantics.
UT_FLAT	Unthreaded.
UT_THREADS	Normal threading (root above subthreads)
UT_REVERSE	Reverse threading (subthreads above root)

Definition at line 95 of file mutt_thread.h.

{
  UT_UNSET,     
  UT_FLAT,      
  UT_THREADS,   
  UT_REVERSE,   
};

Function Documentation

mutt_traverse_thread()

int mutt_traverse_thread	(	struct Email *	e_cur,
		MuttThreadFlags	flag )

Recurse through an email thread, matching messages.

Parameters

e_cur	Current Email
flag	Flag to set, see MuttThreadFlags

Return values

num	Number of matches

Definition at line 1438 of file mutt_thread.c.

{
  struct MuttThread *thread = NULL, *top = NULL;
  struct Email *e_root = NULL;
  const enum UseThreads threaded = mutt_thread_style();
  int final, reverse = (threaded == UT_REVERSE), minmsgno;
  int num_hidden = 0, new_mail = 0, old_mail = 0;
  bool flagged = false;
  int min_unread_msgno = INT_MAX, min_unread = e_cur->vnum;
 
  if (threaded == UT_FLAT)
  {
    mutt_error(_("Threading is not enabled"));
    return e_cur->vnum;
  }
 
  if (!e_cur->thread)
  {
    return e_cur->vnum;
  }
 
  final = e_cur->vnum;
  thread = e_cur->thread;
  while (thread->parent)
    thread = thread->parent;
  top = thread;
  while (!thread->message)
    thread = thread->child;
  e_cur = thread->message;
  minmsgno = e_cur->msgno;
 
  if (!e_cur->read && e_cur->visible)
  {
    if (e_cur->old)
      old_mail = 2;
    else
      new_mail = 1;
    if (e_cur->msgno < min_unread_msgno)
    {
      min_unread = e_cur->vnum;
      min_unread_msgno = e_cur->msgno;
    }
  }
 
  if (e_cur->flagged && e_cur->visible)
    flagged = true;
 
  if ((e_cur->vnum == -1) && e_cur->visible)
    num_hidden++;
 
  if (flag & (MUTT_THREAD_COLLAPSE | MUTT_THREAD_UNCOLLAPSE))
  {
    e_cur->attr_color = NULL; /* force index entry's color to be re-evaluated */
    e_cur->collapsed = flag & MUTT_THREAD_COLLAPSE;
    if (e_cur->vnum != -1)
    {
      e_root = e_cur;
      if (flag & MUTT_THREAD_COLLAPSE)
        final = e_root->vnum;
    }
  }
 
  if ((thread == top) && !(thread = thread->child))
  {
    /* return value depends on action requested */
    if (flag & (MUTT_THREAD_COLLAPSE | MUTT_THREAD_UNCOLLAPSE))
    {
      e_cur->num_hidden = num_hidden;
      return final;
    }
    if (flag & MUTT_THREAD_UNREAD)
      return (old_mail && new_mail) ? new_mail : (old_mail ? old_mail : new_mail);
    if (flag & MUTT_THREAD_NEXT_UNREAD)
      return min_unread;
    if (flag & MUTT_THREAD_FLAGGED)
      return flagged;
  }
 
  while (true)
  {
    e_cur = thread->message;
 
    if (e_cur)
    {
      if (flag & (MUTT_THREAD_COLLAPSE | MUTT_THREAD_UNCOLLAPSE))
      {
        e_cur->attr_color = NULL; /* force index entry's color to be re-evaluated */
        e_cur->collapsed = flag & MUTT_THREAD_COLLAPSE;
        if (!e_root && e_cur->visible)
        {
          e_root = e_cur;
          if (flag & MUTT_THREAD_COLLAPSE)
            final = e_root->vnum;
        }
 
        if (reverse && (flag & MUTT_THREAD_COLLAPSE) &&
            (e_cur->msgno < minmsgno) && e_cur->visible)
        {
          minmsgno = e_cur->msgno;
          final = e_cur->vnum;
        }
 
        if (flag & MUTT_THREAD_COLLAPSE)
        {
          if (e_cur != e_root)
            e_cur->vnum = -1;
        }
        else
        {
          if (e_cur->visible)
            e_cur->vnum = e_cur->msgno;
        }
      }
 
      if (!e_cur->read && e_cur->visible)
      {
        if (e_cur->old)
          old_mail = 2;
        else
          new_mail = 1;
        if (e_cur->msgno < min_unread_msgno)
        {
          min_unread = e_cur->vnum;
          min_unread_msgno = e_cur->msgno;
        }
      }
 
      if (e_cur->flagged && e_cur->visible)
        flagged = true;
 
      if ((e_cur->vnum == -1) && e_cur->visible)
        num_hidden++;
    }
 
    if (thread->child)
    {
      thread = thread->child;
    }
    else if (thread->next)
    {
      thread = thread->next;
    }
    else
    {
      bool done = false;
      while (!thread->next)
      {
        thread = thread->parent;
        if (thread == top)
        {
          done = true;
          break;
        }
      }
      if (done)
        break;
      thread = thread->next;
    }
  }
 
  /* re-traverse the thread and store num_hidden in all headers, with or
   * without a virtual index.  this will allow ~v to match all collapsed
   * messages when switching sort order to non-threaded.  */
  if (flag & MUTT_THREAD_COLLAPSE)
  {
    thread = top;
    while (true)
    {
      e_cur = thread->message;
      if (e_cur)
        e_cur->num_hidden = num_hidden + 1;
 
      if (thread->child)
      {
        thread = thread->child;
      }
      else if (thread->next)
      {
        thread = thread->next;
      }
      else
      {
        bool done = false;
        while (!thread->next)
        {
          thread = thread->parent;
          if (thread == top)
          {
            done = true;
            break;
          }
        }
        if (done)
          break;
        thread = thread->next;
      }
    }
  }
 
  /* return value depends on action requested */
  if (flag & (MUTT_THREAD_COLLAPSE | MUTT_THREAD_UNCOLLAPSE))
    return final;
  if (flag & MUTT_THREAD_UNREAD)
    return (old_mail && new_mail) ? new_mail : (old_mail ? old_mail : new_mail);
  if (flag & MUTT_THREAD_NEXT_UNREAD)
    return min_unread;
  if (flag & MUTT_THREAD_FLAGGED)
    return flagged;
 
  return 0;
}

Here is the call graph for this function:

mutt_thread_style()

enum UseThreads mutt_thread_style

(

void

)

Which threading style is active?

Return values

UT_FLAT	No threading in use
UT_THREADS	Normal threads (root above subthread)
UT_REVERSE	Reverse threads (subthread above root)

Note

UT_UNSET is never returned; rather, this function considers the interaction between $use_threads and $sort.

Definition at line 81 of file mutt_thread.c.

{
  const unsigned char c_use_threads = cs_subset_enum(NeoMutt->sub, "use_threads");
  const enum EmailSortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  if (c_use_threads > UT_FLAT)
    return c_use_threads;
  if ((c_sort & SORT_MASK) != EMAIL_SORT_THREADS)
    return UT_FLAT;
  if (c_sort & SORT_REVERSE)
    return UT_REVERSE;
  return UT_THREADS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_use_threads_str()

const char * get_use_threads_str

(

enum UseThreads

value

)

Convert UseThreads enum to string.

Parameters

value

Value to convert

Return values

ptr	String form of value

Definition at line 99 of file mutt_thread.c.

{
  return mutt_map_get_name(value, UseThreadsMethods);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_aside_thread()

int mutt_aside_thread	(	struct Email *	e,
		bool	forwards,
		bool	subthreads )

Find the next/previous (sub)thread.

Parameters

e	Search from this Email
forwards	Direction to search: 'true' forwards, 'false' backwards
subthreads	Search subthreads: 'true' subthread, 'false' not

Return values

num	Index into the virtual email table
-1	Error

Definition at line 1287 of file mutt_thread.c.

{
  if (!e)
    return -1;
 
  struct MuttThread *cur = NULL;
  struct Email *e_tmp = NULL;
 
  const enum UseThreads threaded = mutt_thread_style();
  if (threaded == UT_FLAT)
  {
    mutt_error(_("Threading is not enabled"));
    return e->vnum;
  }
 
  cur = e->thread;
 
  if (subthreads)
  {
    if (forwards ^ (threaded == UT_REVERSE))
    {
      while (!cur->next && cur->parent)
        cur = cur->parent;
    }
    else
    {
      while (!cur->prev && cur->parent)
        cur = cur->parent;
    }
  }
  else
  {
    while (cur->parent)
      cur = cur->parent;
  }
 
  if (forwards ^ (threaded == UT_REVERSE))
  {
    do
    {
      cur = cur->next;
      if (!cur)
        return -1;
      e_tmp = find_virtual(cur, false);
    } while (!e_tmp);
  }
  else
  {
    do
    {
      cur = cur->prev;
      if (!cur)
        return -1;
      e_tmp = find_virtual(cur, true);
    } while (!e_tmp);
  }
 
  return e_tmp->vnum;
}

Here is the call graph for this function:

mutt_thread_ctx_init()

struct ThreadsContext * mutt_thread_ctx_init

(

struct MailboxView *

mv

)

Initialize a threading context.

Parameters

mv	Mailbox view

Return values

ptr	Threading context

Definition at line 355 of file mutt_thread.c.

{
  struct ThreadsContext *tctx = MUTT_MEM_CALLOC(1, struct ThreadsContext);
  tctx->mailbox_view = mv;
  return tctx;
}

Here is the caller graph for this function:

mutt_thread_ctx_free()

void mutt_thread_ctx_free

(

struct ThreadsContext **

ptr

)

Finalize a threading context.

Parameters

ptr	Threading context to free

Definition at line 366 of file mutt_thread.c.

{
  if (!ptr || !*ptr)
  {
    return;
  }
 
  struct ThreadsContext *tctx = *ptr;
 
  mutt_hash_free(&tctx->hash);
 
  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_thread_collapse_collapsed()

void mutt_thread_collapse_collapsed

(

struct ThreadsContext *

tctx

)

Re-collapse threads marked as collapsed.

Parameters

tctx	Threading context

Definition at line 1768 of file mutt_thread.c.

{
  struct MuttThread *thread = NULL;
  struct MuttThread *top = tctx->tree;
  while ((thread = top))
  {
    while (!thread->message)
      thread = thread->child;
 
    struct Email *e = thread->message;
    if (e->collapsed)
      mutt_collapse_thread(e);
    top = top->next;
  }
}

Here is the caller graph for this function:

mutt_thread_collapse()

void mutt_thread_collapse	(	struct ThreadsContext *	tctx,
		bool	collapse )

Toggle collapse.

Parameters

tctx	Threading context
collapse	Collapse / uncollapse

Definition at line 1789 of file mutt_thread.c.

{
  struct MuttThread *thread = NULL;
  struct MuttThread *top = tctx->tree;
  while ((thread = top))
  {
    while (!thread->message)
      thread = thread->child;
 
    struct Email *e = thread->message;
 
    if (e->collapsed != collapse)
    {
      if (e->collapsed)
        mutt_uncollapse_thread(e);
      else if (mutt_thread_can_collapse(e))
        mutt_collapse_thread(e);
    }
    top = top->next;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_thread_can_collapse()

bool mutt_thread_can_collapse

(

struct Email *

e

)

Check whether a thread can be collapsed.

Parameters

e	Head of the thread

Return values

true	Can be collapsed
false	Cannot be collapsed

Definition at line 1817 of file mutt_thread.c.

{
  const bool c_collapse_flagged = cs_subset_bool(NeoMutt->sub, "collapse_flagged");
  const bool c_collapse_unread = cs_subset_bool(NeoMutt->sub, "collapse_unread");
  return (c_collapse_unread || !mutt_thread_contains_unread(e)) &&
         (c_collapse_flagged || !mutt_thread_contains_flagged(e));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_clear_threads()

void mutt_clear_threads

(

struct ThreadsContext *

tctx

)

Clear the threading of message in a mailbox.

Parameters

tctx	Threading context

Definition at line 718 of file mutt_thread.c.

{
  if (!tctx || !tctx->tree)
    return;
 
  struct MailboxView *mv = tctx->mailbox_view;
  if (!mv)
    return;
 
  struct Mailbox *m = mv->mailbox;
  if (!m || !m->emails)
    return;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    /* mailbox may have been only partially read */
    e->thread = NULL;
    e->threaded = false;
  }
  tctx->tree = NULL;
  mutt_hash_free(&tctx->hash);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_draw_tree()

void mutt_draw_tree

(

struct ThreadsContext *

tctx

)

Draw a tree of threaded emails.

Parameters

tctx	Threading context

Since the graphics characters have a value >255, I have to resort to using escape sequences to pass the information to print_enriched_string(). These are the macros MUTT_TREE_* defined in mutt.h.

ncurses should automatically use the default ASCII characters instead of graphics chars on terminals which don't support them (see the man page for curs_addch).

Definition at line 392 of file mutt_thread.c.

{
  char *pfx = NULL, *mypfx = NULL, *arrow = NULL, *myarrow = NULL, *new_tree = NULL;
  const bool reverse = (mutt_thread_style() == UT_REVERSE);
  enum TreeChar corner = reverse ? MUTT_TREE_ULCORNER : MUTT_TREE_LLCORNER;
  enum TreeChar vtee = reverse ? MUTT_TREE_BTEE : MUTT_TREE_TTEE;
  const bool c_narrow_tree = cs_subset_bool(NeoMutt->sub, "narrow_tree");
  int depth = 0, start_depth = 0, max_depth = 0, width = c_narrow_tree ? 1 : 2;
  struct MuttThread *nextdisp = NULL, *pseudo = NULL, *parent = NULL;
 
  struct MuttThread *tree = tctx->tree;
 
  /* Do the visibility calculations and free the old thread chars.
   * From now on we can simply ignore invisible subtrees */
  calculate_visibility(tree, &max_depth);
  pfx = MUTT_MEM_MALLOC((width * max_depth) + 2, char);
  arrow = MUTT_MEM_MALLOC((width * max_depth) + 2, char);
  const bool c_hide_limited = cs_subset_bool(NeoMutt->sub, "hide_limited");
  const bool c_hide_missing = cs_subset_bool(NeoMutt->sub, "hide_missing");
  while (tree)
  {
    if (depth != 0)
    {
      myarrow = arrow + (depth - start_depth - ((start_depth != 0) ? 0 : 1)) * width;
      if (start_depth == depth)
        myarrow[0] = nextdisp ? MUTT_TREE_LTEE : corner;
      else if (parent->message && !c_hide_limited)
        myarrow[0] = MUTT_TREE_HIDDEN;
      else if (!parent->message && !c_hide_missing)
        myarrow[0] = MUTT_TREE_MISSING;
      else
        myarrow[0] = vtee;
      if (width == 2)
      {
        myarrow[1] = pseudo ? MUTT_TREE_STAR :
                              (tree->duplicate_thread ? MUTT_TREE_EQUALS : MUTT_TREE_HLINE);
      }
      if (tree->visible)
      {
        myarrow[width] = MUTT_TREE_RARROW;
        myarrow[width + 1] = 0;
        new_tree = MUTT_MEM_MALLOC(((size_t) depth * width) + 2, char);
        if (start_depth > 1)
        {
          strncpy(new_tree, pfx, (size_t) width * (start_depth - 1));
          mutt_str_copy(new_tree + (start_depth - 1) * width, arrow,
                        (1 + depth - start_depth) * width + 2);
        }
        else
        {
          mutt_str_copy(new_tree, arrow, ((size_t) depth * width) + 2);
        }
        tree->message->tree = new_tree;
      }
    }
    if (tree->child && (depth != 0))
    {
      mypfx = pfx + (depth - 1) * width;
      mypfx[0] = nextdisp ? MUTT_TREE_VLINE : MUTT_TREE_SPACE;
      if (width == 2)
        mypfx[1] = MUTT_TREE_SPACE;
    }
    parent = tree;
    nextdisp = NULL;
    pseudo = NULL;
    do
    {
      if (tree->child && tree->subtree_visible)
      {
        if (tree->deep)
          depth++;
        if (tree->visible)
          start_depth = depth;
        tree = tree->child;
 
        /* we do this here because we need to make sure that the first child thread
         * of the old tree that we deal with is actually displayed if any are,
         * or we might set the parent variable wrong while going through it. */
        while (!tree->subtree_visible && tree->next)
          tree = tree->next;
      }
      else
      {
        while (!tree->next && tree->parent)
        {
          if (tree == pseudo)
            pseudo = NULL;
          if (tree == nextdisp)
            nextdisp = NULL;
          if (tree->visible)
            start_depth = depth;
          tree = tree->parent;
          if (tree->deep)
          {
            if (start_depth == depth)
              start_depth--;
            depth--;
          }
        }
        if (tree == pseudo)
          pseudo = NULL;
        if (tree == nextdisp)
          nextdisp = NULL;
        if (tree->visible)
          start_depth = depth;
        tree = tree->next;
        if (!tree)
          break;
      }
      if (!pseudo && tree->fake_thread)
        pseudo = tree;
      if (!nextdisp && tree->next_subtree_visible)
        nextdisp = tree;
    } while (!tree->deep);
  }
 
  FREE(&pfx);
  FREE(&arrow);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_link_threads()

bool mutt_link_threads	(	struct Email *	parent,
		struct EmailArray *	children,
		struct Mailbox *	m )

Forcibly link threads together.

Parameters

parent	Parent Email
children	Array of children Emails
m	Mailbox

Return values

true	On success

Definition at line 1747 of file mutt_thread.c.

{
  if (!parent || !children || !m)
    return false;
 
  bool changed = false;
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, children)
  {
    struct Email *e = *ep;
    changed |= link_threads(parent, e, m);
  }
 
  return changed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_make_id_hash()

struct HashTable * mutt_make_id_hash

(

struct Mailbox *

m

)

Create a Hash Table for message-ids.

Parameters

m

Mailbox

Return values

ptr	Newly allocated Hash Table

Definition at line 1702 of file mutt_thread.c.

{
  struct HashTable *hash = mutt_hash_new(m->msg_count * 2, MUTT_HASH_NO_FLAGS);
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e || !e->env)
      continue;
 
    if (e->env->message_id)
      mutt_hash_insert(hash, e->env->message_id, e);
  }
 
  return hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_messages_in_thread()

int mutt_messages_in_thread	(	struct Mailbox *	m,
		struct Email *	e,
		enum MessageInThread	mit )

Count the messages in a thread.

Parameters

m	Mailbox
e	Email
mit	Flag, e.g. MIT_NUM_MESSAGES

Return values

num	Number of message / Our position

Definition at line 1657 of file mutt_thread.c.

{
  if (!m || !e)
    return 1;
 
  struct MuttThread *threads[2];
  int rc;
 
  const enum UseThreads threaded = mutt_thread_style();
  if ((threaded == UT_FLAT) || !e->thread)
    return 1;
 
  threads[0] = e->thread;
  while (threads[0]->parent)
    threads[0] = threads[0]->parent;
 
  threads[1] = (mit == MIT_POSITION) ? e->thread : threads[0]->next;
 
  for (int i = 0; i < (((mit == MIT_POSITION) || !threads[1]) ? 1 : 2); i++)
  {
    while (!threads[i]->message)
      threads[i] = threads[i]->child;
  }
 
  if (threaded == UT_REVERSE)
  {
    rc = threads[0]->message->msgno - (threads[1] ? threads[1]->message->msgno : -1);
  }
  else
  {
    rc = (threads[1] ? threads[1]->message->msgno : m->msg_count) -
         threads[0]->message->msgno;
  }
 
  if (mit == MIT_POSITION)
    rc += 1;
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parent_message()

int mutt_parent_message	(	struct Email *	e,
		bool	find_root )

Find the parent of a message.

Parameters

e	Current Email
find_root	If true, find the root message

Return values

>=0	Virtual index number of parent/root message
-1	Error

Definition at line 1354 of file mutt_thread.c.

{
  if (!e)
    return -1;
 
  struct MuttThread *thread = NULL;
  struct Email *e_parent = NULL;
 
  if (!mutt_using_threads())
  {
    mutt_error(_("Threading is not enabled"));
    return e->vnum;
  }
 
  /* Root may be the current message */
  if (find_root)
    e_parent = e;
 
  for (thread = e->thread->parent; thread; thread = thread->parent)
  {
    e = thread->message;
    if (e)
    {
      e_parent = e;
      if (!find_root)
        break;
    }
  }
 
  if (!e_parent)
  {
    mutt_error(_("Parent message is not available"));
    return -1;
  }
  if (!is_visible(e_parent))
  {
    if (find_root)
      mutt_error(_("Root message is not visible in this limited view"));
    else
      mutt_error(_("Parent message is not visible in this limited view"));
    return -1;
  }
  return e_parent->vnum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_set_vnum()

off_t mutt_set_vnum

(

struct Mailbox *

m

)

Set the virtual index number of all the messages in a mailbox.

Parameters

m

Mailbox

Return values

num	Size in bytes of all messages shown

Definition at line 1404 of file mutt_thread.c.

{
  if (!m)
    return 0;
 
  off_t vsize = 0;
  const int padding = mx_msg_padding_size(m);
 
  m->vcount = 0;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (e->vnum >= 0)
    {
      e->vnum = m->vcount;
      m->v2r[m->vcount] = i;
      m->vcount++;
      vsize += e->body->length + e->body->offset - e->body->hdr_offset + padding;
    }
  }
 
  return vsize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sort_threads()

void mutt_sort_threads	(	struct ThreadsContext *	tctx,
		bool	init )

Sort email threads.

Parameters

tctx	Threading context
init	If true, rebuild the thread

Definition at line 1031 of file mutt_thread.c.

{
  if (!tctx || !tctx->mailbox_view)
    return;
 
  struct MailboxView *mv = tctx->mailbox_view;
  struct Mailbox *m = mv->mailbox;
 
  struct Email *e = NULL;
  int i, using_refs = 0;
  struct MuttThread *thread = NULL, *tnew = NULL, *tmp = NULL;
  struct MuttThread top = { 0 };
  struct ListNode *ref = NULL;
 
  ASSERT(m->msg_count > 0);
  if (!tctx->hash)
    init = true;
 
  if (init)
  {
    tctx->hash = mutt_hash_new(m->msg_count * 2, MUTT_HASH_ALLOW_DUPS);
    mutt_hash_set_destructor(tctx->hash, thread_hash_destructor, 0);
  }
 
  /* we want a quick way to see if things are actually attached to the top of the
   * thread tree or if they're just dangling, so we attach everything to a top
   * node temporarily */
  top.parent = NULL;
  top.next = NULL;
  top.prev = NULL;
 
  top.child = tctx->tree;
  for (thread = tctx->tree; thread; thread = thread->next)
    thread->parent = ⊤
 
  /* put each new message together with the matching messageless MuttThread if it
   * exists.  otherwise, if there is a MuttThread that already has a message, thread
   * new message as an identical child.  if we didn't attach the message to a
   * MuttThread, make a new one for it. */
  const bool c_duplicate_threads = cs_subset_bool(NeoMutt->sub, "duplicate_threads");
  for (i = 0; i < m->msg_count; i++)
  {
    e = m->emails[i];
    if (!e)
      continue;
 
    if (e->thread)
    {
      /* unlink pseudo-threads because they might be children of newly
       * arrived messages */
      thread = e->thread;
      for (tnew = thread->child; tnew;)
      {
        tmp = tnew->next;
        if (tnew->fake_thread)
        {
          unlink_message(&thread->child, tnew);
          insert_message(&top.child, &top, tnew);
          tnew->fake_thread = false;
        }
        tnew = tmp;
      }
    }
    else
    {
      if ((!init || c_duplicate_threads) && e->env->message_id)
        thread = mutt_hash_find(tctx->hash, e->env->message_id);
      else
        thread = NULL;
 
      if (thread && !thread->message)
      {
        /* this is a message which was missing before */
        thread->message = e;
        e->thread = thread;
        thread->check_subject = true;
 
        /* mark descendants as needing subject_changed checked */
        for (tmp = (thread->child ? thread->child : thread); tmp != thread;)
        {
          while (!tmp->message)
            tmp = tmp->child;
          tmp->check_subject = true;
          while (!tmp->next && (tmp != thread))
            tmp = tmp->parent;
          if (tmp != thread)
            tmp = tmp->next;
        }
 
        if (thread->parent)
        {
          /* remove threading info above it based on its children, which we'll
           * recalculate based on its headers.  make sure not to leave
           * dangling missing messages.  note that we haven't kept track
           * of what info came from its children and what from its siblings'
           * children, so we just remove the stuff that's definitely from it */
          do
          {
            tmp = thread->parent;
            unlink_message(&tmp->child, thread);
            thread->parent = NULL;
            thread->sort_thread_key = NULL;
            thread->sort_aux_key = NULL;
            thread->fake_thread = false;
            thread = tmp;
          } while (thread != &top && !thread->child && !thread->message);
        }
      }
      else
      {
        tnew = (c_duplicate_threads ? thread : NULL);
 
        thread = MUTT_MEM_CALLOC(1, struct MuttThread);
        thread->message = e;
        thread->check_subject = true;
        e->thread = thread;
        mutt_hash_insert(tctx->hash, e->env->message_id ? e->env->message_id : "", thread);
 
        if (tnew)
        {
          if (tnew->duplicate_thread)
            tnew = tnew->parent;
 
          thread = e->thread;
 
          insert_message(&tnew->child, tnew, thread);
          thread->duplicate_thread = true;
          thread->message->threaded = true;
        }
      }
    }
  }
 
  /* thread by references */
  for (i = 0; i < m->msg_count; i++)
  {
    e = m->emails[i];
    if (!e)
      break;
 
    if (e->threaded)
      continue;
    e->threaded = true;
 
    thread = e->thread;
    if (!thread)
      continue;
    using_refs = 0;
 
    while (true)
    {
      if (using_refs == 0)
      {
        /* look at the beginning of in-reply-to: */
        ref = STAILQ_FIRST(&e->env->in_reply_to);
        if (ref)
        {
          using_refs = 1;
        }
        else
        {
          ref = STAILQ_FIRST(&e->env->references);
          using_refs = 2;
        }
      }
      else if (using_refs == 1)
      {
        /* if there's no references header, use all the in-reply-to:
         * data that we have.  otherwise, use the first reference
         * if it's different than the first in-reply-to, otherwise use
         * the second reference (since at least eudora puts the most
         * recent reference in in-reply-to and the rest in references) */
        if (STAILQ_EMPTY(&e->env->references))
        {
          ref = STAILQ_NEXT(ref, entries);
        }
        else
        {
          if (!mutt_str_equal(ref->data, STAILQ_FIRST(&e->env->references)->data))
            ref = STAILQ_FIRST(&e->env->references);
          else
            ref = STAILQ_NEXT(STAILQ_FIRST(&e->env->references), entries);
 
          using_refs = 2;
        }
      }
      else
      {
        ref = STAILQ_NEXT(ref, entries); /* go on with references */
      }
 
      if (!ref)
        break;
 
      tnew = mutt_hash_find(tctx->hash, ref->data);
      if (tnew)
      {
        if (tnew->duplicate_thread)
          tnew = tnew->parent;
        if (is_descendant(tnew, thread)) /* no loops! */
          continue;
      }
      else
      {
        tnew = MUTT_MEM_CALLOC(1, struct MuttThread);
        mutt_hash_insert(tctx->hash, ref->data, tnew);
      }
 
      if (thread->parent)
        unlink_message(&top.child, thread);
      insert_message(&tnew->child, tnew, thread);
      thread = tnew;
      if (thread->message || (thread->parent && (thread->parent != &top)))
        break;
    }
 
    if (!thread->parent)
      insert_message(&top.child, &top, thread);
  }
 
  /* detach everything from the temporary top node */
  for (thread = top.child; thread; thread = thread->next)
  {
    thread->parent = NULL;
  }
  tctx->tree = top.child;
 
  check_subjects(mv, init);
 
  const bool c_strict_threads = cs_subset_bool(NeoMutt->sub, "strict_threads");
  if (!c_strict_threads)
    pseudo_threads(tctx);
 
  /* if $sort_aux or similar changed after the mailbox is sorted, then
   * all the subthreads need to be resorted */
  if (tctx->tree)
  {
    mutt_sort_subthreads(tctx, init || OptSortSubthreads);
    OptSortSubthreads = false;
 
    /* Put the list into an array. */
    linearize_tree(tctx);
 
    /* Draw the thread tree. */
    mutt_draw_tree(tctx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

UseThreadsTypeDef

const struct EnumDef UseThreadsTypeDef

extern

Data for the $use_threads enumeration.

Definition at line 66 of file mutt_thread.c.

                                         {
  "use_threads_type",
  4,
  (struct Mapping *) &UseThreadsMethods,
};