sidebar.c File Reference

GUI display the mailboxes in a side panel. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "sidebar.h"
#include "context.h"
#include "format_flags.h"
#include "globals.h"
#include "mutt_menu.h"
#include "muttlib.h"
#include "opcodes.h"

Include dependency graph for sidebar.c:

Go to the source code of this file.

Data Structures
struct	SbEntry
	Info about folders in the sidebar. More...

Enumerations
enum	DivType { SB_DIV_USER, SB_DIV_ASCII, SB_DIV_UTF8 }
	Source of the sidebar divider character. More...

Functions
static const char *	sidebar_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, unsigned long data, MuttFormatFlags flags)
	Format a string for the sidebar - Implements format_t. More...
static void	make_sidebar_entry (char *buf, size_t buflen, int width, const char *box, struct SbEntry *sbe)
	Turn mailbox data into a sidebar string. More...
static int	cb_qsort_sbe (const void *a, const void *b)
	qsort callback to sort SbEntry's More...
static void	update_entries_visibility (void)
	Should a sidebar_entry be displayed in the sidebar. More...
static void	unsort_entries (void)
	Restore Entries array order to match Mailbox list order. More...
static void	sort_entries (void)
	Sort Entries array. More...
static bool	select_next (void)
	Selects the next unhidden mailbox. More...
static int	select_next_new (void)
	Selects the next new mailbox. More...
static bool	select_prev (void)
	Selects the previous unhidden mailbox. More...
static bool	select_prev_new (void)
	Selects the previous new mailbox. More...
static int	select_page_down (void)
	Selects the first entry in the next page of mailboxes. More...
static int	select_page_up (void)
	Selects the last entry in the previous page of mailboxes. More...
static bool	prepare_sidebar (int page_size)
	Prepare the list of SbEntry's for the sidebar display. More...
static int	draw_divider (struct MuttWindow *win, int num_rows, int num_cols)
	Draw a line between the sidebar and the rest of neomutt. More...
static void	fill_empty_space (struct MuttWindow *win, int first_row, int num_rows, int div_width, int num_cols)
	Wipe the remaining Sidebar space. More...
static bool	imap_is_prefix (const char *folder, const char *mbox, size_t *plen)
	Check if folder matches the beginning of mbox. More...
static void	draw_sidebar (struct MuttWindow *win, int num_rows, int num_cols, int div_width)
	Write out a list of mailboxes, in a panel. More...
void	mutt_sb_draw (struct MuttWindow *win)
	Completely redraw the sidebar. More...
void	mutt_sb_change_mailbox (int op)
	Change the selected mailbox. More...
struct Mailbox *	mutt_sb_get_highlight (void)
	Get the Mailbox that's highlighted in the sidebar. More...
void	mutt_sb_set_open_mailbox (struct Mailbox *m)
	Set the 'open' Mailbox. More...
void	mutt_sb_notify_mailbox (struct Mailbox *m, bool created)
	The state of a Mailbox is about to change. More...
int	mutt_sb_observer (struct NotifyCallback *nc)
	Listen for config changes affecting the sidebar - Implements observer_t. More...

Variables
short	C_SidebarComponentDepth
	Config: (sidebar) Strip leading path components from sidebar folders. More...
char *	C_SidebarDelimChars
	Config: (sidebar) Characters that separate nested folders. More...
char *	C_SidebarDividerChar
	Config: (sidebar) Character to draw between the sidebar and index. More...
bool	C_SidebarFolderIndent
	Config: (sidebar) Indent nested folders. More...
char *	C_SidebarFormat
	Config: (sidebar) printf-like format string for the sidebar panel. More...
char *	C_SidebarIndentString
	Config: (sidebar) Indent nested folders using this string. More...
bool	C_SidebarNewMailOnly
	Config: (sidebar) Only show folders with new/flagged mail. More...
bool	C_SidebarNonEmptyMailboxOnly
	Config: (sidebar) Only show folders with a non-zero number of mail. More...
bool	C_SidebarNextNewWrap
	Config: (sidebar) Wrap around when searching for the next mailbox with new mail. More...
bool	C_SidebarOnRight
	Config: (sidebar) Display the sidebar on the right. More...
bool	C_SidebarShortPath
	Config: (sidebar) Abbreviate the paths using the C_Folder variable. More...
short	C_SidebarSortMethod
	Config: (sidebar) Method to sort the sidebar. More...
bool	C_SidebarVisible
	Config: (sidebar) Show the sidebar. More...
short	C_SidebarWidth
	Config: (sidebar) Width of the sidebar. More...
static short	PreviousSort = SORT_ORDER
static int	EntryCount = 0
static int	EntryLen = 0
static struct SbEntry **	Entries = NULL
static int	TopIndex = -1
	First mailbox visible in sidebar. More...
static int	OpnIndex = -1
	Current (open) mailbox. More...
static int	HilIndex = -1
	Highlighted mailbox. More...
static int	BotIndex = -1
	Last mailbox visible in sidebar. More...

Detailed Description

GUI display the mailboxes in a side panel.

Authors

• Justin Hibbits
• Thomer M. Gil
• Richard Russon
• Kevin J. McCarthy

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 sidebar.c.

Enumeration Type Documentation

DivType

enum DivType

Source of the sidebar divider character.

Enumerator
SB_DIV_USER	User configured using $sidebar_divider_char.
SB_DIV_ASCII	An ASCII vertical bar (pipe)
SB_DIV_UTF8	A unicode line-drawing character.

Definition at line 91 of file sidebar.c.

{
  SB_DIV_USER,  
  SB_DIV_ASCII, 
  SB_DIV_UTF8,  
};

Function Documentation

sidebar_format_str()

static const char* sidebar_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, unsigned long  data, MuttFormatFlags  flags  )

static

Format a string for the sidebar - Implements format_t.

Expando	Description
%!	'n!' Flagged messages
%B	Name of the mailbox
%D	Description of the mailbox
%d	Number of deleted messages
%F	Number of Flagged messages in the mailbox
%L	Number of messages after limiting
%n	'N' if mailbox has new mail, ' ' (space) otherwise
%N	Number of unread messages in the mailbox
%o	Number of old unread messages in the mailbox
%r	Number of read messages in the mailbox
%S	Size of mailbox (total number of messages)
%t	Number of tagged messages
%Z	Number of new unseen messages in the mailbox

Definition at line 117 of file sidebar.c.

{
  struct SbEntry *sbe = (struct SbEntry *) data;
  char fmt[256];

  if (!sbe || !buf)
    return src;

  buf[0] = '\0'; /* Just in case there's nothing to do */

  struct Mailbox *m = sbe->mailbox;
  if (!m)
    return src;

  bool c = Context && Context->mailbox &&
           (mutt_str_strcmp(Context->mailbox->realpath, m->realpath) == 0);

  bool optional = (flags & MUTT_FORMAT_OPTIONAL);

  switch (op)
  {
    case 'B':
      mutt_format_s(buf, buflen, prec, sbe->box);
      break;

    case 'd':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, c ? Context->mailbox->msg_deleted : 0);
      }
      else if ((c && (Context->mailbox->msg_deleted == 0)) || !c)
        optional = false;
      break;

    case 'D':
      if (sbe->mailbox->name)
        mutt_format_s(buf, buflen, prec, sbe->mailbox->name);
      else
        mutt_format_s(buf, buflen, prec, sbe->box);
      break;

    case 'F':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_flagged);
      }
      else if (m->msg_flagged == 0)
        optional = false;
      break;

    case 'L':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, c ? Context->mailbox->vcount : m->msg_count);
      }
      else if ((c && (Context->mailbox->vcount == m->msg_count)) || !c)
        optional = false;
      break;

    case 'N':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_unread);
      }
      else if (m->msg_unread == 0)
        optional = false;
      break;

    case 'n':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        snprintf(buf, buflen, fmt, m->has_new ? 'N' : ' ');
      }
      else if (m->has_new == false)
        optional = false;
      break;

    case 'o':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_unread - m->msg_new);
      }
      else if ((c && (Context->mailbox->msg_unread - Context->mailbox->msg_new) == 0) || !c)
        optional = false;
      break;

    case 'r':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_count - m->msg_unread);
      }
      else if ((c && (Context->mailbox->msg_count - Context->mailbox->msg_unread) == 0) || !c)
        optional = false;
      break;

    case 'S':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_count);
      }
      else if (m->msg_count == 0)
        optional = false;
      break;

    case 't':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, c ? Context->mailbox->msg_tagged : 0);
      }
      else if ((c && (Context->mailbox->msg_tagged == 0)) || !c)
        optional = false;
      break;

    case 'Z':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_new);
      }
      else if ((c && (Context->mailbox->msg_new) == 0) || !c)
        optional = false;
      break;

    case '!':
      if (m->msg_flagged == 0)
        mutt_format_s(buf, buflen, prec, "");
      else if (m->msg_flagged == 1)
        mutt_format_s(buf, buflen, prec, "!");
      else if (m->msg_flagged == 2)
        mutt_format_s(buf, buflen, prec, "!!");
      else
      {
        snprintf(fmt, sizeof(fmt), "%d!", m->msg_flagged);
        mutt_format_s(buf, buflen, prec, fmt);
      }
      break;
  }

  if (optional)
  {
    mutt_expando_format(buf, buflen, col, C_SidebarWidth, if_str,
                        sidebar_format_str, (unsigned long) sbe, flags);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, C_SidebarWidth, else_str,
                        sidebar_format_str, (unsigned long) sbe, flags);
  }

  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_sidebar_entry()

static void make_sidebar_entry ( char *  buf, size_t  buflen, int  width, const char *  box, struct SbEntry *  sbe  )

static

Turn mailbox data into a sidebar string.

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	width	Desired width in screen cells
[in]	box	Mailbox name
[in]	sbe	Mailbox object

Take all the relevant mailbox data and the desired screen width and then get mutt_expando_format to do the actual work. mutt_expando_format will callback to us using sidebar_format_str() for the sidebar specific formatting characters.

Definition at line 294 of file sidebar.c.

{
  if (!buf || !box || !sbe)
    return;

  mutt_str_strfcpy(sbe->box, box, sizeof(sbe->box));

  mutt_expando_format(buf, buflen, 0, width, NONULL(C_SidebarFormat),
                      sidebar_format_str, (unsigned long) sbe, MUTT_FORMAT_NO_FLAGS);

  /* Force string to be exactly the right width */
  int w = mutt_strwidth(buf);
  int s = mutt_str_strlen(buf);
  width = MIN(buflen, width);
  if (w < width)
  {
    /* Pad with spaces */
    memset(buf + s, ' ', width - w);
    buf[s + width - w] = '\0';
  }
  else if (w > width)
  {
    /* Truncate to fit */
    size_t len = mutt_wstr_trunc(buf, buflen, width, NULL);
    buf[len] = '\0';
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cb_qsort_sbe()

static int cb_qsort_sbe ( const void *  a, const void *  b  )

static

qsort callback to sort SbEntry's

Parameters

a	First SbEntry to compare
b	Second SbEntry to compare

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 331 of file sidebar.c.

{
  const struct SbEntry *sbe1 = *(struct SbEntry const *const *) a;
  const struct SbEntry *sbe2 = *(struct SbEntry const *const *) b;
  const struct Mailbox *m1 = sbe1->mailbox;
  const struct Mailbox *m2 = sbe2->mailbox;

  int rc = 0;

  switch ((C_SidebarSortMethod & SORT_MASK))
  {
    case SORT_COUNT:
      if (m2->msg_count == m1->msg_count)
        rc = mutt_str_strcoll(mailbox_path(m1), mailbox_path(m2));
      else
        rc = (m2->msg_count - m1->msg_count);
      break;
    case SORT_UNREAD:
      if (m2->msg_unread == m1->msg_unread)
        rc = mutt_str_strcoll(mailbox_path(m1), mailbox_path(m2));
      else
        rc = (m2->msg_unread - m1->msg_unread);
      break;
    case SORT_DESC:
      rc = mutt_str_strcmp(m1->name, m2->name);
      break;
    case SORT_FLAGGED:
      if (m2->msg_flagged == m1->msg_flagged)
        rc = mutt_str_strcoll(mailbox_path(m1), mailbox_path(m2));
      else
        rc = (m2->msg_flagged - m1->msg_flagged);
      break;
    case SORT_PATH:
    {
      rc = mutt_inbox_cmp(mailbox_path(m1), mailbox_path(m2));
      if (rc == 0)
        rc = mutt_str_strcoll(mailbox_path(m1), mailbox_path(m2));
      break;
    }
  }

  if (C_SidebarSortMethod & SORT_REVERSE)
    rc = -rc;

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_entries_visibility()

static void update_entries_visibility ( void  )

static

Should a sidebar_entry be displayed in the sidebar.

For each SbEntry in the Entries array, check whether we should display it. This is determined by several criteria. If the Mailbox:

• is the currently open mailbox
• is the currently highlighted mailbox
• has unread messages
• has flagged messages
• is whitelisted

Definition at line 389 of file sidebar.c.

{
  /* Aliases for readability */
  const bool new_only = C_SidebarNewMailOnly;
  const bool non_empty_only = C_SidebarNonEmptyMailboxOnly;
  struct SbEntry *sbe = NULL;

  /* Take the fast path if there is no need to test visibilities */
  if (!new_only && !non_empty_only)
  {
    for (int i = 0; i < EntryCount; i++)
    {
      Entries[i]->is_hidden = false;
    }
    return;
  }

  for (int i = 0; i < EntryCount; i++)
  {
    sbe = Entries[i];

    sbe->is_hidden = false;

    if (Context && (mutt_str_strcmp(sbe->mailbox->realpath, Context->mailbox->realpath) == 0))
    {
      /* Spool directories are always visible */
      continue;
    }

    if (mutt_list_find(&SidebarWhitelist, mailbox_path(sbe->mailbox)) ||
        mutt_list_find(&SidebarWhitelist, sbe->mailbox->name))
    {
      /* Explicitly asked to be visible */
      continue;
    }

    if (non_empty_only && (i != OpnIndex) && (sbe->mailbox->msg_count == 0))
    {
      sbe->is_hidden = true;
    }

    if (new_only && (i != OpnIndex) && (sbe->mailbox->msg_unread == 0) &&
        (sbe->mailbox->msg_flagged == 0) && !sbe->mailbox->has_new)
    {
      sbe->is_hidden = true;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsort_entries()

static void unsort_entries ( void  )

static

Restore Entries array order to match Mailbox list order.

Definition at line 441 of file sidebar.c.

{
  int i = 0;

  struct MailboxList ml = neomutt_mailboxlist_get_all(NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    if (i >= EntryCount)
      break;

    int j = i;
    while ((j < EntryCount) && (Entries[j]->mailbox != np->mailbox))
      j++;
    if (j < EntryCount)
    {
      if (j != i)
      {
        struct SbEntry *tmp = Entries[i];
        Entries[i] = Entries[j];
        Entries[j] = tmp;
      }
      i++;
    }
  }
  neomutt_mailboxlist_clear(&ml);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sort_entries()

static void sort_entries ( void  )

static

Sort Entries array.

Sort the Entries array according to the current sort config option "sidebar_sort_method". This calls qsort to do the work which calls our callback function "cb_qsort_sbe".

Once sorted, the prev/next links will be reconstructed.

Definition at line 478 of file sidebar.c.

{
  enum SortType ssm = (C_SidebarSortMethod & SORT_MASK);

  /* These are the only sort methods we understand */
  if ((ssm == SORT_COUNT) || (ssm == SORT_UNREAD) || (ssm == SORT_FLAGGED) || (ssm == SORT_PATH))
    qsort(Entries, EntryCount, sizeof(*Entries), cb_qsort_sbe);
  else if ((ssm == SORT_ORDER) && (C_SidebarSortMethod != PreviousSort))
    unsort_entries();
}

Here is the call graph for this function:

Here is the caller graph for this function:

select_next()

static bool select_next ( void  )

static

Selects the next unhidden mailbox.

Return values

true	Success
false	Failure

Definition at line 494 of file sidebar.c.

{
  int entry = HilIndex;

  if (!EntryCount || (HilIndex < 0))
    return false;

  do
  {
    entry++;
    if (entry == EntryCount)
      return false;
  } while (Entries[entry]->is_hidden);

  HilIndex = entry;
  return true;
}

Here is the caller graph for this function:

select_next_new()

static int select_next_new ( void  )

static

Selects the next new mailbox.

Return values

true	Success
false	Failure

Search down the list of mail folders for one containing new mail.

Definition at line 519 of file sidebar.c.

{
  int entry = HilIndex;

  if (!EntryCount || (HilIndex < 0))
    return false;

  do
  {
    entry++;
    if (entry == EntryCount)
    {
      if (C_SidebarNextNewWrap)
        entry = 0;
      else
        return false;
    }
    if (entry == HilIndex)
      return false;
  } while (!Entries[entry]->mailbox->has_new && (Entries[entry]->mailbox->msg_unread == 0));

  HilIndex = entry;
  return true;
}

Here is the caller graph for this function:

select_prev()

static bool select_prev ( void  )

static

Selects the previous unhidden mailbox.

Return values

true	Success
false	Failure

Definition at line 549 of file sidebar.c.

{
  int entry = HilIndex;

  if (!EntryCount || (HilIndex < 0))
    return false;

  do
  {
    entry--;
    if (entry < 0)
      return false;
  } while (Entries[entry]->is_hidden);

  HilIndex = entry;
  return true;
}

Here is the caller graph for this function:

select_prev_new()

static bool select_prev_new ( void  )

static

Selects the previous new mailbox.

Return values

true	Success
false	Failure

Search up the list of mail folders for one containing new mail.

Definition at line 574 of file sidebar.c.

{
  int entry = HilIndex;

  if (!EntryCount || (HilIndex < 0))
    return false;

  do
  {
    entry--;
    if (entry < 0)
    {
      if (C_SidebarNextNewWrap)
        entry = EntryCount - 1;
      else
        return false;
    }
    if (entry == HilIndex)
      return false;
  } while (!Entries[entry]->mailbox->has_new && (Entries[entry]->mailbox->msg_unread == 0));

  HilIndex = entry;
  return true;
}

Here is the caller graph for this function:

select_page_down()

static int select_page_down ( void  )

static

Selects the first entry in the next page of mailboxes.

Return values

true	Success
false	Failure

Definition at line 604 of file sidebar.c.

{
  int orig_hil_index = HilIndex;

  if (!EntryCount || (BotIndex < 0))
    return 0;

  HilIndex = BotIndex;
  select_next();
  /* If the rest of the entries are hidden, go up to the last unhidden one */
  if (Entries[HilIndex]->is_hidden)
    select_prev();

  return orig_hil_index != HilIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

select_page_up()

static int select_page_up ( void  )

static

Selects the last entry in the previous page of mailboxes.

Return values

true	Success
false	Failure

Definition at line 625 of file sidebar.c.

{
  int orig_hil_index = HilIndex;

  if (!EntryCount || (TopIndex < 0))
    return 0;

  HilIndex = TopIndex;
  select_prev();
  /* If the rest of the entries are hidden, go down to the last unhidden one */
  if (Entries[HilIndex]->is_hidden)
    select_next();

  return orig_hil_index != HilIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_sidebar()

static bool prepare_sidebar ( int  page_size )

static

Prepare the list of SbEntry's for the sidebar display.

Parameters

page_size

The number of lines on a page

Return values

false	No, don't draw the sidebar
true	Yes, draw the sidebar

Before painting the sidebar, we determine which are visible, sort them and set up our page pointers.

This is a lot of work to do each refresh, but there are many things that can change outside of the sidebar that we don't hear about.

Definition at line 653 of file sidebar.c.

{
  if (!EntryCount || (page_size <= 0))
    return false;

  const struct SbEntry *opn_entry = (OpnIndex >= 0) ? Entries[OpnIndex] : NULL;
  const struct SbEntry *hil_entry = (HilIndex >= 0) ? Entries[HilIndex] : NULL;

  update_entries_visibility();
  sort_entries();

  for (int i = 0; i < EntryCount; i++)
  {
    if (opn_entry == Entries[i])
      OpnIndex = i;
    if (hil_entry == Entries[i])
      HilIndex = i;
  }

  if ((HilIndex < 0) || Entries[HilIndex]->is_hidden || (C_SidebarSortMethod != PreviousSort))
  {
    if (OpnIndex >= 0)
      HilIndex = OpnIndex;
    else
    {
      HilIndex = 0;
      if (Entries[HilIndex]->is_hidden)
        select_next();
    }
  }

  /* Set the Top and Bottom to frame the HilIndex in groups of page_size */

  /* If C_SidebarNewMailOnly or C_SidebarNonEmptyMailboxOnly is set, some entries
   * may be hidden so we need to scan for the framing interval */
  if (C_SidebarNewMailOnly || C_SidebarNonEmptyMailboxOnly)
  {
    TopIndex = -1;
    BotIndex = -1;
    while (BotIndex < HilIndex)
    {
      TopIndex = BotIndex + 1;
      int page_entries = 0;
      while (page_entries < page_size)
      {
        BotIndex++;
        if (BotIndex >= EntryCount)
          break;
        if (!Entries[BotIndex]->is_hidden)
          page_entries++;
      }
    }
  }
  /* Otherwise we can just calculate the interval */
  else
  {
    TopIndex = (HilIndex / page_size) * page_size;
    BotIndex = TopIndex + page_size - 1;
  }

  if (BotIndex > (EntryCount - 1))
    BotIndex = EntryCount - 1;

  PreviousSort = C_SidebarSortMethod;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_divider()

static int draw_divider ( struct MuttWindow *  win, int  num_rows, int  num_cols  )

static

Draw a line between the sidebar and the rest of neomutt.

Parameters

win	Window to draw on
num_rows	Height of the Sidebar
num_cols	Width of the Sidebar

Return values

0	Empty string
num	Character occupies n screen columns

Draw a divider using characters from the config option "sidebar_divider_char". This can be an ASCII or Unicode character. We calculate these characters' width in screen columns.

If the user hasn't set $sidebar_divider_char we pick a character for them, respecting the value of $ascii_chars.

Definition at line 735 of file sidebar.c.

{
  if ((num_rows < 1) || (num_cols < 1))
    return 0;

  int delim_len;
  enum DivType altchar = SB_DIV_UTF8;

  /* Calculate the width of the delimiter in screen cells */
  delim_len = mutt_strwidth(C_SidebarDividerChar);
  if (delim_len < 0)
  {
    delim_len = 1; /* Bad character */
  }
  else if (delim_len == 0)
  {
    if (C_SidebarDividerChar)
      return 0; /* User has set empty string */

    delim_len = 1; /* Unset variable */
  }
  else
  {
    altchar = SB_DIV_USER; /* User config */
  }

  if (C_AsciiChars && (altchar != SB_DIV_ASCII))
  {
    /* $ascii_chars overrides Unicode divider chars */
    if (altchar == SB_DIV_UTF8)
    {
      altchar = SB_DIV_ASCII;
    }
    else if (C_SidebarDividerChar)
    {
      for (int i = 0; i < delim_len; i++)
      {
        if (C_SidebarDividerChar[i] & ~0x7F) /* high-bit is set */
        {
          altchar = SB_DIV_ASCII;
          delim_len = 1;
          break;
        }
      }
    }
  }

  if (delim_len > num_cols)
    return 0;

  mutt_curses_set_color(MT_COLOR_SIDEBAR_DIVIDER);

  int col = C_SidebarOnRight ? 0 : (C_SidebarWidth - delim_len);

  for (int i = 0; i < num_rows; i++)
  {
    mutt_window_move(win, i, col);

    switch (altchar)
    {
      case SB_DIV_USER:
        mutt_window_addstr(NONULL(C_SidebarDividerChar));
        break;
      case SB_DIV_ASCII:
        mutt_window_addch('|');
        break;
      case SB_DIV_UTF8:
        mutt_window_addch(ACS_VLINE);
        break;
    }
  }

  return delim_len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_empty_space()

static void fill_empty_space ( struct MuttWindow *  win, int  first_row, int  num_rows, int  div_width, int  num_cols  )

static

Wipe the remaining Sidebar space.

Parameters

win	Window to draw on
first_row	Window line to start (0-based)
num_rows	Number of rows to fill
div_width	Width in screen characters taken by the divider
num_cols	Number of columns to fill

Write spaces over the area the sidebar isn't using.

Definition at line 820 of file sidebar.c.

{
  /* Fill the remaining rows with blank space */
  mutt_curses_set_color(MT_COLOR_NORMAL);

  if (!C_SidebarOnRight)
    div_width = 0;
  for (int r = 0; r < num_rows; r++)
  {
    mutt_window_move(win, first_row + r, div_width);

    for (int i = 0; i < num_cols; i++)
      mutt_window_addch(' ');
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_is_prefix()

static bool imap_is_prefix ( const char *  folder, const char *  mbox, size_t *  plen  )

static

Check if folder matches the beginning of mbox.

Parameters

folder	Folder
mbox	Mailbox path
plen	Prefix length

Return values

true	If folder is the prefix of mbox

Definition at line 844 of file sidebar.c.

{
  bool rc = false;

  struct Url *url_m = url_parse(mbox);
  struct Url *url_f = url_parse(folder);
  if (!url_m || !url_f)
    goto done;

  if (mutt_str_strcasecmp(url_m->host, url_f->host) != 0)
    goto done;

  if (url_m->user && url_f->user && (mutt_str_strcasecmp(url_m->user, url_f->user) != 0))
    goto done;

  size_t mlen = mutt_str_strlen(url_m->path);
  size_t flen = mutt_str_strlen(url_f->path);
  if (flen > mlen)
    goto done;

  if (mutt_str_strncmp(url_m->path, url_f->path, flen) != 0)
    goto done;

  if (url_m->user && !url_f->user)
    *plen += mutt_str_strlen(url_m->user) + 1;
  rc = true;

done:
  url_free(&url_m);
  url_free(&url_f);

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw_sidebar()

static void draw_sidebar ( struct MuttWindow *  win, int  num_rows, int  num_cols, int  div_width  )

static

Write out a list of mailboxes, in a panel.

Parameters

win	Window to draw on
num_rows	Height of the Sidebar
num_cols	Width of the Sidebar
div_width	Width in screen characters taken by the divider

Display a list of mailboxes in a panel on the left. What's displayed will depend on our index markers: TopMailbox, OpnMailbox, HilMailbox, BotMailbox. On the first run they'll be NULL, so we display the top of NeoMutt's list.

• TopMailbox - first visible mailbox
• BotMailbox - last visible mailbox
• OpnMailbox - mailbox shown in NeoMutt's Index Panel
• HilMailbox - Unselected mailbox (the paging follows this)

The entries are formatted using "sidebar_format" and may be abbreviated: "sidebar_short_path", indented: "sidebar_folder_indent", "sidebar_indent_string" and sorted: "sidebar_sort_method". Finally, they're trimmed to fit the available space.

Definition at line 899 of file sidebar.c.

{
  struct SbEntry *entry = NULL;
  struct Mailbox *m = NULL;
  if (TopIndex < 0)
    return;

  int w = MIN(num_cols, (C_SidebarWidth - div_width));
  int row = 0;
  for (int entryidx = TopIndex; (entryidx < EntryCount) && (row < num_rows); entryidx++)
  {
    entry = Entries[entryidx];
    if (entry->is_hidden)
      continue;
    m = entry->mailbox;

    if (entryidx == OpnIndex)
    {
      if ((Colors->defs[MT_COLOR_SIDEBAR_INDICATOR] != 0))
        mutt_curses_set_color(MT_COLOR_SIDEBAR_INDICATOR);
      else
        mutt_curses_set_color(MT_COLOR_INDICATOR);
    }
    else if (entryidx == HilIndex)
      mutt_curses_set_color(MT_COLOR_SIDEBAR_HIGHLIGHT);
    else if (m->has_new)
      mutt_curses_set_color(MT_COLOR_SIDEBAR_NEW);
    else if (m->msg_unread > 0)
      mutt_curses_set_color(MT_COLOR_SIDEBAR_UNREAD);
    else if (m->msg_flagged > 0)
      mutt_curses_set_color(MT_COLOR_SIDEBAR_FLAGGED);
    else if ((Colors->defs[MT_COLOR_SIDEBAR_SPOOLFILE] != 0) &&
             (mutt_str_strcmp(mailbox_path(m), C_Spoolfile) == 0))
    {
      mutt_curses_set_color(MT_COLOR_SIDEBAR_SPOOLFILE);
    }
    else
    {
      if (Colors->defs[MT_COLOR_SIDEBAR_ORDINARY] != 0)
        mutt_curses_set_color(MT_COLOR_SIDEBAR_ORDINARY);
      else
        mutt_curses_set_color(MT_COLOR_NORMAL);
    }

    int col = 0;
    if (C_SidebarOnRight)
      col = div_width;

    mutt_window_move(win, row, col);
    if (Context && Context->mailbox && (Context->mailbox->realpath[0] != '\0') &&
        (mutt_str_strcmp(m->realpath, Context->mailbox->realpath) == 0))
    {
      m->msg_unread = Context->mailbox->msg_unread;
      m->msg_count = Context->mailbox->msg_count;
      m->msg_flagged = Context->mailbox->msg_flagged;
    }

    /* compute length of C_Folder without trailing separator */
    size_t maildirlen = mutt_str_strlen(C_Folder);
    if (maildirlen && C_SidebarDelimChars &&
        strchr(C_SidebarDelimChars, C_Folder[maildirlen - 1]))
    {
      maildirlen--;
    }

    /* check whether C_Folder is a prefix of the current folder's path */
    bool maildir_is_prefix = false;
    if (m->type == MUTT_IMAP)
    {
      maildir_is_prefix = imap_is_prefix(C_Folder, mailbox_path(m), &maildirlen);
    }
    else
    {
      if ((mutt_buffer_len(&m->pathbuf) > maildirlen) &&
          (mutt_str_strncmp(C_Folder, mailbox_path(m), maildirlen) == 0) && C_SidebarDelimChars &&
          strchr(C_SidebarDelimChars, mailbox_path(m)[maildirlen]))
      {
        maildir_is_prefix = true;
      }
    }

    if (m->name)
      maildir_is_prefix = false;

    /* calculate depth of current folder and generate its display name with indented spaces */
    int sidebar_folder_depth = 0;
    const char *sidebar_folder_name = m->name ? m->name : mailbox_path(m);
    struct Buffer *short_folder_name = NULL;

    if (C_SidebarShortPath)
    {
      /* disregard a trailing separator, so strlen() - 2 */
      for (int i = mutt_str_strlen(sidebar_folder_name) - 2; i >= 0; i--)
      {
        if (C_SidebarDelimChars && strchr(C_SidebarDelimChars, sidebar_folder_name[i]))
        {
          sidebar_folder_name += (i + 1);
          break;
        }
      }
    }
    else if ((C_SidebarComponentDepth > 0) && C_SidebarDelimChars)
    {
      sidebar_folder_name += maildir_is_prefix * (maildirlen + 1);
      for (int i = 0; i < C_SidebarComponentDepth; i++)
      {
        char *chars_after_delim = strpbrk(sidebar_folder_name, C_SidebarDelimChars);
        if (!chars_after_delim)
          break;

        sidebar_folder_name = chars_after_delim + 1;
      }
    }
    else
      sidebar_folder_name += maildir_is_prefix * (maildirlen + 1);

    if ((m->name || maildir_is_prefix) && C_SidebarFolderIndent)
    {
      int lastsep = 0;
      const char *tmp_folder_name = m->name ? m->name : mailbox_path(m) + maildirlen + 1;
      int tmplen = (int) mutt_str_strlen(tmp_folder_name) - 1;
      for (int i = 0; i < tmplen; i++)
      {
        if (C_SidebarDelimChars && strchr(C_SidebarDelimChars, tmp_folder_name[i]))
        {
          sidebar_folder_depth++;
          lastsep = i + 1;
        }
      }
      if (sidebar_folder_depth > 0)
      {
        if (C_SidebarShortPath)
          tmp_folder_name += lastsep; /* basename */
        short_folder_name = mutt_buffer_pool_get();
        for (int i = 0; i < sidebar_folder_depth; i++)
          mutt_buffer_addstr(short_folder_name, NONULL(C_SidebarIndentString));
        mutt_buffer_addstr(short_folder_name, tmp_folder_name);
        sidebar_folder_name = mutt_b2s(short_folder_name);
      }
    }
    char str[256];
    make_sidebar_entry(str, sizeof(str), w, sidebar_folder_name, entry);
    mutt_window_printf("%s", str);
    mutt_buffer_pool_release(&short_folder_name);
    row++;
  }

  fill_empty_space(win, row, num_rows - row, div_width, w);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sb_draw()

void mutt_sb_draw

(

struct MuttWindow *

win

)

Completely redraw the sidebar.

Parameters

win	Window to draw on

Completely refresh the sidebar region. First draw the divider; then, for each Mailbox, call make_sidebar_entry; finally blank out any remaining space.

Definition at line 1056 of file sidebar.c.

{
  if (!C_SidebarVisible || !win)
    return;

  if (!mutt_window_is_visible(win))
    return;

  int row = 0, col = 0;
  mutt_window_get_coords(win, &row, &col);

  int num_rows = win->state.rows;
  int num_cols = win->state.cols;

  int div_width = draw_divider(win, num_rows, num_cols);

  if (!Entries)
  {
    struct MailboxList ml = neomutt_mailboxlist_get_all(NeoMutt, MUTT_MAILBOX_ANY);
    struct MailboxNode *np = NULL;
    STAILQ_FOREACH(np, &ml, entries)
    {
      mutt_sb_notify_mailbox(np->mailbox, true);
    }
    neomutt_mailboxlist_clear(&ml);
  }

  if (!prepare_sidebar(num_rows))
  {
    fill_empty_space(win, 0, num_rows, div_width, num_cols - div_width);
    return;
  }

  draw_sidebar(win, num_rows, num_cols, div_width);
  mutt_window_move(win, row, col);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sb_change_mailbox()

void mutt_sb_change_mailbox

(

int

op

)

Change the selected mailbox.

Parameters

op	Operation code

Change the selected mailbox, e.g. "Next mailbox", "Previous Mailbox with new mail". The operations are listed in opcodes.h.

If the operation is successful, HilMailbox will be set to the new mailbox. This function only selects the mailbox, doesn't open it.

Allowed values are: OP_SIDEBAR_NEXT, OP_SIDEBAR_NEXT_NEW, OP_SIDEBAR_PAGE_DOWN, OP_SIDEBAR_PAGE_UP, OP_SIDEBAR_PREV, OP_SIDEBAR_PREV_NEW.

Definition at line 1107 of file sidebar.c.

{
  if (!C_SidebarVisible)
    return;

  if (HilIndex < 0) /* It'll get reset on the next draw */
    return;

  switch (op)
  {
    case OP_SIDEBAR_NEXT:
      if (!select_next())
        return;
      break;
    case OP_SIDEBAR_NEXT_NEW:
      if (!select_next_new())
        return;
      break;
    case OP_SIDEBAR_PAGE_DOWN:
      if (!select_page_down())
        return;
      break;
    case OP_SIDEBAR_PAGE_UP:
      if (!select_page_up())
        return;
      break;
    case OP_SIDEBAR_PREV:
      if (!select_prev())
        return;
      break;
    case OP_SIDEBAR_PREV_NEW:
      if (!select_prev_new())
        return;
      break;
    default:
      return;
  }
  mutt_menu_set_current_redraw(REDRAW_SIDEBAR);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sb_get_highlight()

struct Mailbox* mutt_sb_get_highlight

(

void

)

Get the Mailbox that's highlighted in the sidebar.

Return values

ptr

Mailbox

Definition at line 1151 of file sidebar.c.

{
  if (!C_SidebarVisible)
    return NULL;

  if (!EntryCount || (HilIndex < 0))
    return NULL;

  return Entries[HilIndex]->mailbox;
}

Here is the caller graph for this function:

mutt_sb_set_open_mailbox()

void mutt_sb_set_open_mailbox

(

struct Mailbox *

m

)

Set the 'open' Mailbox.

Parameters

m

Mailbox

Search through the list of mailboxes. If a Mailbox has a matching path, set OpnMailbox to it.

Definition at line 1169 of file sidebar.c.

{
  OpnIndex = -1;

  if (!m)
    return;

  for (int entry = 0; entry < EntryCount; entry++)
  {
    if (mutt_str_strcmp(Entries[entry]->mailbox->realpath, m->realpath) == 0)
    {
      OpnIndex = entry;
      HilIndex = entry;
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sb_notify_mailbox()

void mutt_sb_notify_mailbox	(	struct Mailbox *	m,
		bool	created
	)

The state of a Mailbox is about to change.

Parameters

m	Folder
created	True if folder created, false if deleted

We receive a notification:

• After a new Mailbox has been created
• Before a Mailbox is deleted

Before a deletion, check that our pointers won't be invalidated.

Definition at line 1198 of file sidebar.c.

{
  if (!m)
    return;

  /* Any new/deleted mailboxes will cause a refresh.  As long as
   * they're valid, our pointers will be updated in prepare_sidebar() */

  if (created)
  {
    if (EntryCount >= EntryLen)
    {
      EntryLen += 10;
      mutt_mem_realloc(&Entries, EntryLen * sizeof(struct SbEntry *));
    }
    Entries[EntryCount] = mutt_mem_calloc(1, sizeof(struct SbEntry));
    Entries[EntryCount]->mailbox = m;

    if (TopIndex < 0)
      TopIndex = EntryCount;
    if (BotIndex < 0)
      BotIndex = EntryCount;
    if ((OpnIndex < 0) && Context &&
        (mutt_str_strcmp(m->realpath, Context->mailbox->realpath) == 0))
      OpnIndex = EntryCount;

    EntryCount++;
  }
  else
  {
    int del_index;
    for (del_index = 0; del_index < EntryCount; del_index++)
      if (Entries[del_index]->mailbox == m)
        break;
    if (del_index == EntryCount)
      return;
    FREE(&Entries[del_index]);
    EntryCount--;

    if ((TopIndex > del_index) || (TopIndex == EntryCount))
      TopIndex--;
    if (OpnIndex == del_index)
      OpnIndex = -1;
    else if (OpnIndex > del_index)
      OpnIndex--;
    if ((HilIndex > del_index) || (HilIndex == EntryCount))
      HilIndex--;
    if ((BotIndex > del_index) || (BotIndex == EntryCount))
      BotIndex--;

    for (; del_index < EntryCount; del_index++)
      Entries[del_index] = Entries[del_index + 1];
  }

  mutt_menu_set_current_redraw(REDRAW_SIDEBAR);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sb_observer()

int mutt_sb_observer

(

struct NotifyCallback *

nc

)

Listen for config changes affecting the sidebar - Implements observer_t.

Parameters

nc	Notification data

Return values

bool	True, if successful

Definition at line 1260 of file sidebar.c.

{
  if (!nc->event_data || !nc->global_data)
    return -1;
  if (nc->event_type != NT_CONFIG)
    return 0;

  struct MuttWindow *win = nc->global_data;
  struct EventConfig *ec = nc->event_data;

  if (mutt_str_strncmp(ec->name, "sidebar_", 8) != 0)
    return 0;

  bool repaint = false;

  if (win->state.visible == !C_SidebarVisible)
  {
    win->state.visible = C_SidebarVisible;
    repaint = true;
  }

  if (win->req_cols != C_SidebarWidth)
  {
    win->req_cols = C_SidebarWidth;
    repaint = true;
  }

  struct MuttWindow *parent = win->parent;
  struct MuttWindow *first = TAILQ_FIRST(&parent->children);

  if ((C_SidebarOnRight && (first == win)) || (!C_SidebarOnRight && (first != win)))
  {
    // Swap the Sidebar and the Container of the Index/Pager
    TAILQ_REMOVE(&parent->children, first, entries);
    TAILQ_INSERT_TAIL(&parent->children, first, entries);
    repaint = true;
  }

  if (repaint)
  {
    mutt_debug(LL_NOTIFY, "repaint sidebar\n");
    mutt_window_reflow(MuttDialogWindow);
    mutt_menu_set_current_redraw_full();
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_SidebarComponentDepth

short C_SidebarComponentDepth

Config: (sidebar) Strip leading path components from sidebar folders.

Definition at line 51 of file sidebar.c.

C_SidebarDelimChars

char* C_SidebarDelimChars

Config: (sidebar) Characters that separate nested folders.

Definition at line 52 of file sidebar.c.

C_SidebarDividerChar

char* C_SidebarDividerChar

Config: (sidebar) Character to draw between the sidebar and index.

Definition at line 53 of file sidebar.c.

C_SidebarFolderIndent

bool C_SidebarFolderIndent

Config: (sidebar) Indent nested folders.

Definition at line 54 of file sidebar.c.

C_SidebarFormat

char* C_SidebarFormat

Config: (sidebar) printf-like format string for the sidebar panel.

Definition at line 55 of file sidebar.c.

C_SidebarIndentString

char* C_SidebarIndentString

Config: (sidebar) Indent nested folders using this string.

Definition at line 56 of file sidebar.c.

C_SidebarNewMailOnly

bool C_SidebarNewMailOnly

Config: (sidebar) Only show folders with new/flagged mail.

Definition at line 57 of file sidebar.c.

C_SidebarNonEmptyMailboxOnly

bool C_SidebarNonEmptyMailboxOnly

Config: (sidebar) Only show folders with a non-zero number of mail.

Definition at line 58 of file sidebar.c.

C_SidebarNextNewWrap

bool C_SidebarNextNewWrap

Config: (sidebar) Wrap around when searching for the next mailbox with new mail.

Definition at line 59 of file sidebar.c.

C_SidebarOnRight

bool C_SidebarOnRight

Config: (sidebar) Display the sidebar on the right.

Definition at line 60 of file sidebar.c.

C_SidebarShortPath

bool C_SidebarShortPath

Config: (sidebar) Abbreviate the paths using the C_Folder variable.

Definition at line 61 of file sidebar.c.

C_SidebarSortMethod

short C_SidebarSortMethod

Config: (sidebar) Method to sort the sidebar.

Definition at line 62 of file sidebar.c.

C_SidebarVisible

bool C_SidebarVisible

Config: (sidebar) Show the sidebar.

Definition at line 63 of file sidebar.c.

C_SidebarWidth

short C_SidebarWidth

Config: (sidebar) Width of the sidebar.

Definition at line 64 of file sidebar.c.

PreviousSort

short PreviousSort = SORT_ORDER

static

Definition at line 67 of file sidebar.c.

EntryCount

int EntryCount = 0

static

Definition at line 79 of file sidebar.c.

EntryLen

int EntryLen = 0

static

Definition at line 80 of file sidebar.c.

Entries

struct SbEntry** Entries = NULL

static

Definition at line 81 of file sidebar.c.

TopIndex

int TopIndex = -1

static

First mailbox visible in sidebar.

Definition at line 83 of file sidebar.c.

OpnIndex

int OpnIndex = -1

static

Current (open) mailbox.

Definition at line 84 of file sidebar.c.

HilIndex

int HilIndex = -1

static

Highlighted mailbox.

Definition at line 85 of file sidebar.c.

BotIndex

int BotIndex = -1

static

Last mailbox visible in sidebar.

Definition at line 86 of file sidebar.c.