lib.h File Reference

GUI manage the main index (list of emails). More...

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "expando/lib.h"
#include "expando_index.h"
#include "functions.h"
#include "shared_data.h"
#include "status.h"
#include "subjectrx.h"

Include dependency graph for lib.h:

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

Go to the source code of this file.

Typedefs
typedef uint8_t	NotifyIndex
typedef uint8_t	CheckFlags

Enumerations
enum	NotifyIndexFlag {   NT_INDEX_NONE = 0 , NT_INDEX_ADD = 1U << 0 , NT_INDEX_DELETE = 1U << 1 , NT_INDEX_SUBSET = 1U << 2 ,   NT_INDEX_ACCOUNT = 1U << 3 , NT_INDEX_MVIEW = 1U << 4 , NT_INDEX_MAILBOX = 1U << 5 , NT_INDEX_EMAIL = 1U << 6 }
	Flags, e.g. More...
enum	CheckFlag {   CHECK_NONE = 0 , CHECK_IN_MAILBOX = 1U << 0 , CHECK_MSGCOUNT = 1U << 1 , CHECK_VISIBLE = 1U << 2 ,   CHECK_READONLY = 1U << 3 , CHECK_ATTACH = 1U << 4 }
	Flags, e.g. More...
enum	CollapseMode { COLLAPSE_MODE_TOGGLE , COLLAPSE_MODE_CLOSE , COLLAPSE_MODE_OPEN }
	Action to perform on a Thread. More...

Functions
void	index_init_keys (struct NeoMutt *n, struct SubMenu *sm_generic)
	Initialise the Index Keybindings - Implements ::init_keys_api.
void	change_folder_mailbox (struct Menu *menu, struct Mailbox *m, int *oldcount, struct IndexSharedData *shared, bool read_only)
	Change to a different Mailbox by pointer.
struct Mailbox *	change_folder_notmuch (struct Menu *menu, char *buf, int buflen, int *oldcount, struct IndexSharedData *shared, bool read_only)
	Change to a different Notmuch Mailbox by string.
void	change_folder_string (struct Menu *menu, struct Buffer *buf, int *oldcount, struct IndexSharedData *shared, bool read_only)
	Change to a different Mailbox by string.
bool	check_acl (struct Mailbox *m, AclFlags acl, const char *msg)
	Check the ACLs for a function.
void	collapse_all (struct MailboxView *mv, struct Menu *menu, enum CollapseMode mode)
	Collapse/uncollapse all threads.
struct Mailbox *	dlg_index (struct MuttWindow *dlg, struct Mailbox *m)
	Display a list of emails -.
int	find_first_message (struct MailboxView *mv)
	Get index of first new message.
int	find_next_undeleted (struct MailboxView *mv, int msgno, bool uncollapse)
	Find the next undeleted email.
int	find_previous_undeleted (struct MailboxView *mv, int msgno, bool uncollapse)
	Find the previous undeleted email.
struct Mailbox *	get_current_mailbox (void)
	Get the current Mailbox.
struct MailboxView *	get_current_mailbox_view (void)
	Get the current Mailbox view.
void	index_change_folder (struct MuttWindow *dlg, struct Mailbox *m)
	Change the current folder, cautiously.
const struct AttrColor *	index_color (struct Menu *menu, int line)
	Calculate the colour for a line of the index - Implements Menu::color() -.
int	index_make_entry (struct Menu *menu, int line, int max_cols, struct Buffer *buf)
	Format an Email for the Menu - Implements Menu::make_entry() -.
struct MuttWindow *	index_pager_init (void)
	Allocate the Windows for the Index/Pager.
int	mutt_dlgindex_observer (struct NotifyCallback *nc)
void	mutt_draw_statusline (struct MuttWindow *win, int max_cols, const char *buf, size_t buflen)
	Draw a highlighted status bar.
void	email_set_color (struct Mailbox *m, struct Email *e)
	Select an Index colour for an Email.
void	resort_index (struct MailboxView *mv, struct Menu *menu)
	Resort the index.
void	update_index (struct Menu *menu, struct MailboxView *mv, enum MxStatus check, int oldcount, const struct IndexSharedData *shared)
	Update the index.
int	mutt_make_string (struct Buffer *buf, size_t max_cols, const struct Expando *exp, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
	Create formatted strings using mailbox expandos.

Variables
const struct Mapping	IndexNewsHelp []
	Help Bar for the News Index dialog.
const struct ExpandoDefinition	StatusFormatDef []
	Expando definitions.

Detailed Description

GUI manage the main index (list of emails).

Authors

• Richard Russon

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

Typedef Documentation

NotifyIndex

typedef uint8_t NotifyIndex

Definition at line 82 of file lib.h.

CheckFlags

typedef uint8_t CheckFlags

Definition at line 96 of file lib.h.

Enumeration Type Documentation

NotifyIndexFlag

enum NotifyIndexFlag

Flags, e.g.

NT_INDEX_ACCOUNT

Enumerator
NT_INDEX_NONE	No flags are set.
NT_INDEX_ADD	New Index Shared Data has been created.
NT_INDEX_DELETE	Index Shared Data is about to be freed.
NT_INDEX_SUBSET	Config Subset has changed.
NT_INDEX_ACCOUNT	Account has changed.
NT_INDEX_MVIEW	MailboxView has changed.
NT_INDEX_MAILBOX	Mailbox has changed.
NT_INDEX_EMAIL	Email has changed.

Definition at line 71 of file lib.h.

{
  NT_INDEX_NONE    =       0,  
  NT_INDEX_ADD     = 1U << 0,  
  NT_INDEX_DELETE  = 1U << 1,  
  NT_INDEX_SUBSET  = 1U << 2,  
  NT_INDEX_ACCOUNT = 1U << 3,  
  NT_INDEX_MVIEW   = 1U << 4,  
  NT_INDEX_MAILBOX = 1U << 5,  
  NT_INDEX_EMAIL   = 1U << 6,  
};

CheckFlag

enum CheckFlag

Flags, e.g.

CHECK_IN_MAILBOX

Enumerator
CHECK_NONE	No flags are set.
CHECK_IN_MAILBOX	Is there a mailbox open?
CHECK_MSGCOUNT	Are there any messages?
CHECK_VISIBLE	Is the selected message visible in the index?
CHECK_READONLY	Is the mailbox readonly?
CHECK_ATTACH	Is the user in message-attach mode?

Definition at line 87 of file lib.h.

{
  CHECK_NONE       =       0,  
  CHECK_IN_MAILBOX = 1U << 0,  
  CHECK_MSGCOUNT   = 1U << 1,  
  CHECK_VISIBLE    = 1U << 2,  
  CHECK_READONLY   = 1U << 3,  
  CHECK_ATTACH     = 1U << 4,  
};

CollapseMode

enum CollapseMode

Action to perform on a Thread.

Enumerator
COLLAPSE_MODE_TOGGLE	Toggle collapsed state.
COLLAPSE_MODE_CLOSE	Collapse all threads.
COLLAPSE_MODE_OPEN	Open all threads.

Definition at line 101 of file lib.h.

{
  COLLAPSE_MODE_TOGGLE, 
  COLLAPSE_MODE_CLOSE,  
  COLLAPSE_MODE_OPEN,   
};

Function Documentation

index_init_keys()

void index_init_keys	(	struct NeoMutt *	n,
		struct SubMenu *	sm_generic )

Initialise the Index Keybindings - Implements ::init_keys_api.

Definition at line 332 of file functions.c.

{
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm_index = NULL;
  struct SubMenu *sm_sidebar = sidebar_get_submenu();
 
  sm_index = km_register_submenu(OpIndex);
  md = km_register_menu(MENU_INDEX, "index");
  km_menu_add_submenu(md, sm_index);
  km_menu_add_submenu(md, sm_sidebar);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, IndexDefaultBindings);
 
  struct IndexModuleData *mod_data = neomutt_get_module_data(n, MODULE_ID_INDEX);
  ASSERT(mod_data);
  mod_data->md_index = md;
  mod_data->sm_index = sm_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

change_folder_mailbox()

void change_folder_mailbox	(	struct Menu *	menu,
		struct Mailbox *	m,
		int *	oldcount,
		struct IndexSharedData *	shared,
		bool	read_only )

Change to a different Mailbox by pointer.

Parameters

menu	Current Menu
m	Mailbox
oldcount	How many items are currently in the index
shared	Shared Index data
read_only	Open Mailbox in read-only mode

Definition at line 631 of file dlg_index.c.

{
  if (!m)
    return;
 
  /* keepalive failure in mutt_enter_fname may kill connection. */
  if (shared->mailbox && (buf_is_empty(&shared->mailbox->pathbuf)))
  {
    mview_free(&shared->mailbox_view);
    mailbox_free(&shared->mailbox);
  }
 
  if (shared->mailbox)
  {
    char *new_last_folder = NULL;
#ifdef USE_INOTIFY
    int monitor_remove_rc = mutt_monitor_remove(NULL);
#endif
    if (shared->mailbox->compress_info && (shared->mailbox->realpath[0] != '\0'))
      new_last_folder = mutt_str_dup(shared->mailbox->realpath);
    else
      new_last_folder = mutt_str_dup(mailbox_path(shared->mailbox));
    *oldcount = shared->mailbox->msg_count;
 
    const enum MxStatus check = mx_mbox_close(shared->mailbox);
    if (check == MX_STATUS_OK)
    {
      mview_free(&shared->mailbox_view);
      if (shared->mailbox != m)
      {
        mailbox_free(&shared->mailbox);
      }
    }
    else
    {
#ifdef USE_INOTIFY
      if (monitor_remove_rc == 0)
        mutt_monitor_add(NULL);
#endif
      if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
        update_index(menu, shared->mailbox_view, check, *oldcount, shared);
 
      FREE(&new_last_folder);
      mutt_pattern_free(&shared->search_state->pattern);
      menu_queue_redraw(menu, MENU_REDRAW_INDEX);
      return;
    }
    FREE(&LastFolder);
    LastFolder = new_last_folder;
  }
  mutt_str_replace(&CurrentFolder, mailbox_path(m));
 
  /* If the `folder-hook` were to call `unmailboxes`, then the Mailbox (`m`)
   * could be deleted, leaving `m` dangling. */
  // TODO: Refactor this function to avoid the need for an observer
  notify_observer_add(m->notify, NT_MAILBOX, index_mailbox_observer, &m);
  char *dup_path = mutt_str_dup(mailbox_path(m));
  char *dup_name = mutt_str_dup(m->name);
 
  exec_folder_hook(dup_path, dup_name);
  if (m)
  {
    /* `m` is still valid, but we won't need the observer again before the end
     * of the function. */
    notify_observer_remove(m->notify, index_mailbox_observer, &m);
  }
  else
  {
    // Recreate the Mailbox as the folder-hook might have invoked `mailboxes`
    // and/or `unmailboxes`.
    m = mx_path_resolve(dup_path);
  }
 
  FREE(&dup_path);
  FREE(&dup_name);
 
  if (!m)
    return;
 
  const OpenMailboxFlags flags = read_only ? MUTT_READONLY : MUTT_OPEN_NONE;
  if (mx_mbox_open(m, flags))
  {
    struct MailboxView *mv = mview_new(m, NeoMutt->notify);
    index_shared_data_set_mview(shared, mv);
 
    menu->max = m->msg_count;
    menu_set_index(menu, find_first_message(shared->mailbox_view));
#ifdef USE_INOTIFY
    mutt_monitor_add(NULL);
#endif
  }
  else
  {
    index_shared_data_set_mview(shared, NULL);
    menu_set_index(menu, 0);
  }
 
  const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
  if (mutt_using_threads() && c_collapse_all)
    collapse_all(shared->mailbox_view, menu, COLLAPSE_MODE_CLOSE);
 
  mutt_clear_error();
  /* force the mailbox check after we have changed the folder */
  struct EventMailbox ev_m = { shared->mailbox };
  mutt_mailbox_check(ev_m.mailbox, MUTT_MAILBOX_CHECK_POSTPONED);
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  mutt_pattern_free(&shared->search_state->pattern);
}

Here is the call graph for this function:

Here is the caller graph for this function:

change_folder_notmuch()

struct Mailbox * change_folder_notmuch	(	struct Menu *	menu,
		char *	buf,
		int	buflen,
		int *	oldcount,
		struct IndexSharedData *	shared,
		bool	read_only )

Change to a different Notmuch Mailbox by string.

Parameters

menu	Current Menu
buf	Folder to change to
buflen	Length of buffer
oldcount	How many items are currently in the index
shared	Shared Index data
read_only	Open Mailbox in read-only mode

Return values

ptr

Mailbox

Definition at line 752 of file dlg_index.c.

{
  if (!nm_url_from_query(NULL, buf, buflen))
  {
    mutt_message(_("Failed to create query, aborting"));
    return NULL;
  }
 
  struct Mailbox *m_query = mx_path_resolve(buf);
  change_folder_mailbox(menu, m_query, oldcount, shared, read_only);
  if (!shared->mailbox_view)
    mailbox_free(&m_query);
  return m_query;
}

Here is the call graph for this function:

Here is the caller graph for this function:

change_folder_string()

void change_folder_string	(	struct Menu *	menu,
		struct Buffer *	buf,
		int *	oldcount,
		struct IndexSharedData *	shared,
		bool	read_only )

Change to a different Mailbox by string.

Parameters

menu	Current Menu
buf	Folder to change to
oldcount	How many items are currently in the index
shared	Shared Index data
read_only	Open Mailbox in read-only mode

Definition at line 777 of file dlg_index.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  if (OptNews)
  {
    OptNews = false;
    nntp_expand_path(buf->data, buf->dsize, &mod_data->current_news_srv->conn->account);
  }
  else
  {
    const char *const c_folder = cs_subset_string(shared->sub, "folder");
    mx_path_canon(buf, c_folder, NULL);
  }
 
  enum MailboxType type = mx_path_probe(buf_string(buf));
  if ((type == MUTT_MAILBOX_ERROR) || (type == MUTT_UNKNOWN))
  {
    // Look for a Mailbox by its description, before failing
    struct Mailbox *m = mailbox_find_name(buf_string(buf));
    if (m)
    {
      change_folder_mailbox(menu, m, oldcount, shared, read_only);
    }
    else
    {
      mutt_error(_("%s is not a mailbox"), buf_string(buf));
    }
    return;
  }
 
  struct Mailbox *m = mx_path_resolve(buf_string(buf));
  change_folder_mailbox(menu, m, oldcount, shared, read_only);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_acl()

bool check_acl	(	struct Mailbox *	m,
		AclFlags	acl,
		const char *	msg )

Check the ACLs for a function.

Parameters

m	Mailbox
acl	ACL, see AclFlags
msg	Error message for failure

Return values

true	The function is permitted

Definition at line 137 of file dlg_index.c.

{
  if (!m)
    return false;
 
  if (!(m->rights & acl))
  {
    /* L10N: %s is one of the CHECK_ACL entries below. */
    mutt_error(_("%s: Operation not permitted by ACL"), msg);
    return false;
  }
 
  return true;
}

Here is the caller graph for this function:

collapse_all()

void collapse_all	(	struct MailboxView *	mv,
		struct Menu *	menu,
		enum CollapseMode	mode )

Collapse/uncollapse all threads.

Parameters

mv	Mailbox View
menu	Current menu
mode	Collapse mode

This function is called by OP_MAIN_COLLAPSE_ALL, by the one-way open/close commands, and on folder enter if the $collapse_all option is set.

Definition at line 161 of file dlg_index.c.

{
  if (!mv || !mv->mailbox || (mv->mailbox->msg_count == 0) || !menu)
    return;
 
  struct Email *e_cur = mutt_get_virt_email(mv->mailbox, menu_get_index(menu));
  if (!e_cur)
    return;
 
  int final = -1;
 
  /* Figure out what the current message would be after folding / unfolding,
   * so that we can restore the cursor in a sane way afterwards. */
  switch (mode)
  {
    case COLLAPSE_MODE_TOGGLE:
      if (e_cur->collapsed)
        final = mutt_uncollapse_thread(e_cur);
      else if (mutt_thread_can_collapse(e_cur))
        final = mutt_collapse_thread(e_cur);
      else
        final = e_cur->vnum;
      break;
 
    case COLLAPSE_MODE_CLOSE:
      if (mutt_thread_can_collapse(e_cur))
        final = mutt_collapse_thread(e_cur);
      else
        final = e_cur->vnum;
      break;
 
    case COLLAPSE_MODE_OPEN:
      if (e_cur->collapsed)
        final = mutt_uncollapse_thread(e_cur);
      else
        final = e_cur->vnum;
      break;
  }
 
  if (final == -1)
    return;
 
  struct Email *base = mutt_get_virt_email(mv->mailbox, final);
  if (!base)
    return;
 
  /* Iterate all threads, perform collapse/uncollapse as needed */
  if (mode == COLLAPSE_MODE_TOGGLE)
    mv->collapsed = !mv->collapsed;
  else
    mv->collapsed = (mode == COLLAPSE_MODE_CLOSE);
  mutt_thread_collapse(mv->threads, mv->collapsed);
 
  /* Restore the cursor */
  mutt_set_vnum(mv->mailbox);
  menu->max = mv->mailbox->vcount;
  for (int i = 0; i < mv->mailbox->vcount; i++)
  {
    struct Email *e = mutt_get_virt_email(mv->mailbox, i);
    if (!e)
      break;
    if (e->index == base->index)
    {
      menu_set_index(menu, i);
      break;
    }
  }
 
  menu_queue_redraw(menu, MENU_REDRAW_INDEX);
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_first_message()

int find_first_message

(

struct MailboxView *

mv

)

Get index of first new message.

Parameters

mv	Mailbox view

Return values

num	Index of first new message

Return the index of the first new message, or failing that, the first unread message.

Definition at line 327 of file dlg_index.c.

{
  if (!mv)
    return 0;
 
  struct Mailbox *m = mv->mailbox;
  if (!m || (m->msg_count == 0))
    return 0;
 
  int old = -1;
  for (int i = 0; i < m->vcount; i++)
  {
    struct Email *e = mutt_get_virt_email(m, i);
    if (!e)
      continue;
    if (!e->read && !e->deleted)
    {
      if (!e->old)
        return i;
      if (old == -1)
        old = i;
    }
  }
  if (old != -1)
    return old;
 
  /* If `$use_threads` is not threaded and `$sort` is reverse, the latest
   * message is first.  Otherwise, the latest message is first if exactly
   * one of `$use_threads` and `$sort` are reverse.
   */
  enum EmailSortType c_sort = cs_subset_sort(m->sub, "sort");
  if ((c_sort & SORT_MASK) == EMAIL_SORT_THREADS)
    c_sort = cs_subset_sort(m->sub, "sort_aux");
  bool reverse = false;
  switch (mutt_thread_style())
  {
    case UT_FLAT:
      reverse = c_sort & SORT_REVERSE;
      break;
    case UT_THREADS:
      reverse = c_sort & SORT_REVERSE;
      break;
    case UT_REVERSE:
      reverse = !(c_sort & SORT_REVERSE);
      break;
    default:
      ASSERT(false);
  }
 
  if (reverse || (m->vcount == 0))
    return 0;
 
  return m->vcount - 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_next_undeleted()

int find_next_undeleted	(	struct MailboxView *	mv,
		int	msgno,
		bool	uncollapse )

Find the next undeleted email.

Parameters

mv	Mailbox view
msgno	Message number to start at
uncollapse	Open collapsed threads

Return values

>=0	Message number of next undeleted email
-1	No more undeleted messages

Definition at line 259 of file dlg_index.c.

{
  if (!mv || !mv->mailbox)
    return -1;
 
  struct Mailbox *m = mv->mailbox;
 
  int index = -1;
  for (int i = msgno + 1; i < m->vcount; i++)
  {
    struct Email *e = mutt_get_virt_email(m, i);
    if (!e)
      continue;
    if (!e->deleted)
    {
      index = i;
      break;
    }
  }
 
  if (uncollapse)
    uncollapse_thread(mv, index);
 
  return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_previous_undeleted()

int find_previous_undeleted	(	struct MailboxView *	mv,
		int	msgno,
		bool	uncollapse )

Find the previous undeleted email.

Parameters

mv	Mailbox View
msgno	Message number to start at
uncollapse	Open collapsed threads

Return values

>=0	Message number of next undeleted email
-1	No more undeleted messages

Definition at line 293 of file dlg_index.c.

{
  if (!mv || !mv->mailbox)
    return -1;
 
  struct Mailbox *m = mv->mailbox;
 
  int index = -1;
  for (int i = msgno - 1; i >= 0; i--)
  {
    struct Email *e = mutt_get_virt_email(m, i);
    if (!e)
      continue;
    if (!e->deleted)
    {
      index = i;
      break;
    }
  }
 
  if (uncollapse)
    uncollapse_thread(mv, index);
 
  return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_mailbox()

struct Mailbox * get_current_mailbox

(

void

)

Get the current Mailbox.

Return values

ptr	Current Mailbox

Search for the last (most recent) dialog that has an Index. Then return the Mailbox from its shared data.

Definition at line 725 of file index.c.

{
  struct MailboxView *mv = get_current_mailbox_view();
  if (mv)
    return mv->mailbox;
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_mailbox_view()

struct MailboxView * get_current_mailbox_view

(

void

)

Get the current Mailbox view.

Return values

ptr	Current Mailbox view

Search for the last (most recent) dialog that has an Index. Then return the Mailbox from its shared data.

Definition at line 692 of file index.c.

{
  struct GuiModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
  if (!mod_data || !mod_data->all_dialogs_window)
    return NULL;
 
  struct MuttWindow **wp = NULL;
  ARRAY_FOREACH_REVERSE(wp, &mod_data->all_dialogs_window->children)
  {
    struct MuttWindow *win = window_find_child(*wp, WT_DLG_INDEX);
    if (win)
    {
      struct IndexSharedData *shared = win->wdata;
      return shared->mailbox_view;
    }
 
    win = window_find_child(*wp, WT_DLG_POSTPONE);
    if (win)
    {
      return postpone_get_mailbox_view(win);
    }
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_change_folder()

void index_change_folder	(	struct MuttWindow *	dlg,
		struct Mailbox *	m )

Change the current folder, cautiously.

Parameters

dlg	Dialog holding the Index
m	Mailbox to change to

Definition at line 1490 of file dlg_index.c.

{
  if (!dlg || !m)
    return;
 
  struct IndexSharedData *shared = dlg->wdata;
  if (!shared)
    return;
 
  struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
  if (!panel_index)
    return;
 
  struct IndexPrivateData *priv = panel_index->wdata;
  if (!priv)
    return;
 
  change_folder_mailbox(priv->menu, m, &priv->oldcount, shared, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_pager_init()

struct MuttWindow * index_pager_init

(

void

)

Allocate the Windows for the Index/Pager.

Return values

ptr	Dialog containing nested Windows

Definition at line 1462 of file dlg_index.c.

{
  struct MuttWindow *dlg = mutt_window_new(WT_DLG_INDEX, MUTT_WIN_ORIENT_HORIZONTAL,
                                           MUTT_WIN_SIZE_MAXIMISE, MUTT_WIN_SIZE_UNLIMITED,
                                           MUTT_WIN_SIZE_UNLIMITED);
 
  struct IndexSharedData *shared = index_shared_data_new();
  notify_set_parent(shared->notify, dlg->notify);
 
  dlg->wdata = shared;
  dlg->wdata_free = index_shared_data_free;
 
  const bool c_status_on_top = cs_subset_bool(NeoMutt->sub, "status_on_top");
 
  struct MuttWindow *panel_index = ipanel_new(c_status_on_top, shared);
  struct MuttWindow *panel_pager = ppanel_new(c_status_on_top, shared);
 
  mutt_window_add_child(dlg, panel_index);
  mutt_window_add_child(dlg, panel_pager);
 
  return dlg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_dlgindex_observer()

int mutt_dlgindex_observer

(

struct NotifyCallback *

nc

)

mutt_draw_statusline()

void mutt_draw_statusline	(	struct MuttWindow *	win,
		int	max_cols,
		const char *	buf,
		size_t	buflen )

Draw a highlighted status bar.

Parameters

win	Window
max_cols	Maximum number of screen columns
buf	Message to be displayed
buflen	Length of the buffer

Users configure the highlighting of the status bar, e.g. color status red default "[0-9][0-9]:[0-9][0-9]"

Where regexes overlap, the one nearest the start will be used. If two regexes start at the same place, the longer match will be used.

Colours of the status bar

< Colour attribute

< First character of that colour

< Last character of that colour

Definition at line 980 of file dlg_index.c.

{
  if (!buf || !stdscr)
    return;
 
  size_t i = 0;
  size_t offset = 0;
  bool found = false;
  size_t chunks = 0;
  size_t len = 0;

  struct StatusSyntax
  {
    const struct AttrColor *attr_color; 
    int first;                          
    int last;                           
  } *syntax = NULL;
 
  const struct AttrColor *ac_base = merged_color_overlay(simple_color_get(MT_COLOR_NORMAL),
                                                         simple_color_get(MT_COLOR_STATUS));
  do
  {
    struct RegexColor *cl = NULL;
    found = false;
 
    if (!buf[offset])
      break;
 
    /* loop through each "color status regex" */
    STAILQ_FOREACH(cl, regex_colors_get_list(MT_COLOR_STATUS), entries)
    {
      regmatch_t pmatch[cl->match + 1];
      memset(pmatch, 0, (cl->match + 1) * sizeof(regmatch_t));
 
      if (regexec(&cl->regex, buf + offset, cl->match + 1, pmatch, 0) != 0)
        continue; /* regex doesn't match the status bar */
 
      int first = pmatch[cl->match].rm_so + offset;
      int last = pmatch[cl->match].rm_eo + offset;
 
      if (first == last)
        continue; /* ignore an empty regex */
 
      if (!found)
      {
        chunks++;
        MUTT_MEM_REALLOC(&syntax, chunks, struct StatusSyntax);
      }
 
      i = chunks - 1;
      if (!found || (first < syntax[i].first) ||
          ((first == syntax[i].first) && (last > syntax[i].last)))
      {
        const struct AttrColor *ac_merge = merged_color_overlay(ac_base, &cl->attr_color);
 
        syntax[i].attr_color = ac_merge;
        syntax[i].first = first;
        syntax[i].last = last;
      }
      found = true;
    }
 
    if (syntax)
    {
      offset = syntax[i].last;
    }
  } while (found);
 
  /* Only 'len' bytes will fit into 'max_cols' screen columns */
  len = mutt_wstr_trunc(buf, buflen, max_cols, NULL);
 
  offset = 0;
 
  if ((chunks > 0) && (syntax[0].first > 0))
  {
    /* Text before the first highlight */
    mutt_window_addnstr(win, buf, MIN(len, syntax[0].first));
    mutt_curses_set_color(ac_base);
    if (len <= syntax[0].first)
      goto dsl_finish; /* no more room */
 
    offset = syntax[0].first;
  }
 
  for (i = 0; i < chunks; i++)
  {
    /* Highlighted text */
    mutt_curses_set_color(syntax[i].attr_color);
    mutt_window_addnstr(win, buf + offset, MIN(len, syntax[i].last) - offset);
    if (len <= syntax[i].last)
      goto dsl_finish; /* no more room */
 
    size_t next;
    if ((i + 1) == chunks)
    {
      next = len;
    }
    else
    {
      next = MIN(len, syntax[i + 1].first);
    }
 
    mutt_curses_set_color(ac_base);
    offset = syntax[i].last;
    mutt_window_addnstr(win, buf + offset, next - offset);
 
    offset = next;
    if (offset >= len)
      goto dsl_finish; /* no more room */
  }
 
  mutt_curses_set_color(ac_base);
  if (offset < len)
  {
    /* Text after the last highlight */
    mutt_window_addnstr(win, buf + offset, len - offset);
  }
 
  int width = mutt_strwidth(buf);
  if (width < max_cols)
  {
    /* Pad the rest of the line with whitespace */
    mutt_paddstr(win, max_cols - width, "");
  }
dsl_finish:
  FREE(&syntax);
}

Here is the call graph for this function:

Here is the caller graph for this function:

email_set_color()

void email_set_color	(	struct Mailbox *	m,
		struct Email *	e )

Select an Index colour for an Email.

Parameters

m	Mailbox
e	Current Email

Calculate the colour for an Email in the Index. Cache the colour in the Email.

Definition at line 1431 of file dlg_index.c.

{
  if (!e)
    return;
 
  struct RegexColor *color = NULL;
  struct PatternCache cache = { 0 };
 
  const struct AttrColor *ac_merge = NULL;
  STAILQ_FOREACH(color, regex_colors_get_list(MT_COLOR_INDEX), entries)
  {
    if (mutt_pattern_exec(SLIST_FIRST(color->color_pattern),
                          MUTT_MATCH_FULL_ADDRESS, m, e, &cache))
    {
      ac_merge = merged_color_overlay(ac_merge, &color->attr_color);
    }
  }
 
  struct AttrColor *ac_normal = simple_color_get(MT_COLOR_NORMAL);
  if (ac_merge)
    ac_merge = merged_color_overlay(ac_normal, ac_merge);
  else
    ac_merge = ac_normal;
 
  e->attr_color = ac_merge;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resort_index()

void resort_index	(	struct MailboxView *	mv,
		struct Menu *	menu )

Resort the index.

Parameters

mv	Mailbox View
menu	Current Menu

Definition at line 387 of file dlg_index.c.

{
  if (!mv || !mv->mailbox || !menu)
    return;
 
  struct Mailbox *m = mv->mailbox;
  const int old_index = menu_get_index(menu);
  struct Email *e_cur = mutt_get_virt_email(m, old_index);
 
  int new_index = -1;
  mutt_sort_headers(mv, false);
 
  /* Restore the current message */
  for (int i = 0; i < m->vcount; i++)
  {
    struct Email *e = mutt_get_virt_email(m, i);
    if (!e)
      continue;
    if (e == e_cur)
    {
      new_index = i;
      break;
    }
  }
 
  if (mutt_using_threads() && (old_index < 0))
    new_index = mutt_parent_message(e_cur, false, 1);
 
  if (old_index < 0)
    new_index = find_first_message(mv);
 
  menu->max = m->vcount;
  menu_set_index(menu, new_index);
  menu_queue_redraw(menu, MENU_REDRAW_INDEX);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_index()

void update_index	(	struct Menu *	menu,
		struct MailboxView *	mv,
		enum MxStatus	check,
		int	oldcount,
		const struct IndexSharedData *	shared )

Update the index.

Parameters

menu	Current Menu
mv	Mailbox
check	Flags, e.g. MX_STATUS_REOPENED
oldcount	How many items are currently in the index
shared	Shared Index data

Definition at line 562 of file dlg_index.c.

{
  if (!menu || !mv)
    return;
 
  struct Mailbox *m = mv->mailbox;
  if (mutt_using_threads())
    update_index_threaded(mv, check, oldcount);
  else
    update_index_unthreaded(mv, check);
 
  menu->max = m->vcount;
  const int old_index = menu_get_index(menu);
  int index = -1;
  if (oldcount)
  {
    /* restore the current message to the message it was pointing to */
    for (int i = 0; i < m->vcount; i++)
    {
      struct Email *e = mutt_get_virt_email(m, i);
      if (!e)
        continue;
      if (index_shared_data_is_cur_email(shared, e))
      {
        index = i;
        break;
      }
    }
  }
 
  if (index < 0)
  {
    index = (old_index < m->vcount) ? old_index : find_first_message(mv);
  }
  menu_set_index(menu, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_make_string()

int mutt_make_string	(	struct Buffer *	buf,
		size_t	max_cols,
		const struct Expando *	exp,
		struct Mailbox *	m,
		int	inpgr,
		struct Email *	e,
		MuttFormatFlags	flags,
		const char *	progress )

Create formatted strings using mailbox expandos.

Parameters

buf	Buffer for the result
max_cols	Number of screen columns (-1 means unlimited)
exp	Expando containing expando tree
m	Mailbox
inpgr	Message shown in the pager
e	Email
flags	Flags, see MuttFormatFlags
progress	Pager progress string

Return values

num	Number of screen columns used

Definition at line 824 of file dlg_index.c.

{
  if (!exp)
    return 0;
 
  struct EmailFormatInfo efi = { 0 };
 
  efi.email = e;
  efi.mailbox = m;
  efi.msg_in_pager = inpgr;
  efi.pager_progress = progress;
 
  return expando_filter(exp, IndexRenderCallbacks, &efi, flags, max_cols,
                        NeoMutt->env, buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

IndexNewsHelp

const struct Mapping IndexNewsHelp[]

extern

Help Bar for the News Index dialog.

Definition at line 116 of file dlg_index.c.

                                     {
  // clang-format off
  { N_("Quit"),     OP_QUIT },
  { N_("Del"),      OP_DELETE },
  { N_("Undel"),    OP_UNDELETE },
  { N_("Save"),     OP_SAVE },
  { N_("Post"),     OP_POST },
  { N_("Followup"), OP_FOLLOWUP },
  { N_("Catchup"),  OP_CATCHUP },
  { N_("Help"),     OP_HELP },
  { NULL, 0 },
  // clang-format on
};

StatusFormatDef

const struct ExpandoDefinition StatusFormatDef[]

extern

Expando definitions.

Config:

• $new_mail_command
• $status_format
• $ts_icon_format
• $ts_status_format

Definition at line 49 of file config.c.

                                                 {
  // clang-format off
  { "*", "padding-soft",     ED_GLOBAL, ED_GLO_PADDING_SOFT,       node_padding_parse },
  { ">", "padding-hard",     ED_GLOBAL, ED_GLO_PADDING_HARD,       node_padding_parse },
  { "|", "padding-eol",      ED_GLOBAL, ED_GLO_PADDING_EOL,        node_padding_parse },
  { "b", "unread-mailboxes", ED_INDEX,  ED_IND_UNREAD_MAILBOXES,   NULL },
  { "d", "deleted-count",    ED_INDEX,  ED_IND_DELETED_COUNT,      NULL },
  { "D", "description",      ED_INDEX,  ED_IND_DESCRIPTION,        NULL },
  { "f", "mailbox-path",     ED_INDEX,  ED_IND_MAILBOX_PATH,       NULL },
  { "F", "flagged-count",    ED_INDEX,  ED_IND_FLAGGED_COUNT,      NULL },
  { "h", "hostname",         ED_GLOBAL, ED_GLO_HOSTNAME,           NULL },
  { "l", "mailbox-size",     ED_INDEX,  ED_IND_MAILBOX_SIZE,       NULL },
  { "L", "limit-size",       ED_INDEX,  ED_IND_LIMIT_SIZE,         NULL },
  { "m", "message-count",    ED_INDEX,  ED_IND_MESSAGE_COUNT,      NULL },
  { "M", "limit-count",      ED_INDEX,  ED_IND_LIMIT_COUNT,        NULL },
  { "n", "new-count",        ED_INDEX,  ED_IND_NEW_COUNT,          NULL },
  { "o", "old-count",        ED_INDEX,  ED_IND_OLD_COUNT,          NULL },
  { "p", "postponed-count",  ED_INDEX,  ED_IND_POSTPONED_COUNT,    NULL },
  { "P", "percentage",       ED_MENU,   ED_MEN_PERCENTAGE,         NULL },
  { "r", "readonly",         ED_INDEX,  ED_IND_READONLY,           NULL },
  { "R", "read-count",       ED_INDEX,  ED_IND_READ_COUNT,         NULL },
  { "s", "sort",             ED_GLOBAL, ED_GLO_CONFIG_SORT,        NULL },
  { "S", "sort-aux",         ED_GLOBAL, ED_GLO_CONFIG_SORT_AUX,    NULL },
  { "t", "tagged-count",     ED_INDEX,  ED_IND_TAGGED_COUNT,       NULL },
  { "T", "use-threads",      ED_GLOBAL, ED_GLO_CONFIG_USE_THREADS, NULL },
  { "u", "unread-count",     ED_INDEX,  ED_IND_UNREAD_COUNT,       NULL },
  { "v", "version",          ED_GLOBAL, ED_GLO_VERSION,            NULL },
  { "V", "limit-pattern",    ED_INDEX,  ED_IND_LIMIT_PATTERN,      NULL },
  { NULL, NULL, 0, -1, NULL }
  // clang-format on
};