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 "core/lib.h"
#include "status.h"
#include "expando/lib.h"
#include "index/lib.h"
#include "menu/lib.h"
#include "postpone/lib.h"
#include "globals.h"
#include "mutt_mailbox.h"
#include "mutt_thread.h"
#include "muttlib.h"
#include "mview.h"
 
void status_f(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
              struct Buffer *buf);
 
const struct ExpandoRenderData StatusRenderData[];
 
static char *get_sort_str(char *buf, size_t buflen, enum SortType method)
{
  snprintf(buf, buflen, "%s%s%s", (method & SORT_REVERSE) ? "reverse-" : "",
           (method & SORT_LAST) ? "last-" : "",
           mutt_map_get_name(method & SORT_MASK, SortMethods));
  return buf;
}
 
struct MenuStatusLineData
{
  struct IndexSharedData *shared; 
  struct Menu *menu;              
};
 
void status_r(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;
 
  size_t i = 0;
 
  if (m)
  {
    i = shared->attach_msg ? 3 :
                             ((m->readonly || m->dontwrite) ? 2 :
                              (m->changed ||
                               /* deleted doesn't necessarily mean changed in IMAP */
                               (m->type != MUTT_IMAP && m->msg_deleted)) ?
                                                              1 :
                                                              0);
  }
 
  if (i >= c_status_chars->len)
    buf_addstr(buf, c_status_chars->chars[0]);
  else
    buf_addstr(buf, c_status_chars->chars[i]);
}
 
void status_D(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;
  }
 
  status_f(node, data, flags, buf);
}
 
void status_f(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;
 
  char tmp[128] = { 0 };
 
  if (m && m->compress_info && (m->realpath[0] != '\0'))
  {
    mutt_str_copy(tmp, m->realpath, sizeof(tmp));
    mutt_pretty_mailbox(tmp, sizeof(tmp));
  }
  else if (m && (m->type == MUTT_NOTMUCH) && m->name)
  {
    mutt_str_copy(tmp, m->name, sizeof(tmp));
  }
  else if (m && !buf_is_empty(&m->pathbuf))
  {
    mutt_str_copy(tmp, mailbox_path(m), sizeof(tmp));
    mutt_pretty_mailbox(tmp, sizeof(tmp));
  }
  else
  {
    mutt_str_copy(tmp, _("(no mailbox)"), sizeof(tmp));
  }
 
  buf_strcpy(buf, tmp);
}
 
long status_M_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;
}
 
long status_m_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;
}
 
long status_n_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;
}
 
long status_o_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;
}
 
long status_d_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;
}
 
long status_F_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;
}
 
long status_t_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;
}
 
long status_p_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);
}
 
long status_b_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);
}
 
long status_l_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;
}
 
void status_l(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;
 
  char tmp[128] = { 0 };
 
  const off_t num = m ? m->size : 0;
  mutt_str_pretty_size(tmp, sizeof(tmp), num);
  buf_strcpy(buf, tmp);
}
 
void status_T(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);
}
 
void status_s(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
              struct Buffer *buf)
{
  char tmp[128] = { 0 };
 
  const enum SortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  const char *s = get_sort_str(tmp, sizeof(tmp), c_sort);
  buf_strcpy(buf, s);
}
 
void status_S(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
              struct Buffer *buf)
{
  char tmp[128] = { 0 };
 
  const enum SortType c_sort_aux = cs_subset_sort(NeoMutt->sub, "sort_aux");
  const char *s = get_sort_str(tmp, sizeof(tmp), c_sort_aux);
  buf_strcpy(buf, s);
}
 
long status_P_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;
}
 
void status_P(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;
 
  char tmp[128] = { 0 };
 
  char *cp = NULL;
  if (menu->top + menu->page_len >= menu->max)
  {
    cp = 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");
  }
  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. */
    snprintf(tmp, sizeof(tmp), _("%d%%"), count);
    cp = tmp;
  }
 
  buf_strcpy(buf, cp);
}
 
void status_h(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
              struct Buffer *buf)
{
  const char *s = ShortHostname;
  buf_strcpy(buf, s);
}
 
long status_L_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;
}
 
void status_L(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;
 
  char tmp[128] = { 0 };
 
  const off_t num = mailbox_view ? mailbox_view->vsize : 0;
  mutt_str_pretty_size(tmp, sizeof(tmp), num);
  buf_strcpy(buf, tmp);
}
 
long status_R_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;
}
 
long status_u_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;
}
 
void status_v(const struct ExpandoNode *node, void *data, MuttFormatFlags flags,
              struct Buffer *buf)
{
  const char *s = mutt_make_version();
  buf_strcpy(buf, s);
}
 
void status_V(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);
}
 
void menu_status_line(struct Buffer *buf, struct IndexSharedData *shared,
                      struct Menu *menu, int max_cols, const struct Expando *exp)
{
  struct MenuStatusLineData data = { shared, menu };
 
  expando_filter(exp, StatusRenderData, &data, MUTT_FORMAT_NO_FLAGS, max_cols, buf);
}
 
const struct ExpandoRenderData StatusRenderData[] = {
  // clang-format off
  { ED_INDEX,  ED_IND_UNREAD_MAILBOXES,NULL,     status_b_num },
  { ED_INDEX,  ED_IND_DELETED_COUNT,   NULL,     status_d_num },
  { ED_INDEX,  ED_IND_DESCRIPTION,     status_D, NULL },
  { ED_INDEX,  ED_IND_FLAGGED_COUNT,   NULL,     status_F_num },
  { ED_INDEX,  ED_IND_MAILBOX_PATH,    status_f, NULL },
  { ED_GLOBAL, ED_GLO_HOSTNAME,        status_h, NULL },
  { ED_INDEX,  ED_IND_LIMIT_SIZE,      status_L, status_L_num },
  { ED_INDEX,  ED_IND_MAILBOX_SIZE,    status_l, status_l_num },
  { ED_INDEX,  ED_IND_LIMIT_COUNT,     NULL,     status_M_num },
  { ED_INDEX,  ED_IND_MESSAGE_COUNT,   NULL,     status_m_num },
  { ED_INDEX,  ED_IND_NEW_COUNT,       NULL,     status_n_num },
  { ED_INDEX,  ED_IND_OLD_COUNT,       NULL,     status_o_num },
  { ED_MENU,   ED_MEN_PERCENTAGE,      status_P, status_P_num },
  { ED_INDEX,  ED_IND_POSTPONED_COUNT, NULL,     status_p_num },
  { ED_INDEX,  ED_IND_READ_COUNT,      NULL,     status_R_num },
  { ED_INDEX,  ED_IND_READONLY,        status_r, NULL },
  { ED_GLOBAL, ED_GLO_SORT,            status_s, NULL },
  { ED_GLOBAL, ED_GLO_SORT_AUX,        status_S, NULL },
  { ED_INDEX,  ED_IND_TAGGED_COUNT,    NULL,     status_t_num },
  { ED_GLOBAL, ED_GLO_USE_THREADS,     status_T, NULL },
  { ED_INDEX,  ED_IND_UNREAD_COUNT,    NULL,     status_u_num },
  { ED_INDEX,  ED_IND_LIMIT_PATTERN,   status_V, NULL },
  { ED_GLOBAL, ED_GLO_VERSION,         status_v, NULL },
  { -1, -1, NULL, NULL },
  // clang-format on
};