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 "functions.h"
#include "shared_data.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.

Macros
#define	NT_INDEX_NO_FLAGS   0
	No flags are set.
#define	NT_INDEX_ADD   (1 << 0)
	New Index Shared Data has been created.
#define	NT_INDEX_DELETE   (1 << 1)
	Index Shared Data is about to be freed.
#define	NT_INDEX_SUBSET   (1 << 2)
	Config Subset has changed.
#define	NT_INDEX_ACCOUNT   (1 << 3)
	Account has changed.
#define	NT_INDEX_MVIEW   (1 << 4)
	MailboxView has changed.
#define	NT_INDEX_MAILBOX   (1 << 5)
	Mailbox has changed.
#define	NT_INDEX_EMAIL   (1 << 6)
	Email has changed.
#define	CHECK_NO_FLAGS   0
	No flags are set.
#define	CHECK_IN_MAILBOX   (1 << 0)
	Is there a mailbox open?
#define	CHECK_MSGCOUNT   (1 << 1)
	Are there any messages?
#define	CHECK_VISIBLE   (1 << 2)
	Is the selected message visible in the index?
#define	CHECK_READONLY   (1 << 3)
	Is the mailbox readonly?
#define	CHECK_ATTACH   (1 << 4)
	Is the user in message-attach mode?

Typedefs
typedef uint8_t	NotifyIndex
	Flags, e.g. NT_INDEX_ACCOUNT.
typedef uint8_t	CheckFlags
	Flags, e.g. CHECK_IN_MAILBOX.

Functions
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, int toggle)
	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.
struct Menu *	get_current_menu (void)
	Get the current Menu.
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	mutt_set_header_color (struct Mailbox *m, struct Email *e)
	Select a colour for a message.
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.

Variables
const struct Mapping	IndexNewsHelp []
	Help Bar for the News Index dialog.

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.

Macro Definition Documentation

NT_INDEX_NO_FLAGS

#define NT_INDEX_NO_FLAGS   0

No flags are set.

Definition at line 58 of file lib.h.

NT_INDEX_ADD

#define NT_INDEX_ADD   (1 << 0)

New Index Shared Data has been created.

Definition at line 59 of file lib.h.

NT_INDEX_DELETE

#define NT_INDEX_DELETE   (1 << 1)

Index Shared Data is about to be freed.

Definition at line 60 of file lib.h.

NT_INDEX_SUBSET

#define NT_INDEX_SUBSET   (1 << 2)

Config Subset has changed.

Definition at line 61 of file lib.h.

NT_INDEX_ACCOUNT

#define NT_INDEX_ACCOUNT   (1 << 3)

Account has changed.

Definition at line 62 of file lib.h.

NT_INDEX_MVIEW

#define NT_INDEX_MVIEW   (1 << 4)

MailboxView has changed.

Definition at line 63 of file lib.h.

NT_INDEX_MAILBOX

#define NT_INDEX_MAILBOX   (1 << 5)

Mailbox has changed.

Definition at line 64 of file lib.h.

NT_INDEX_EMAIL

#define NT_INDEX_EMAIL   (1 << 6)

Email has changed.

Definition at line 65 of file lib.h.

CHECK_NO_FLAGS

#define CHECK_NO_FLAGS   0

No flags are set.

Definition at line 68 of file lib.h.

CHECK_IN_MAILBOX

#define CHECK_IN_MAILBOX   (1 << 0)

Is there a mailbox open?

Definition at line 69 of file lib.h.

CHECK_MSGCOUNT

#define CHECK_MSGCOUNT   (1 << 1)

Are there any messages?

Definition at line 70 of file lib.h.

CHECK_VISIBLE

#define CHECK_VISIBLE   (1 << 2)

Is the selected message visible in the index?

Definition at line 71 of file lib.h.

CHECK_READONLY

#define CHECK_READONLY   (1 << 3)

Is the mailbox readonly?

Definition at line 72 of file lib.h.

CHECK_ATTACH

#define CHECK_ATTACH   (1 << 4)

Is the user in message-attach mode?

Definition at line 73 of file lib.h.

Typedef Documentation

NotifyIndex

typedef uint8_t NotifyIndex

Flags, e.g. NT_INDEX_ACCOUNT.

Definition at line 57 of file lib.h.

CheckFlags

typedef uint8_t CheckFlags

Flags, e.g. CHECK_IN_MAILBOX.

Definition at line 67 of file lib.h.

Function Documentation

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 612 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);
 
  mutt_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_NO_FLAGS;
  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, 0);
 
  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 733 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 758 of file dlg_index.c.

{
  if (OptNews)
  {
    OptNews = false;
    nntp_expand_path(buf->data, buf->dsize, &CurrentNewsSrv->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 139 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,
		int	toggle
	)

Collapse/uncollapse all threads.

Parameters

mv	Mailbox View
menu	current menu
toggle	toggle collapsed state

This function is called by the OP_MAIN_COLLAPSE_ALL command and on folder enter if the $collapse_all option is set. In the first case, the toggle parameter is 1 to actually toggle collapsed/uncollapsed state on all threads. In the second case, the toggle parameter is 0, actually turning this function into a one-way collapse.

Definition at line 166 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;
 
  /* Figure out what the current message would be after folding / unfolding,
   * so that we can restore the cursor in a sane way afterwards. */
  if (e_cur->collapsed && toggle)
    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;
 
  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 */
  mv->collapsed = toggle ? !mv->collapsed : true;
  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 310 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 SortType c_sort = cs_subset_sort(m->sub, "sort");
  if ((c_sort & SORT_MASK) == 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 242 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 276 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 715 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 683 of file index.c.

{
  if (!AllDialogsWindow)
    return NULL;
 
  struct MuttWindow *np = NULL;
  TAILQ_FOREACH_REVERSE(np, &AllDialogsWindow->children, MuttWindowList, entries)
  {
    struct MuttWindow *win = window_find_child(np, WT_DLG_INDEX);
    if (win)
    {
      struct IndexSharedData *shared = win->wdata;
      return shared->mailbox_view;
    }
 
    win = window_find_child(np, WT_DLG_POSTPONED);
    if (win)
    {
      return postponed_get_mailbox_view(win);
    }
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_menu()

struct Menu * get_current_menu

(

void

)

Get the current Menu.

Return values

ptr	Current Menu

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

Definition at line 731 of file index.c.

{
  if (!AllDialogsWindow)
    return NULL;
 
  struct MuttWindow *np = NULL;
  TAILQ_FOREACH_REVERSE(np, &AllDialogsWindow->children, MuttWindowList, entries)
  {
    struct MuttWindow *dlg = window_find_child(np, WT_DLG_INDEX);
    if (dlg)
    {
      struct MuttWindow *panel_index = window_find_child(dlg, WT_INDEX);
      struct IndexPrivateData *priv = panel_index->wdata;
      return priv->menu;
    }
  }
 
  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 1433 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 1405 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

< First character of that colour

< Last character of that colour

Definition at line 930 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:

mutt_set_header_color()

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

Select a colour for a message.

Parameters

m	Mailbox
e	Current Email

Definition at line 1374 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 370 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);
 
  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 543 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:

Variable Documentation

IndexNewsHelp

const struct Mapping IndexNewsHelp[]

extern

Help Bar for the News Index dialog.

Definition at line 118 of file dlg_index.c.