command.c File Reference

Parse colour commands. More...

#include "config.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "init.h"
#include "options.h"

Include dependency graph for command.c:

Go to the source code of this file.

Functions
static enum CommandResult	parse_color_name (const char *s, uint32_t *col, int *attrs, bool is_fg, struct Buffer *err)
	Parse a colour name. More...
static enum CommandResult	parse_attr_spec (struct Buffer *buf, struct Buffer *s, uint32_t *fg, uint32_t *bg, int *attrs, struct Buffer *err)
	Parse an attribute description - Implements parser_callback_t -. More...
static enum CommandResult	parse_color_pair (struct Buffer *buf, struct Buffer *s, uint32_t *fg, uint32_t *bg, int *attrs, struct Buffer *err)
	Parse a pair of colours - Implements parser_callback_t -. More...
void	get_colorid_name (unsigned int cid, struct Buffer *buf)
	Get the name of a color id. More...
static enum CommandResult	parse_object (struct Buffer *buf, struct Buffer *s, enum ColorId *cid, int *ql, struct Buffer *err)
	Identify a colour object. More...
static bool	do_uncolor (struct Buffer *buf, struct Buffer *s, struct RegexColorList *cl, bool uncolor)
	Parse the 'uncolor' or 'unmono' command. More...
static enum CommandResult	parse_uncolor (struct Buffer *buf, struct Buffer *s, struct Buffer *err, bool uncolor)
	Parse an 'uncolor' command. More...
int	fgbgattr_to_color (int fg, int bg, int attrs)
	Convert a foreground, background, attribute triplet into a colour. More...
static enum CommandResult	parse_color (struct Buffer *buf, struct Buffer *s, struct Buffer *err, parser_callback_t callback, bool dry_run, bool color)
	Parse a 'color' command. More...
enum CommandResult	mutt_parse_uncolor (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'uncolor' command - Implements Command::parse() -. More...
enum CommandResult	mutt_parse_unmono (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unmono' command - Implements Command::parse() -. More...
enum CommandResult	mutt_parse_color (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'color' command - Implements Command::parse() -. More...
enum CommandResult	mutt_parse_mono (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'mono' command - Implements Command::parse() -. More...

Variables
const struct Mapping	ColorFields []
	Mapping of colour names to their IDs. More...
const struct Mapping	ComposeColorFields []
	Mapping of compose colour names to their IDs. More...

Detailed Description

Parse colour commands.

Authors

• Richard Russon

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

Function Documentation

parse_color_name()

static enum CommandResult parse_color_name ( const char *  s, uint32_t *  col, int *  attrs, bool  is_fg, struct Buffer *  err  )

static

Parse a colour name.

Parameters

[in]	s	String to parse
[out]	col	Number for 'colorNNN' colours
[out]	attrs	Attributes, e.g. A_UNDERLINE
[in]	is_fg	true if this is a foreground colour
[out]	err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Parse a colour name, such as "red", "brightgreen", "color123".

Definition at line 1 of file command.c.

{
  char *eptr = NULL;
  bool is_alert = false, is_bright = false, is_light = false;
  int clen;
 
  if ((clen = mutt_istr_startswith(s, "bright")))
  {
    is_bright = true;
    s += clen;
  }
  else if ((clen = mutt_istr_startswith(s, "alert")))
  {
    is_alert = true;
    is_bright = true;
    s += clen;
  }
  else if ((clen = mutt_istr_startswith(s, "light")))
  {
    is_light = true;
    s += clen;
  }
 
  /* allow aliases for xterm color resources */
  if ((clen = mutt_istr_startswith(s, "color")))
  {
    s += clen;
    *col = strtoul(s, &eptr, 10);
    if ((*s == '\0') || (*eptr != '\0') ||
        ((*col >= COLORS) && !OptNoCurses && has_colors()))
    {
      mutt_buffer_printf(err, _("%s: color not supported by term"), s);
      return MUTT_CMD_ERROR;
    }
  }
  else if ((*col = mutt_map_get_value(s, ColorNames)) == -1)
  {
    mutt_buffer_printf(err, _("%s: no such color"), s);
    return MUTT_CMD_WARNING;
  }
 
  if (is_bright || is_light)
  {
    if (is_alert)
    {
      *attrs |= A_BOLD;
      *attrs |= A_BLINK;
    }
    else if (is_fg)
    {
      if ((COLORS >= 16) && is_light)
      {
        if (*col <= 7)
        {
          /* Advance the color 0-7 by 8 to get the light version */
          *col += 8;
        }
      }
      else
      {
        *attrs |= A_BOLD;
      }
    }
    else if (!(*col & RGB24))
    {
      if (COLORS >= 16)
      {
        if (*col <= 7)
        {
          /* Advance the color 0-7 by 8 to get the light version */
          *col += 8;
        }
      }
    }
  }
 
  return MUTT_CMD_SUCCESS;
}

get_colorid_name()

void get_colorid_name	(	unsigned int	cid,
		struct Buffer *	buf
	)

Get the name of a color id.

Parameters

cid	Colour, e.g. MT_COLOR_HEADER
buf	Buffer for result

Definition at line 308 of file command.c.

{
  const char *name = NULL;
 
  if ((cid >= MT_COLOR_COMPOSE_HEADER) && (cid <= MT_COLOR_COMPOSE_SECURITY_SIGN))
  {
    name = mutt_map_get_name(cid, ComposeColorFields);
    if (name)
    {
      mutt_buffer_printf(buf, "compose %s", name);
      return;
    }
  }
 
  name = mutt_map_get_name(cid, ColorFields);
  if (name)
    mutt_buffer_printf(buf, "%s", name);
  else
    mutt_buffer_printf(buf, "UNKNOWN %d", cid);
}

Here is the call graph for this function:

parse_object()

static enum CommandResult parse_object ( struct Buffer *  buf, struct Buffer *  s, enum ColorId *  cid, int *  ql, struct Buffer *  err  )

static

Identify a colour object.

Parameters

[in]	buf	Temporary Buffer space
[in]	s	Buffer containing string to be parsed
[out]	cid	Object type, e.g. MT_COLOR_TILDE
[out]	ql	Quote level, if type MT_COLOR_QUOTED
[out]	err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Identify a colour object, e.g. "quoted", "compose header"

Definition at line 308 of file command.c.

{
  int rc;
 
  if (mutt_str_startswith(buf->data, "quoted") != 0)
  {
    int val = 0;
    if (buf->data[6] != '\0')
    {
      if (!mutt_str_atoi_full(buf->data + 6, &val) || (val > COLOR_QUOTES_MAX))
      {
        mutt_buffer_printf(err, _("%s: no such object"), buf->data);
        return MUTT_CMD_WARNING;
      }
    }
 
    *ql = val;
    *cid = MT_COLOR_QUOTED;
    return MUTT_CMD_SUCCESS;
  }
 
  if (mutt_istr_equal(buf->data, "compose"))
  {
    if (!MoreArgs(s))
    {
      mutt_buffer_printf(err, _("%s: too few arguments"), "color");
      return MUTT_CMD_WARNING;
    }
 
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
 
    rc = mutt_map_get_value(buf->data, ComposeColorFields);
    if (rc == -1)
    {
      mutt_buffer_printf(err, _("%s: no such object"), buf->data);
      return MUTT_CMD_WARNING;
    }
 
    *cid = rc;
    return MUTT_CMD_SUCCESS;
  }
 
  rc = mutt_map_get_value(buf->data, ColorFields);
  if (rc == -1)
  {
    mutt_buffer_printf(err, _("%s: no such object"), buf->data);
    return MUTT_CMD_WARNING;
  }
 
  *cid = rc;
  return MUTT_CMD_SUCCESS;
}

do_uncolor()

static bool do_uncolor ( struct Buffer *  buf, struct Buffer *  s, struct RegexColorList *  cl, bool  uncolor  )

static

Parse the 'uncolor' or 'unmono' command.

Parameters

buf	Buffer for temporary storage
s	Buffer containing the uncolor command
cl	List of existing colours
uncolor	If true, 'uncolor', else 'unmono'

Return values

true	A colour was freed

Definition at line 402 of file command.c.

{
  struct RegexColor *np = NULL, *prev = NULL;
  bool rc = false;
 
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf->data))
    {
      rc = STAILQ_FIRST(cl);
      regex_color_list_clear(cl);
      return rc;
    }
 
    prev = NULL;
    STAILQ_FOREACH(np, cl, entries)
    {
      if (mutt_str_equal(buf->data, np->pattern))
      {
        rc = true;
 
        mutt_debug(LL_DEBUG1, "Freeing pattern \"%s\" from user_colors\n", buf->data);
        if (prev)
          STAILQ_REMOVE_AFTER(cl, prev, entries);
        else
          STAILQ_REMOVE_HEAD(cl, entries);
        regex_color_free(&np, uncolor);
        break;
      }
      prev = np;
    }
  } while (MoreArgs(s));
 
  return rc;
}

Here is the call graph for this function:

parse_uncolor()

static enum CommandResult parse_uncolor ( struct Buffer *  buf, struct Buffer *  s, struct Buffer *  err, bool  uncolor  )

static

Parse an 'uncolor' command.

Parameters

buf	Temporary Buffer space
s	Buffer containing string to be parsed
err	Buffer for error messages
uncolor	If true, 'uncolor', else 'unmono'

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Usage:

• uncolor index pattern [pattern...]
• unmono index pattern [pattern...]

Definition at line 402 of file command.c.

{
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
 
  if (mutt_str_equal(buf->data, "*"))
  {
    mutt_debug(LL_NOTIFY, "NT_COLOR_RESET: [ALL]\n");
    colors_clear();
    struct EventColor ev_c = { MT_COLOR_MAX };
    notify_send(ColorsNotify, NT_COLOR, NT_COLOR_RESET, &ev_c);
    return MUTT_CMD_SUCCESS;
  }
 
  unsigned int cid = MT_COLOR_NONE;
  int ql = 0;
  enum CommandResult rc = parse_object(buf, s, &cid, &ql, err);
  if (rc != MUTT_CMD_SUCCESS)
    return rc;
 
  if (cid == -1)
  {
    mutt_buffer_printf(err, _("%s: no such object"), buf->data);
    return MUTT_CMD_ERROR;
  }
 
  if (cid == MT_COLOR_QUOTED)
  {
    QuotedColors[ql] = A_NORMAL;
    /* fallthrough to simple case */
  }
 
  if ((cid != MT_COLOR_ATTACH_HEADERS) && (cid != MT_COLOR_BODY) &&
      (cid != MT_COLOR_HEADER) && (cid != MT_COLOR_INDEX) && (cid != MT_COLOR_INDEX_AUTHOR) &&
      (cid != MT_COLOR_INDEX_FLAGS) && (cid != MT_COLOR_INDEX_SUBJECT) &&
      (cid != MT_COLOR_INDEX_TAG) && (cid != MT_COLOR_STATUS))
  {
    // Simple colours
    SimpleColors[cid] = A_NORMAL;
 
    get_colorid_name(cid, buf);
    mutt_debug(LL_NOTIFY, "NT_COLOR_RESET: %s\n", buf->data);
    struct EventColor ev_c = { cid };
    notify_send(ColorsNotify, NT_COLOR, NT_COLOR_RESET, &ev_c);
    return MUTT_CMD_SUCCESS;
  }
 
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), uncolor ? "uncolor" : "unmono");
    return MUTT_CMD_WARNING;
  }
 
  if (OptNoCurses ||                // running without curses
      (uncolor && !has_colors()) || // parsing an uncolor command, and have no colors
      (!uncolor && has_colors())) // parsing an unmono command, and have colors
  {
    do
    {
      /* just eat the command, but don't do anything real about it */
      mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    } while (MoreArgs(s));
 
    return MUTT_CMD_SUCCESS;
  }
 
  bool changed = false;
  if (cid == MT_COLOR_ATTACH_HEADERS)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_ATTACH_HEADERS), uncolor);
  else if (cid == MT_COLOR_BODY)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_BODY), uncolor);
  else if (cid == MT_COLOR_HEADER)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_HEADER), uncolor);
  else if (cid == MT_COLOR_INDEX)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_INDEX), uncolor);
  else if (cid == MT_COLOR_INDEX_AUTHOR)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_INDEX_AUTHOR), uncolor);
  else if (cid == MT_COLOR_INDEX_FLAGS)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_INDEX_FLAGS), uncolor);
  else if (cid == MT_COLOR_INDEX_SUBJECT)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_INDEX_SUBJECT), uncolor);
  else if (cid == MT_COLOR_INDEX_TAG)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_INDEX_TAG), uncolor);
  else if (cid == MT_COLOR_STATUS)
    changed |= do_uncolor(buf, s, regex_colors_get_list(MT_COLOR_STATUS), uncolor);
 
  if (changed)
  {
    get_colorid_name(cid, buf);
    mutt_debug(LL_NOTIFY, "NT_COLOR_RESET: %s\n", buf->data);
    struct EventColor ev_c = { cid };
    notify_send(ColorsNotify, NT_COLOR, NT_COLOR_RESET, &ev_c);
  }
 
  return MUTT_CMD_SUCCESS;
}

fgbgattr_to_color()

int fgbgattr_to_color	(	int	fg,
		int	bg,
		int	attrs
	)

Convert a foreground, background, attribute triplet into a colour.

Parameters

fg	Foreground colour ID
bg	Background colour ID
attrs	Attribute flags, e.g. A_BOLD

Return values

num	Combined colour pair

Definition at line 556 of file command.c.

{
  if ((fg != COLOR_UNSET) && (bg != COLOR_UNSET))
    return attrs | mutt_color_alloc(fg, bg);
  return attrs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_color()

static enum CommandResult parse_color ( struct Buffer *  buf, struct Buffer *  s, struct Buffer *  err, parser_callback_t  callback, bool  dry_run, bool  color  )

static

Parse a 'color' command.

Parameters

buf	Temporary Buffer space
s	Buffer containing string to be parsed
err	Buffer for error messages
callback	Function to handle command - Implements parser_callback_t
dry_run	If true, test the command, but don't apply it
color	If true "color", else "mono"

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Usage:

• color OBJECT [ ATTRS ] FG BG [ REGEX ]
• mono OBJECT ATTRS [ REGEX ]

Definition at line 556 of file command.c.

{
  int attrs = 0, q_level = 0;
  uint32_t fg = 0, bg = 0, match = 0;
  enum ColorId cid = MT_COLOR_NONE;
  enum CommandResult rc;
 
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "color");
    return MUTT_CMD_WARNING;
  }
 
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
 
  rc = parse_object(buf, s, &cid, &q_level, err);
  if (rc != MUTT_CMD_SUCCESS)
    return rc;
 
  rc = callback(buf, s, &fg, &bg, &attrs, err);
  if (rc != MUTT_CMD_SUCCESS)
    return rc;
 
  /* extract a regular expression if needed */
 
  if ((cid == MT_COLOR_ATTACH_HEADERS) || (cid == MT_COLOR_BODY) ||
      (cid == MT_COLOR_HEADER) || (cid == MT_COLOR_INDEX) ||
      (cid == MT_COLOR_INDEX_AUTHOR) || (cid == MT_COLOR_INDEX_FLAGS) ||
      (cid == MT_COLOR_INDEX_SUBJECT) || (cid == MT_COLOR_INDEX_TAG))
  {
    if (!MoreArgs(s))
    {
      mutt_buffer_printf(err, _("%s: too few arguments"), color ? "color" : "mono");
      return MUTT_CMD_WARNING;
    }
 
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  }
 
  if (MoreArgs(s) && (cid != MT_COLOR_STATUS))
  {
    mutt_buffer_printf(err, _("%s: too many arguments"), color ? "color" : "mono");
    return MUTT_CMD_WARNING;
  }
 
  if (dry_run)
  {
    *s->dptr = '\0'; /* fake that we're done parsing */
    return MUTT_CMD_SUCCESS;
  }
 
  if (!OptNoCurses &&
      has_colors()
      /* delay use_default_colors() until needed, since it initializes things */
      && ((fg == COLOR_DEFAULT) || (bg == COLOR_DEFAULT) || (cid == MT_COLOR_TREE)) &&
      (use_default_colors() != OK))
  /* the case of the tree cid is special, because a non-default fg color of
   * the tree element may be combined dynamically with the default bg color of
   * an index line, not necessarily defined in a rc file.  */
  {
    mutt_buffer_strcpy(err, _("default colors not supported"));
    return MUTT_CMD_ERROR;
  }
 
  if (regex_colors_parse_color_list(cid, buf->data, fg, bg, attrs, &rc, err))
  {
    // do nothing
  }
  else if (quoted_colors_parse_color(cid, fg, bg, attrs, q_level, &rc, err))
  {
    // do nothing
  }
  else if ((cid == MT_COLOR_STATUS) && MoreArgs(s))
  {
    /* 'color status fg bg' can have up to 2 arguments:
     * 0 arguments: sets the default status color (handled below by else part)
     * 1 argument : colorize pattern on match
     * 2 arguments: colorize nth submatch of pattern */
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
 
    if (MoreArgs(s))
    {
      struct Buffer tmp = mutt_buffer_make(0);
      mutt_extract_token(&tmp, s, MUTT_TOKEN_NO_FLAGS);
      if (!mutt_str_atoui_full(tmp.data, &match))
      {
        mutt_buffer_printf(err, _("%s: invalid number: %s"),
                           color ? "color" : "mono", tmp.data);
        mutt_buffer_dealloc(&tmp);
        return MUTT_CMD_WARNING;
      }
      mutt_buffer_dealloc(&tmp);
    }
 
    if (MoreArgs(s))
    {
      mutt_buffer_printf(err, _("%s: too many arguments"), color ? "color" : "mono");
      return MUTT_CMD_WARNING;
    }
 
    rc = regex_colors_parse_status_list(cid, buf->data, fg, bg, attrs, match, err);
  }
  else // Remaining simple colours
  {
    SimpleColors[cid] = fgbgattr_to_color(fg, bg, attrs);
    rc = MUTT_CMD_SUCCESS;
  }
 
  if (rc == MUTT_CMD_SUCCESS)
  {
    get_colorid_name(cid, buf);
    mutt_debug(LL_NOTIFY, "NT_COLOR_SET: %s\n", buf->data);
    struct EventColor ev_c = { cid };
    notify_send(ColorsNotify, NT_COLOR, NT_COLOR_SET, &ev_c);
  }
 
  return rc;
}

Variable Documentation

ColorFields

const struct Mapping ColorFields[]

Mapping of colour names to their IDs.

Definition at line 1 of file command.c.

ComposeColorFields

const struct Mapping ComposeColorFields[]

Initial value:

= {
  
  { "header",            MT_COLOR_COMPOSE_HEADER },
  { "security_encrypt",  MT_COLOR_COMPOSE_SECURITY_ENCRYPT },
  { "security_sign",     MT_COLOR_COMPOSE_SECURITY_SIGN },
  { "security_both",     MT_COLOR_COMPOSE_SECURITY_BOTH },
  { "security_none",     MT_COLOR_COMPOSE_SECURITY_NONE },
  { NULL, 0 }
  
}

Mapping of compose colour names to their IDs.

Definition at line 1 of file command.c.