attr.c

Go to the documentation of this file.

 
#include "config.h"
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "attr.h"
#include "color.h"
#include "curses2.h"
#include "debug.h"

void attr_color_clear(struct AttrColor *ac)
{
  if (!ac)
    return;
 
  if (ac->curses_color)
    color_debug(LL_DEBUG5, "clear %p\n", (void *) ac);
  curses_color_free(&ac->curses_color);
 
  memset(&ac->fg, 0, sizeof(ac->fg));
  memset(&ac->bg, 0, sizeof(ac->bg));
 
  ac->fg.color = COLOR_DEFAULT;
  ac->bg.color = COLOR_DEFAULT;
  ac->attrs = A_NORMAL;
}

void attr_color_free(struct AttrColor **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AttrColor *ac = *ptr;
  if (ac->ref_count > 1)
  {
    ac->ref_count--;
    *ptr = NULL;
    return;
  }
 
  attr_color_clear(ac);
  FREE(ptr);
}

struct AttrColor *attr_color_new(void)
{
  struct AttrColor *ac = MUTT_MEM_CALLOC(1, struct AttrColor);
 
  ac->fg.color = COLOR_DEFAULT;
  ac->fg.type = CT_SIMPLE;
  ac->fg.prefix = COLOR_PREFIX_NONE;
 
  ac->bg.color = COLOR_DEFAULT;
  ac->bg.type = CT_SIMPLE;
  ac->bg.prefix = COLOR_PREFIX_NONE;
 
  ac->attrs = A_NORMAL;
 
  ac->ref_count = 1;
 
  return ac;
}

void attr_color_list_clear(struct AttrColorList *acl)
{
  if (!acl)
    return;
 
  struct AttrColor *ac = NULL;
  struct AttrColor *tmp = NULL;
  TAILQ_FOREACH_SAFE(ac, acl, entries, tmp)
  {
    TAILQ_REMOVE(acl, ac, entries);
    attr_color_free(&ac);
  }
}

struct AttrColor *attr_color_list_find(struct AttrColorList *acl, color_t fg,
                                       color_t bg, int attrs)
{
  if (!acl)
    return NULL;
 
  struct AttrColor *ac = NULL;
  TAILQ_FOREACH(ac, acl, entries)
  {
    if (ac->attrs != attrs)
      continue;
 
    struct CursesColor *cc = ac->curses_color;
    if (!cc)
      continue;
 
    if ((cc->fg == fg) && (cc->bg == bg))
      return ac;
  }
  return NULL;
}

struct AttrColor attr_color_copy(const struct AttrColor *ac)
{
  if (ac)
    return *ac;
  else
    return (struct AttrColor) { 0 };
}

bool attr_color_is_set(const struct AttrColor *ac)
{
  if (!ac)
    return false;
 
  return ((ac->attrs != A_NORMAL) || ac->curses_color);
}

bool attr_color_match(struct AttrColor *ac1, struct AttrColor *ac2)
{
  if ((!ac1) ^ (!ac2)) // One is set, but not the other
    return false;
 
  if (!ac1) // Two empty colours match
    return true;
 
  return ((ac1->curses_color == ac2->curses_color) && (ac1->attrs == ac2->attrs));
}

void modify_color_by_prefix(enum ColorPrefix prefix, bool is_fg, color_t *col, int *attrs)
{
  if (prefix == COLOR_PREFIX_NONE)
    return; // nothing to do here
 
  if (prefix == COLOR_PREFIX_ALERT)
  {
    *attrs |= A_BOLD;
    *attrs |= A_BLINK;
  }
  else if (is_fg)
  {
    if ((COLORS >= 16) && (prefix == COLOR_PREFIX_LIGHT))
    {
      if (*col <= 7)
      {
        /* Advance the color 0-7 by 8 to get the light version */
        *col += 8;
      }
    }
    else
    {
      *attrs |= A_BOLD;
    }
  }
  else
  {
    if (COLORS >= 16)
    {
      if (*col <= 7)
      {
        /* Advance the color 0-7 by 8 to get the light version */
        *col += 8;
      }
    }
  }
}
 
#ifdef NEOMUTT_DIRECT_COLORS
color_t color_xterm256_to_24bit(const color_t color)
{
  static const color_t basic[] = {
    0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080,
    0x008080, 0xc0c0c0, 0x808080, 0xff0000, 0x00ff00, 0xffff00,
    0x0000ff, 0xff00ff, 0x00ffff, 0xffffff,
  };
 
  ASSERT(color < 256);
 
  if (color < 0)
    return color;
 
  const bool c_color_directcolor = cs_subset_bool(NeoMutt->sub, "color_directcolor");
  if (!c_color_directcolor)
  {
    return color;
  }
 
  if (color < 16)
  {
    color_debug(LL_DEBUG5, "Converted color 0-15: %d\n", color);
    /* The first 16 colours are the "usual" terminal colours */
    return basic[color];
  }
 
  if (color < 232)
  {
    /* The Color palette is divided in 6x6x6 colours, i.e. each R, G, B channel
     * has six values:
     *
     *  value: 1     2     3     4     5     6
     *  color: 0x00  0x5f  0x87  0xaf  0xd7  0xff
     *
     * The steps between the values is 0x28 = 40, the EXCEPT for the first one
     * where it is 0x5f = 95.
     *
     * If we express the xterm color number minus 16 to base 6, i.e.
     *
     *    color - 16 = (vr * 36) + (vg * 6) + (vb * 1)
     *
     * with vr, vg, vb integers between 0 and 5, then vr, vg, vb is the channel
     * value for red, green, and blue, respectively.
     */
 
    color_t normalised_color = color - 16;
    color_t vr = (normalised_color % 216) / 36; /* 216 = 6*6*6 */
    color_t vg = (normalised_color % 36) / 6;
    color_t vb = (normalised_color % 6) / 1;
 
    /* First step is wider than the other ones, so add the difference if needed */
    color_t r = (vr * 0x28) + ((vr > 0) ? (0x5f - 0x28) : 0);
    color_t g = (vg * 0x28) + ((vg > 0) ? (0x5f - 0x28) : 0);
    color_t b = (vb * 0x28) + ((vb > 0) ? (0x5f - 0x28) : 0);
 
    color_t rgb = (r << 16) + (g << 8) + (b << 0);
    color_debug(LL_DEBUG5, "Converted xterm color %d to RGB #%x:\n", color, rgb);
    return rgb;
  }
 
  /* Grey scale starts at 0x08 and adds 0xa = 10 in very step ending in 0xee.
   * There are a total of 6*4 = 24 grey colors in total. */
  color_t steps = color - 232;
  color_t grey = (steps * 0x0a) + 0x08;
  color_t rgb = (grey << 16) + (grey << 8) + (grey << 0);
  color_debug(LL_DEBUG5, "Converted xterm color %d to RGB #%x:\n", color, rgb);
  return rgb;
}
#endif

void attr_color_overwrite(struct AttrColor *ac_old, const struct AttrColor *ac_new)
{
  if (!ac_old || !ac_new)
    return;
 
  color_t fg = ac_new->fg.color;
  color_t bg = ac_new->bg.color;
  int attrs = ac_new->attrs;
 
  modify_color_by_prefix(ac_new->fg.prefix, true, &fg, &attrs);
  modify_color_by_prefix(ac_new->bg.prefix, false, &bg, &attrs);
 
#ifdef NEOMUTT_DIRECT_COLORS
  if ((ac_new->fg.type == CT_SIMPLE) || (ac_new->fg.type == CT_PALETTE))
    fg = color_xterm256_to_24bit(fg);
  else if (fg < 8)
    fg = 8;
  if ((ac_new->bg.type == CT_SIMPLE) || (ac_new->bg.type == CT_PALETTE))
    bg = color_xterm256_to_24bit(bg);
  else if (bg < 8)
    bg = 8;
#endif
 
  struct CursesColor *cc = curses_color_new(fg, bg);
  curses_color_free(&ac_old->curses_color);
  ac_old->fg = ac_new->fg;
  ac_old->bg = ac_new->bg;
  ac_old->attrs = attrs;
  ac_old->curses_color = cc;
}