expando_status.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "expando_status.h"
#include "expando/lib.h"
#include "menu/lib.h"
#include "postpone/lib.h"
#include "globals.h"
#include "mutt_mailbox.h"
#include "muttlib.h"
#include "shared_data.h"
#include "version.h"
 
static void index_mailbox_path(const struct ExpandoNode *node, void *data,
                               MuttFormatFlags flags, struct Buffer *buf);
 
extern const struct Mapping SortMethods[];

static void get_sort_str(struct Buffer *buf, enum EmailSortType method)
{
  if (method & SORT_REVERSE)
    buf_addstr(buf, "reverse-");
  if (method & SORT_LAST)
    buf_addstr(buf, "last-");
  buf_addstr(buf, mutt_map_get_name(method & SORT_MASK, SortMethods));
}

static void global_config_sort(const struct ExpandoNode *node, void *data,
                               MuttFormatFlags flags, struct Buffer *buf)
{
  const enum EmailSortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  get_sort_str(buf, c_sort);
}

static void global_config_sort_aux(const struct ExpandoNode *node, void *data,
                                   MuttFormatFlags flags, struct Buffer *buf)
{
  const enum EmailSortType c_sort_aux = cs_subset_sort(NeoMutt->sub, "sort_aux");
  get_sort_str(buf, c_sort_aux);
}

static void global_config_use_threads(const struct ExpandoNode *node, void *data,
                                      MuttFormatFlags flags, struct Buffer *buf)
{
  const enum UseThreads c_use_threads = mutt_thread_style();
  const char *s = get_use_threads_str(c_use_threads);
  buf_strcpy(buf, s);
}

static void global_hostname(const struct ExpandoNode *node, void *data,
                            MuttFormatFlags flags, struct Buffer *buf)
{
  const char *s = ShortHostname;
  buf_strcpy(buf, s);
}

static void global_version(const struct ExpandoNode *node, void *data,
                           MuttFormatFlags flags, struct Buffer *buf)
{
  const char *s = mutt_make_version();
  buf_strcpy(buf, s);
}

static long index_deleted_count_num(const struct ExpandoNode *node, void *data,
                                    MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->msg_deleted : 0;
}

static void index_description(const struct ExpandoNode *node, void *data,
                              MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  // If there's a descriptive name, use it. Otherwise, use %f
  if (m && m->name)
  {
    const char *s = m->name;
    buf_strcpy(buf, s);
    return;
  }
 
  index_mailbox_path(node, data, flags, buf);
}

static long index_flagged_count_num(const struct ExpandoNode *node, void *data,
                                    MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->msg_flagged : 0;
}

static long index_limit_count_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->vcount : 0;
}

static void index_limit_pattern(const struct ExpandoNode *node, void *data,
                                MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct MailboxView *mailbox_view = shared->mailbox_view;
 
  const char *s = mview_has_limit(mailbox_view) ? mailbox_view->pattern : "";
  buf_strcpy(buf, s);
}

static void index_limit_size(const struct ExpandoNode *node, void *data,
                             MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct MailboxView *mailbox_view = shared->mailbox_view;
 
  const off_t num = mailbox_view ? mailbox_view->vsize : 0;
  mutt_str_pretty_size(buf, num);
}

static long index_limit_size_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct MailboxView *mailbox_view = shared->mailbox_view;
  if (!mailbox_view)
    return 0;
 
  return mailbox_view->vsize;
}

static void index_mailbox_path(const struct ExpandoNode *node, void *data,
                               MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  if (m && m->compress_info && (m->realpath[0] != '\0'))
  {
    buf_strcpy(buf, m->realpath);
    pretty_mailbox(buf);
  }
  else if (m && (m->type == MUTT_NOTMUCH) && m->name)
  {
    buf_strcpy(buf, m->name);
  }
  else if (m && !buf_is_empty(&m->pathbuf))
  {
    buf_strcpy(buf, mailbox_path(m));
    pretty_mailbox(buf);
  }
  else
  {
    buf_strcpy(buf, _("(no mailbox)"));
  }
}

static void index_mailbox_size(const struct ExpandoNode *node, void *data,
                               MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  const off_t num = m ? m->size : 0;
  mutt_str_pretty_size(buf, num);
}

static long index_mailbox_size_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
  if (!m)
    return 0;
 
  return m->size;
}

static long index_message_count_num(const struct ExpandoNode *node, void *data,
                                    MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->msg_count : 0;
}

static long index_new_count_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->msg_new : 0;
}

static long index_old_count_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? (m->msg_unread - m->msg_new) : 0;
}

static long index_postponed_count_num(const struct ExpandoNode *node,
                                      void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  struct Mailbox *m = shared->mailbox;
 
  return mutt_num_postponed(m, false);
}

static void index_readonly(const struct ExpandoNode *node, void *data,
                           MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MbTable *c_status_chars = cs_subset_mbtable(NeoMutt->sub, "status_chars");
  if (!c_status_chars || !c_status_chars->len)
    return;
 
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  int i = STATUS_CHAR_UNCHANGED;
 
  if (m)
  {
    if (shared->attach_msg)
      i = STATUS_CHAR_ATTACH;
    else if (m->readonly || m->dontwrite)
      i = STATUS_CHAR_READ_ONLY;
    else if (m->changed || ((m->type != MUTT_IMAP) && m->msg_deleted)) /* deleted doesn't necessarily mean changed in IMAP */
      i = STATUS_CHAR_NEED_RESYNC;
    else
      i = STATUS_CHAR_UNCHANGED;
  }
 
  if (i >= c_status_chars->len)
    buf_addstr(buf, c_status_chars->chars[STATUS_CHAR_UNCHANGED]);
  else
    buf_addstr(buf, c_status_chars->chars[i]);
}

static long index_read_count_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? (m->msg_count - m->msg_unread) : 0;
}

static long index_tagged_count_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->msg_tagged : 0;
}

static long index_unread_count_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  const struct Mailbox *m = shared->mailbox;
 
  return m ? m->msg_unread : 0;
}

static long index_unread_mailboxes_num(const struct ExpandoNode *node,
                                       void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct IndexSharedData *shared = msld->shared;
  struct Mailbox *m = shared->mailbox;
 
  return mutt_mailbox_check(m, MUTT_MAILBOX_CHECK_NO_FLAGS);
}

static void menu_percentage(const struct ExpandoNode *node, void *data,
                            MuttFormatFlags flags, struct Buffer *buf)
{
  const struct MenuStatusLineData *msld = data;
  const struct Menu *menu = msld->menu;
  if (!menu)
    return;
 
  if (menu->top + menu->page_len >= menu->max)
  {
    const char *s = menu->top ?
                        /* L10N: Status bar message: the end of the list emails is visible in the index */
                        _("end") :
                        /* L10N: Status bar message: all the emails are visible in the index */
                        _("all");
    buf_strcpy(buf, s);
  }
  else
  {
    int count = (100 * (menu->top + menu->page_len)) / menu->max;
    /* L10N: Status bar, percentage of way through index.
           `%d` is the number, `%%` is the percent symbol.
           They may be reordered, or space inserted, if you wish. */
    buf_printf(buf, _("%d%%"), count);
  }
}

static long menu_percentage_num(const struct ExpandoNode *node, void *data, MuttFormatFlags flags)
{
  const struct MenuStatusLineData *msld = data;
  const struct Menu *menu = msld->menu;
  if (!menu)
    return 0;
 
  if (menu->top + menu->page_len >= menu->max)
    return 100;
 
  return (100 * (menu->top + menu->page_len)) / menu->max;
}

const struct ExpandoRenderCallback StatusRenderCallbacks[] = {
  // clang-format off
  { ED_GLOBAL, ED_GLO_CONFIG_SORT,        global_config_sort,        NULL },
  { ED_GLOBAL, ED_GLO_CONFIG_SORT_AUX,    global_config_sort_aux,    NULL },
  { ED_GLOBAL, ED_GLO_CONFIG_USE_THREADS, global_config_use_threads, NULL },
  { ED_GLOBAL, ED_GLO_HOSTNAME,           global_hostname,           NULL },
  { ED_GLOBAL, ED_GLO_VERSION,            global_version,            NULL },
  { ED_INDEX,  ED_IND_DELETED_COUNT,      NULL,                      index_deleted_count_num },
  { ED_INDEX,  ED_IND_DESCRIPTION,        index_description,         NULL },
  { ED_INDEX,  ED_IND_FLAGGED_COUNT,      NULL,                      index_flagged_count_num },
  { ED_INDEX,  ED_IND_LIMIT_COUNT,        NULL,                      index_limit_count_num },
  { ED_INDEX,  ED_IND_LIMIT_PATTERN,      index_limit_pattern,       NULL },
  { ED_INDEX,  ED_IND_LIMIT_SIZE,         index_limit_size,          index_limit_size_num },
  { ED_INDEX,  ED_IND_MAILBOX_PATH,       index_mailbox_path,        NULL },
  { ED_INDEX,  ED_IND_MAILBOX_SIZE,       index_mailbox_size,        index_mailbox_size_num },
  { ED_INDEX,  ED_IND_MESSAGE_COUNT,      NULL,                      index_message_count_num },
  { ED_INDEX,  ED_IND_NEW_COUNT,          NULL,                      index_new_count_num },
  { ED_INDEX,  ED_IND_OLD_COUNT,          NULL,                      index_old_count_num },
  { ED_INDEX,  ED_IND_POSTPONED_COUNT,    NULL,                      index_postponed_count_num },
  { ED_INDEX,  ED_IND_READONLY,           index_readonly,            NULL },
  { ED_INDEX,  ED_IND_READ_COUNT,         NULL,                      index_read_count_num },
  { ED_INDEX,  ED_IND_TAGGED_COUNT,       NULL,                      index_tagged_count_num },
  { ED_INDEX,  ED_IND_UNREAD_COUNT,       NULL,                      index_unread_count_num },
  { ED_INDEX,  ED_IND_UNREAD_MAILBOXES,   NULL,                      index_unread_mailboxes_num },
  { ED_MENU,   ED_MEN_PERCENTAGE,         menu_percentage,           menu_percentage_num },
  { -1, -1, NULL, NULL },
  // clang-format on
};