draw.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <wchar.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "gui/lib.h"
#include "color/lib.h"
#include "index/lib.h"
#include "menu/lib.h"
#include "pattern/lib.h"
#include "mutt_thread.h"
#include "mview.h"
#include "opcodes.h"
 
static struct AttrColor *get_color(int index, unsigned char *s)
{
  const int type = *s;
  struct RegexColorList *rcl = regex_colors_get_list(type);
  if (rcl == NULL)
  {
    return simple_color_get(type);
  }
 
  struct RegexColor *np = NULL;
  struct Mailbox *m_cur = get_current_mailbox();
  struct Email *e = mutt_get_virt_email(m_cur, index);
 
  if (type == MT_COLOR_INDEX_TAG)
  {
    struct AttrColor *ac_merge = NULL;
    STAILQ_FOREACH(np, rcl, entries)
    {
      if (mutt_strn_equal((const char *) (s + 1), np->pattern, strlen(np->pattern)))
      {
        ac_merge = merged_color_overlay(ac_merge, &np->attr_color);
        continue;
      }
      const char *transform = mutt_hash_find(TagTransforms, np->pattern);
      if (transform && mutt_strn_equal((const char *) (s + 1), transform, strlen(transform)))
      {
        ac_merge = merged_color_overlay(ac_merge, &np->attr_color);
      }
    }
    return ac_merge;
  }
 
  struct AttrColor *ac_merge = NULL;
  STAILQ_FOREACH(np, rcl, entries)
  {
    if (mutt_pattern_exec(SLIST_FIRST(np->color_pattern),
                          MUTT_MATCH_FULL_ADDRESS, m_cur, e, NULL))
    {
      ac_merge = merged_color_overlay(ac_merge, &np->attr_color);
    }
  }
 
  return ac_merge;
}
 
static void print_enriched_string(struct MuttWindow *win, int index,
                                  struct AttrColor *ac_def, struct AttrColor *ac_ind,
                                  unsigned char *s, struct ConfigSubset *sub)
{
  wchar_t wc = 0;
  size_t k;
  size_t n = mutt_str_len((char *) s);
  mbstate_t mbstate = { 0 };
 
  const bool c_ascii_chars = cs_subset_bool(sub, "ascii_chars");
  while (*s)
  {
    if (*s < MUTT_TREE_MAX)
    {
      struct AttrColor *ac_merge = merged_color_overlay(ac_def, simple_color_get(MT_COLOR_TREE));
      ac_merge = merged_color_overlay(ac_merge, ac_ind);
 
      /* Combining tree fg color and another bg color requires having
       * use_default_colors, because the other bg color may be undefined. */
      mutt_curses_set_color(ac_merge);
 
      while (*s && (*s < MUTT_TREE_MAX))
      {
        switch (*s)
        {
          case MUTT_TREE_LLCORNER:
            if (c_ascii_chars)
              mutt_window_addch(win, '`');
#ifdef WACS_LLCORNER
            else
              add_wch(WACS_LLCORNER);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\224"); /* WACS_LLCORNER */
            else
              mutt_window_addch(win, ACS_LLCORNER);
#endif
            break;
          case MUTT_TREE_ULCORNER:
            if (c_ascii_chars)
              mutt_window_addch(win, ',');
#ifdef WACS_ULCORNER
            else
              add_wch(WACS_ULCORNER);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\214"); /* WACS_ULCORNER */
            else
              mutt_window_addch(win, ACS_ULCORNER);
#endif
            break;
          case MUTT_TREE_LTEE:
            if (c_ascii_chars)
              mutt_window_addch(win, '|');
#ifdef WACS_LTEE
            else
              add_wch(WACS_LTEE);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\234"); /* WACS_LTEE */
            else
              mutt_window_addch(win, ACS_LTEE);
#endif
            break;
          case MUTT_TREE_HLINE:
            if (c_ascii_chars)
              mutt_window_addch(win, '-');
#ifdef WACS_HLINE
            else
              add_wch(WACS_HLINE);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\200"); /* WACS_HLINE */
            else
              mutt_window_addch(win, ACS_HLINE);
#endif
            break;
          case MUTT_TREE_VLINE:
            if (c_ascii_chars)
              mutt_window_addch(win, '|');
#ifdef WACS_VLINE
            else
              add_wch(WACS_VLINE);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\202"); /* WACS_VLINE */
            else
              mutt_window_addch(win, ACS_VLINE);
#endif
            break;
          case MUTT_TREE_TTEE:
            if (c_ascii_chars)
              mutt_window_addch(win, '-');
#ifdef WACS_TTEE
            else
              add_wch(WACS_TTEE);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\254"); /* WACS_TTEE */
            else
              mutt_window_addch(win, ACS_TTEE);
#endif
            break;
          case MUTT_TREE_BTEE:
            if (c_ascii_chars)
              mutt_window_addch(win, '-');
#ifdef WACS_BTEE
            else
              add_wch(WACS_BTEE);
#else
            else if (CharsetIsUtf8)
              mutt_window_addstr(win, "\342\224\264"); /* WACS_BTEE */
            else
              mutt_window_addch(win, ACS_BTEE);
#endif
            break;
          case MUTT_TREE_SPACE:
            mutt_window_addch(win, ' ');
            break;
          case MUTT_TREE_RARROW:
            mutt_window_addch(win, '>');
            break;
          case MUTT_TREE_STAR:
            mutt_window_addch(win, '*'); /* fake thread indicator */
            break;
          case MUTT_TREE_HIDDEN:
            mutt_window_addch(win, '&');
            break;
          case MUTT_TREE_EQUALS:
            mutt_window_addch(win, '=');
            break;
          case MUTT_TREE_MISSING:
            mutt_window_addch(win, '?');
            break;
        }
        s++;
        n--;
      }
      ac_merge = merged_color_overlay(ac_def, ac_ind);
      mutt_curses_set_color(ac_merge);
    }
    else if (*s == MUTT_SPECIAL_INDEX)
    {
      s++;
      if (*s == MT_COLOR_INDEX)
      {
        struct AttrColor *ac_merge = merged_color_overlay(ac_def, ac_ind);
        mutt_curses_set_color(ac_merge);
      }
      else
      {
        struct AttrColor *color = get_color(index, s);
        struct AttrColor *ac_merge = merged_color_overlay(ac_def, color);
        ac_merge = merged_color_overlay(ac_merge, ac_ind);
 
        mutt_curses_set_color(ac_merge);
      }
      s++;
      n -= 2;
    }
    else if ((k = mbrtowc(&wc, (char *) s, n, &mbstate)) > 0)
    {
      mutt_window_addnstr(win, (char *) s, k);
      s += k;
      n -= k;
    }
    else
      break;
  }
}
 
static void menu_pad_string(struct Menu *menu, char *buf, size_t buflen)
{
  char *scratch = mutt_str_dup(buf);
  const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
  const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
  int shift = c_arrow_cursor ? mutt_strwidth(c_arrow_string) + 1 : 0;
  int cols = menu->win->state.cols - shift;
 
  mutt_simple_format(buf, buflen, cols, cols, JUSTIFY_LEFT, ' ', scratch,
                     mutt_str_len(scratch), true);
  buf[buflen - 1] = '\0';
  FREE(&scratch);
}
 
void menu_redraw_full(struct Menu *menu)
{
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  mutt_window_clear(menu->win);
 
  menu->page_len = menu->win->state.rows;
 
  menu->redraw = MENU_REDRAW_INDEX;
}
 
void menu_redraw_index(struct Menu *menu)
{
  char buf[1024] = { 0 };
  struct AttrColor *ac = NULL;
 
  const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
  const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
  struct AttrColor *ac_ind = simple_color_get(MT_COLOR_INDICATOR);
  for (int i = menu->top; i < (menu->top + menu->page_len); i++)
  {
    if (i < menu->max)
    {
      ac = menu->color(menu, i);
 
      menu->make_entry(menu, buf, sizeof(buf), i);
      menu_pad_string(menu, buf, sizeof(buf));
 
      mutt_curses_set_color(ac);
      mutt_window_move(menu->win, 0, i - menu->top);
 
      if (i == menu->current)
        mutt_curses_set_color(ac_ind);
 
      if (c_arrow_cursor)
      {
        if (i == menu->current)
        {
          mutt_window_addstr(menu->win, c_arrow_string);
          mutt_curses_set_color(ac);
          mutt_window_addch(menu->win, ' ');
        }
        else
        {
          /* Print space chars to match the screen width of `$arrow_string` */
          mutt_window_printf(menu->win, "%*s", mutt_strwidth(c_arrow_string) + 1, "");
        }
      }
 
      if ((i == menu->current) && !c_arrow_cursor)
        print_enriched_string(menu->win, i, ac, ac_ind, (unsigned char *) buf, menu->sub);
      else
        print_enriched_string(menu->win, i, ac, NULL, (unsigned char *) buf, menu->sub);
    }
    else
    {
      mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
      mutt_window_clearline(menu->win, i - menu->top);
    }
  }
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  menu->redraw = MENU_REDRAW_NO_FLAGS;
}
 
void menu_redraw_motion(struct Menu *menu)
{
  char buf[1024] = { 0 };
 
  /* Note: menu->color() for the index can end up retrieving a message
   * over imap (if matching against ~h for instance).  This can
   * generate status messages.  So we want to call it *before* we
   * position the cursor for drawing. */
  struct AttrColor *old_color = menu->color(menu, menu->old_current);
  mutt_window_move(menu->win, 0, menu->old_current - menu->top);
  mutt_curses_set_color(old_color);
 
  const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
  const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
  struct AttrColor *ac_ind = simple_color_get(MT_COLOR_INDICATOR);
  if (c_arrow_cursor)
  {
    /* clear the arrow */
    /* Print space chars to match the screen width of `$arrow_string` */
    mutt_window_printf(menu->win, "%*s", mutt_strwidth(c_arrow_string) + 1, "");
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
 
    menu->make_entry(menu, buf, sizeof(buf), menu->old_current);
    menu_pad_string(menu, buf, sizeof(buf));
    mutt_window_move(menu->win, mutt_strwidth(c_arrow_string) + 1,
                     menu->old_current - menu->top);
    print_enriched_string(menu->win, menu->old_current, old_color, NULL,
                          (unsigned char *) buf, menu->sub);
 
    /* now draw it in the new location */
    mutt_curses_set_color(ac_ind);
    mutt_window_mvaddstr(menu->win, 0, menu->current - menu->top, c_arrow_string);
  }
  else
  {
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    /* erase the current indicator */
    menu->make_entry(menu, buf, sizeof(buf), menu->old_current);
    menu_pad_string(menu, buf, sizeof(buf));
    print_enriched_string(menu->win, menu->old_current, old_color, NULL,
                          (unsigned char *) buf, menu->sub);
 
    /* now draw the new one to reflect the change */
    struct AttrColor *cur_color = menu->color(menu, menu->current);
    cur_color = merged_color_overlay(cur_color, ac_ind);
    menu->make_entry(menu, buf, sizeof(buf), menu->current);
    menu_pad_string(menu, buf, sizeof(buf));
    mutt_window_move(menu->win, 0, menu->current - menu->top);
    mutt_curses_set_color(cur_color);
    print_enriched_string(menu->win, menu->current, cur_color, ac_ind,
                          (unsigned char *) buf, menu->sub);
  }
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
}
 
void menu_redraw_current(struct Menu *menu)
{
  char buf[1024] = { 0 };
  struct AttrColor *ac = menu->color(menu, menu->current);
 
  mutt_window_move(menu->win, 0, menu->current - menu->top);
  menu->make_entry(menu, buf, sizeof(buf), menu->current);
  menu_pad_string(menu, buf, sizeof(buf));
 
  struct AttrColor *ac_ind = simple_color_get(MT_COLOR_INDICATOR);
  const bool c_arrow_cursor = cs_subset_bool(menu->sub, "arrow_cursor");
  const char *const c_arrow_string = cs_subset_string(menu->sub, "arrow_string");
  if (c_arrow_cursor)
  {
    mutt_curses_set_color(ac_ind);
    mutt_window_addstr(menu->win, c_arrow_string);
    mutt_curses_set_color(ac);
    mutt_window_addch(menu->win, ' ');
    menu_pad_string(menu, buf, sizeof(buf));
    print_enriched_string(menu->win, menu->current, ac, NULL,
                          (unsigned char *) buf, menu->sub);
  }
  else
  {
    print_enriched_string(menu->win, menu->current, ac, ac_ind,
                          (unsigned char *) buf, menu->sub);
  }
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
}
 
int menu_redraw(struct Menu *menu)
{
  /* See if all or part of the screen needs to be updated.  */
  if (menu->redraw & MENU_REDRAW_FULL)
    menu_redraw_full(menu);
 
  if (menu->redraw & MENU_REDRAW_INDEX)
    menu_redraw_index(menu);
  else if (menu->redraw & MENU_REDRAW_MOTION)
    menu_redraw_motion(menu);
  else if (menu->redraw == MENU_REDRAW_CURRENT)
    menu_redraw_current(menu);
 
  return OP_NULL;
}