commands.c File Reference

Parse colour commands. More...

#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "commands.h"
#include "parse/lib.h"
#include "attr.h"
#include "color.h"
#include "debug.h"
#include "dump.h"
#include "globals.h"
#include "module_data.h"
#include "notify2.h"
#include "parse_color.h"
#include "regex4.h"
#include "simple2.h"

Include dependency graph for commands.c:

Go to the source code of this file.

Functions
void	get_colorid_name (unsigned int cid, struct Buffer *buf)
	Get the name of a Colour ID.
static enum CommandResult	parse_object (const struct Command *cmd, struct Buffer *line, enum ColorId *cid, struct Buffer *err)
	Identify a colour object.
enum CommandResult	parse_uncolor_command (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse an 'uncolor' command - Implements Command::parse() -.
static enum CommandResult	parse_color_command (const struct Command *cmd, struct Buffer *line, struct Buffer *err, parser_callback_t callback)
	Parse a 'color' command.
enum CommandResult	parse_uncolor (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'uncolor' command - Implements Command::parse() -.
enum CommandResult	parse_unmono (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmono' command - Implements Command::parse() -.
enum CommandResult	parse_color (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'color' command - Implements Command::parse() -.
enum CommandResult	parse_mono (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'mono' command - Implements Command::parse() -.

Variables
const struct Mapping	ColorFields []
	Mapping of colour names to their IDs.
const struct Command	ColorCommands []
	Colour Commands.

Detailed Description

Parse colour commands.

Authors

• Pietro Cerutti
• Richard Russon
• Dennis Schön

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

Function Documentation

get_colorid_name()

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

Get the name of a Colour ID.

Parameters

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

Definition at line 128 of file commands.c.

{
  const char *name = mutt_map_get_name(cid, ColorFields);
  if (name)
    buf_addstr(buf, name);
  else
    buf_printf(buf, "UNKNOWN %d", cid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_object()

static enum CommandResult parse_object ( const struct Command * cmd, struct Buffer * line, enum ColorId * cid, struct Buffer * err )

static

Identify a colour object.

Parameters

[in]	cmd	Command being parsed
[in]	line	Buffer containing string to be parsed
[out]	cid	Object type, e.g. MT_COLOR_TILDE
[out]	err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

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

Definition at line 147 of file commands.c.

{
  if (!MoreArgsF(line, TOKEN_COMMENT))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  parse_extract_token(token, line, TOKEN_NONE);
  color_debug(LL_DEBUG5, "color: %s\n", buf_string(token));
 
  if (mutt_istr_equal(buf_string(token), "compose"))
  {
    if (!MoreArgs(line))
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      buf_pool_release(&token);
      return MUTT_CMD_WARNING;
    }
 
    struct Buffer *suffix = buf_pool_get();
    parse_extract_token(suffix, line, TOKEN_NONE);
    buf_fix_dptr(token);
    buf_add_printf(token, "_%s", buf_string(suffix));
    buf_pool_release(&suffix);
  }
 
  int rc = mutt_map_get_value(buf_string(token), ColorFields);
  if (rc == -1)
  {
    buf_printf(err, _("%s: no such object"), buf_string(token));
    buf_pool_release(&token);
    return MUTT_CMD_WARNING;
  }
  else
  {
    color_debug(LL_DEBUG5, "object: %s\n", mutt_map_get_name(rc, ColorFields));
  }
 
  *cid = rc;
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_color_command()

static enum CommandResult parse_color_command ( const struct Command * cmd, struct Buffer * line, struct Buffer * err, parser_callback_t callback )

static

Parse a 'color' command.

Parameters

cmd	Command being parsed
line	Buffer containing string to be parsed
err	Buffer for error messages
callback	Function to handle command - Implements parser_callback_t

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Usage:

• color OBJECT [ ATTRS ] FG BG [ PATTERN | REGEX ] [ NUM ]
• mono OBJECT ATTRS [ PATTERN | REGEX ] [ NUM ]

Definition at line 292 of file commands.c.

{
  if (!cmd || !line || !err)
    return MUTT_CMD_ERROR;
 
  unsigned int match = 0;
  enum ColorId cid = MT_COLOR_NONE;
  enum CommandResult rc = MUTT_CMD_ERROR;
  struct AttrColor *ac = NULL;
  struct Buffer *token = buf_pool_get();
 
  if (!MoreArgs(line))
  {
    if (StartupComplete)
    {
      color_dump();
      rc = MUTT_CMD_SUCCESS;
    }
    else
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      rc = MUTT_CMD_WARNING;
    }
 
    goto done;
  }
 
  rc = parse_object(cmd, line, &cid, err);
  if (rc != MUTT_CMD_SUCCESS)
    goto done;
 
  ac = attr_color_new();
  rc = callback(cmd, line, ac, err);
  if (rc != MUTT_CMD_SUCCESS)
    goto done;
 
  //------------------------------------------------------------------
  // Business Logic
 
  rc = MUTT_CMD_ERROR;
  if ((ac->fg.type == CT_RGB) || (ac->bg.type == CT_RGB))
  {
#ifndef NEOMUTT_DIRECT_COLORS
    buf_printf(err, _("Direct colors support not compiled in: %s"), buf_string(line));
    goto done;
#endif
 
    const bool c_color_directcolor = cs_subset_bool(NeoMutt->sub, "color_directcolor");
    if (!c_color_directcolor)
    {
      buf_printf(err, _("Direct colors support disabled: %s"), buf_string(line));
      goto done;
    }
  }
 
  if ((ac->fg.color >= COLORS) || (ac->bg.color >= COLORS))
  {
    buf_printf(err, _("%s: color not supported by term"), buf_string(line));
    goto done;
  }
 
  //------------------------------------------------------------------
 
  /* extract a regular expression if needed */
 
  if (mutt_color_has_pattern(cid) && (cid != MT_COLOR_STATUS))
  {
    color_debug(LL_DEBUG5, "regex needed\n");
    if (MoreArgs(line))
    {
      parse_extract_token(token, line, TOKEN_NONE);
    }
    else
    {
      buf_strcpy(token, ".*");
    }
  }
 
  if (MoreArgs(line) && (cid != MT_COLOR_STATUS))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto done;
  }
 
  if (regex_colors_parse_color_list(cid, buf_string(token), ac, &rc, err))
  {
    color_debug(LL_DEBUG5, "regex_colors_parse_color_list done\n");
    goto done;
    // do nothing
  }
  else if ((cid == MT_COLOR_STATUS) && MoreArgs(line))
  {
    color_debug(LL_DEBUG5, "status\n");
    /* '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 */
    parse_extract_token(token, line, TOKEN_NONE);
 
    if (MoreArgs(line))
    {
      struct Buffer *tmp = buf_pool_get();
      parse_extract_token(tmp, line, TOKEN_NONE);
      if (!mutt_str_atoui_full(buf_string(tmp), &match))
      {
        buf_printf(err, _("%s: invalid number: %s"), cmd->name, buf_string(tmp));
        buf_pool_release(&tmp);
        rc = MUTT_CMD_WARNING;
        goto done;
      }
      buf_pool_release(&tmp);
    }
 
    if (MoreArgs(line))
    {
      buf_printf(err, _("%s: too many arguments"), cmd->name);
      rc = MUTT_CMD_WARNING;
      goto done;
    }
 
    rc = regex_colors_parse_status_list(cid, buf_string(token), ac, match, err);
    goto done;
  }
  else // Remaining simple colours
  {
    color_debug(LL_DEBUG5, "simple\n");
    if (simple_color_set(cid, ac))
      rc = MUTT_CMD_SUCCESS;
    else
      rc = MUTT_CMD_ERROR;
  }
 
  if (rc == MUTT_CMD_SUCCESS)
  {
    get_colorid_name(cid, token);
    color_debug(LL_DEBUG5, "NT_COLOR_SET: %s\n", buf_string(token));
    struct ColorModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COLOR);
    struct EventColor ev_c = { cid, NULL };
    notify_send(mod_data->colors_notify, NT_COLOR, NT_COLOR_SET, &ev_c);
  }
 
done:
  attr_color_free(&ac);
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ColorFields

const struct Mapping ColorFields[]

Mapping of colour names to their IDs.

Definition at line 55 of file commands.c.

                                     {
  // clang-format off
  { "attachment",                MT_COLOR_ATTACHMENT },
  { "attach_headers",            MT_COLOR_ATTACH_HEADERS },
  { "body",                      MT_COLOR_BODY },
  { "bold",                      MT_COLOR_BOLD },
  { "compose_header",            MT_COLOR_COMPOSE_HEADER },
  { "compose_security_both",     MT_COLOR_COMPOSE_SECURITY_BOTH },
  { "compose_security_encrypt",  MT_COLOR_COMPOSE_SECURITY_ENCRYPT },
  { "compose_security_none",     MT_COLOR_COMPOSE_SECURITY_NONE },
  { "compose_security_sign",     MT_COLOR_COMPOSE_SECURITY_SIGN },
  { "error",                     MT_COLOR_ERROR },
  { "hdrdefault",                MT_COLOR_HDRDEFAULT },
  { "header",                    MT_COLOR_HEADER },
  { "index",                     MT_COLOR_INDEX },
  { "index_author",              MT_COLOR_INDEX_AUTHOR },
  { "index_collapsed",           MT_COLOR_INDEX_COLLAPSED },
  { "index_date",                MT_COLOR_INDEX_DATE },
  { "index_flags",               MT_COLOR_INDEX_FLAGS },
  { "index_label",               MT_COLOR_INDEX_LABEL },
  { "index_number",              MT_COLOR_INDEX_NUMBER },
  { "index_size",                MT_COLOR_INDEX_SIZE },
  { "index_subject",             MT_COLOR_INDEX_SUBJECT },
  { "index_tag",                 MT_COLOR_INDEX_TAG },
  { "index_tags",                MT_COLOR_INDEX_TAGS },
  { "indicator",                 MT_COLOR_INDICATOR },
  { "italic",                    MT_COLOR_ITALIC },
  { "markers",                   MT_COLOR_MARKERS },
  { "message",                   MT_COLOR_MESSAGE },
  { "normal",                    MT_COLOR_NORMAL },
  { "options",                   MT_COLOR_OPTIONS },
  { "progress",                  MT_COLOR_PROGRESS },
  { "prompt",                    MT_COLOR_PROMPT },
  { "quoted0",                   MT_COLOR_QUOTED0 },
  { "quoted1",                   MT_COLOR_QUOTED1 },
  { "quoted2",                   MT_COLOR_QUOTED2 },
  { "quoted3",                   MT_COLOR_QUOTED3 },
  { "quoted4",                   MT_COLOR_QUOTED4 },
  { "quoted5",                   MT_COLOR_QUOTED5 },
  { "quoted6",                   MT_COLOR_QUOTED6 },
  { "quoted7",                   MT_COLOR_QUOTED7 },
  { "quoted8",                   MT_COLOR_QUOTED8 },
  { "quoted9",                   MT_COLOR_QUOTED9 },
  { "search",                    MT_COLOR_SEARCH },
  { "sidebar_background",        MT_COLOR_SIDEBAR_BACKGROUND },
  { "sidebar_divider",           MT_COLOR_SIDEBAR_DIVIDER },
  { "sidebar_flagged",           MT_COLOR_SIDEBAR_FLAGGED },
  { "sidebar_highlight",         MT_COLOR_SIDEBAR_HIGHLIGHT },
  { "sidebar_indicator",         MT_COLOR_SIDEBAR_INDICATOR },
  { "sidebar_new",               MT_COLOR_SIDEBAR_NEW },
  { "sidebar_ordinary",          MT_COLOR_SIDEBAR_ORDINARY },
  { "sidebar_spool_file",        MT_COLOR_SIDEBAR_SPOOL_FILE },
  { "sidebar_unread",            MT_COLOR_SIDEBAR_UNREAD },
  { "signature",                 MT_COLOR_SIGNATURE },
  { "status",                    MT_COLOR_STATUS },
  { "stripe_even",               MT_COLOR_STRIPE_EVEN},
  { "stripe_odd",                MT_COLOR_STRIPE_ODD},
  { "tilde",                     MT_COLOR_TILDE },
  { "tree",                      MT_COLOR_TREE },
  { "underline",                 MT_COLOR_UNDERLINE },
  { "warning",                   MT_COLOR_WARNING },
  // Deprecated
  { "quoted",                    MT_COLOR_QUOTED0 },
  { "sidebar_spoolfile",         MT_COLOR_SIDEBAR_SPOOL_FILE },
  { NULL, 0 },
  // clang-format on
};

ColorCommands

const struct Command ColorCommands[]

Initial value:

= {
  
  { "color", CMD_COLOR, parse_color,
        N_("Define colors for the user interface"),
        N_("color <object> [ <attribute> ... ] <fg> <bg> [ <regex> [ <num> ]]"),
        "configuration.html#color" },
  { "mono", CMD_MONO, parse_mono,
        N_("Deprecated: Use `color` instead"),
        N_("mono <object> <attribute> [ <pattern> | <regex> ]"),
        "configuration.html#color-mono" },
  { "uncolor", CMD_UNCOLOR, parse_uncolor,
        N_("Remove a `color` definition"),
        N_("uncolor <object> { * | <pattern> ... }"),
        "configuration.html#color" },
  { "unmono", CMD_UNMONO, parse_unmono,
        N_("Deprecated: Use `uncolor` instead"),
        N_("unmono <object> { * | <pattern> ... }"),
        "configuration.html#color-mono" },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NONE },
  
}

Colour Commands.

Definition at line 571 of file commands.c.

                                       {
  // clang-format off
  { "color", CMD_COLOR, parse_color,
        N_("Define colors for the user interface"),
        N_("color <object> [ <attribute> ... ] <fg> <bg> [ <regex> [ <num> ]]"),
        "configuration.html#color" },
  { "mono", CMD_MONO, parse_mono,
        N_("Deprecated: Use `color` instead"),
        N_("mono <object> <attribute> [ <pattern> | <regex> ]"),
        "configuration.html#color-mono" },
  { "uncolor", CMD_UNCOLOR, parse_uncolor,
        N_("Remove a `color` definition"),
        N_("uncolor <object> { * | <pattern> ... }"),
        "configuration.html#color" },
  { "unmono", CMD_UNMONO, parse_unmono,
        N_("Deprecated: Use `uncolor` instead"),
        N_("unmono <object> { * | <pattern> ... }"),
        "configuration.html#color-mono" },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NONE },
  // clang-format on
};