mirror of
https://github.com/vim/vim
synced 2025-03-16 06:47:52 +01:00
Problem: Highlight groups PopupSelected/PopupNotification/ MessageWindow are supposed to fall back to default highlight groups if they are not defined. However, once a colorscheme has defined them, switching to another colorscheme that doesn't do so will leave behind a cleared colorscheme, which causes the fallback to fail. Solution: Set up default links to the relevant fallback highlight groups, which makes sure a `:hi clear` command will reset the state properly (Yee Cheng Chin). closes: #16676 Signed-off-by: Yee Cheng Chin <ychin.git@gmail.com> Signed-off-by: Christian Brabandt <cb@256bit.org>
4733 lines
124 KiB
C
4733 lines
124 KiB
C
/* vi:set ts=8 sts=4 sw=4 noet:
|
|
*
|
|
* VIM - Vi IMproved by Bram Moolenaar
|
|
*
|
|
* Do ":help uganda" in Vim to read copying and usage conditions.
|
|
* Do ":help credits" in Vim to see a list of people who contributed.
|
|
* See README.txt for an overview of the Vim source code.
|
|
*/
|
|
|
|
/*
|
|
* Highlighting stuff.
|
|
*/
|
|
|
|
#include "vim.h"
|
|
|
|
#define SG_TERM 1 // term has been set
|
|
#define SG_CTERM 2 // cterm has been set
|
|
#define SG_GUI 4 // gui has been set
|
|
#define SG_LINK 8 // link has been set
|
|
|
|
#define MAX_SYN_NAME 200
|
|
|
|
/*
|
|
* The "term", "cterm" and "gui" arguments can be any combination of the
|
|
* following names, separated by commas (but no spaces!).
|
|
*/
|
|
// must be sorted by the 'value' field because it is used by bsearch()!
|
|
// note: inverse and reverse use the same key
|
|
static keyvalue_T highlight_tab[] = {
|
|
KEYVALUE_ENTRY(HL_BOLD, "bold"), // index 0
|
|
KEYVALUE_ENTRY(HL_INVERSE, "inverse"), // index 1
|
|
KEYVALUE_ENTRY(HL_ITALIC, "italic"), // index 2
|
|
KEYVALUE_ENTRY(HL_NOCOMBINE, "nocombine"), // index 3
|
|
KEYVALUE_ENTRY(HL_NORMAL, "NONE"), // index 4
|
|
KEYVALUE_ENTRY(HL_INVERSE, "reverse"), // index 5
|
|
KEYVALUE_ENTRY(HL_STANDOUT, "standout"), // index 6
|
|
KEYVALUE_ENTRY(HL_STRIKETHROUGH, "strikethrough"), // index 7
|
|
KEYVALUE_ENTRY(HL_UNDERCURL, "undercurl"), // index 8
|
|
KEYVALUE_ENTRY(HL_UNDERDASHED, "underdashed"), // index 9
|
|
KEYVALUE_ENTRY(HL_UNDERDOTTED, "underdotted"), // index 10
|
|
KEYVALUE_ENTRY(HL_UNDERDOUBLE, "underdouble"), // index 11
|
|
KEYVALUE_ENTRY(HL_UNDERLINE, "underline") // index 12
|
|
};
|
|
|
|
// this table is used to display highlight names in the "correct" sequence.
|
|
// keep this in sync with highlight_tab[].
|
|
static keyvalue_T *highlight_index_tab[] = {
|
|
&highlight_tab[0], // HL_BOLD
|
|
&highlight_tab[6], // HL_STANDOUT
|
|
&highlight_tab[12], // HL_UNDERLINE
|
|
&highlight_tab[8], // HL_UNDERCURL
|
|
&highlight_tab[11], // HL_UNDERDOUBLE
|
|
&highlight_tab[10], // HL_UNDERDOTTED
|
|
&highlight_tab[9], // HL_UNDERDASHED
|
|
&highlight_tab[2], // HL_ITALIC
|
|
&highlight_tab[5], // HL_REVERSE
|
|
&highlight_tab[1], // HL_INVERSE
|
|
&highlight_tab[3], // HL_NOCOMBINE
|
|
&highlight_tab[7], // HL_STRIKETHROUGH
|
|
&highlight_tab[4] // HL_NORMAL
|
|
};
|
|
|
|
// length of all attribute names, plus commas, together (and a bit more)
|
|
#define MAX_ATTR_LEN 120
|
|
|
|
#define ATTR_COMBINE(attr_a, attr_b) ((((attr_b) & HL_NOCOMBINE) ? (attr_b) : (attr_a)) | (attr_b))
|
|
|
|
enum {
|
|
BLACK = 0,
|
|
DARKBLUE,
|
|
DARKGREEN,
|
|
DARKCYAN,
|
|
DARKRED,
|
|
DARKMAGENTA,
|
|
BROWN,
|
|
DARKYELLOW,
|
|
GRAY,
|
|
GREY,
|
|
LIGHTGRAY,
|
|
LIGHTGREY,
|
|
DARKGRAY,
|
|
DARKGREY,
|
|
BLUE,
|
|
LIGHTBLUE,
|
|
GREEN,
|
|
LIGHTGREEN,
|
|
CYAN,
|
|
LIGHTCYAN,
|
|
RED,
|
|
LIGHTRED,
|
|
MAGENTA,
|
|
LIGHTMAGENTA,
|
|
YELLOW,
|
|
LIGHTYELLOW,
|
|
WHITE,
|
|
NONE
|
|
};
|
|
|
|
// must be sorted by the 'value' field because it is used by bsearch()!
|
|
static keyvalue_T color_name_tab[] = {
|
|
KEYVALUE_ENTRY(BLACK, "Black"),
|
|
KEYVALUE_ENTRY(BLUE, "Blue"),
|
|
KEYVALUE_ENTRY(BROWN, "Brown"),
|
|
KEYVALUE_ENTRY(CYAN, "Cyan"),
|
|
KEYVALUE_ENTRY(DARKBLUE, "DarkBlue"),
|
|
KEYVALUE_ENTRY(DARKCYAN, "DarkCyan"),
|
|
KEYVALUE_ENTRY(DARKGRAY, "DarkGray"),
|
|
KEYVALUE_ENTRY(DARKGREEN, "DarkGreen"),
|
|
KEYVALUE_ENTRY(DARKGREY, "DarkGrey"),
|
|
KEYVALUE_ENTRY(DARKMAGENTA, "DarkMagenta"),
|
|
KEYVALUE_ENTRY(DARKRED, "DarkRed"),
|
|
KEYVALUE_ENTRY(DARKYELLOW, "DarkYellow"),
|
|
KEYVALUE_ENTRY(GRAY, "Gray"),
|
|
KEYVALUE_ENTRY(GREEN, "Green"),
|
|
KEYVALUE_ENTRY(GREY, "Grey"),
|
|
KEYVALUE_ENTRY(LIGHTBLUE, "LightBlue"),
|
|
KEYVALUE_ENTRY(LIGHTCYAN, "LightCyan"),
|
|
KEYVALUE_ENTRY(LIGHTGRAY, "LightGray"),
|
|
KEYVALUE_ENTRY(LIGHTGREEN, "LightGreen"),
|
|
KEYVALUE_ENTRY(LIGHTGREY, "LightGrey"),
|
|
KEYVALUE_ENTRY(LIGHTMAGENTA, "LightMagenta"),
|
|
KEYVALUE_ENTRY(LIGHTRED, "LightRed"),
|
|
KEYVALUE_ENTRY(LIGHTYELLOW, "LightYellow"),
|
|
KEYVALUE_ENTRY(MAGENTA, "Magenta"),
|
|
KEYVALUE_ENTRY(NONE, "NONE"),
|
|
KEYVALUE_ENTRY(RED, "Red"),
|
|
KEYVALUE_ENTRY(WHITE, "White"),
|
|
KEYVALUE_ENTRY(YELLOW, "Yellow")
|
|
};
|
|
|
|
/*
|
|
* Structure that stores information about a highlight group.
|
|
* The ID of a highlight group is also called group ID. It is the index in
|
|
* the highlight_ga array PLUS ONE.
|
|
*/
|
|
typedef struct
|
|
{
|
|
char_u *sg_name; // highlight group name
|
|
char_u *sg_name_u; // uppercase of sg_name
|
|
int sg_cleared; // "hi clear" was used
|
|
// for normal terminals
|
|
int sg_term; // "term=" highlighting attributes
|
|
char_u *sg_start; // terminal string for start highl
|
|
char_u *sg_stop; // terminal string for stop highl
|
|
int sg_term_attr; // Screen attr for term mode
|
|
// for color terminals
|
|
int sg_cterm; // "cterm=" highlighting attr
|
|
int sg_cterm_bold; // bold attr was set for light color
|
|
int sg_cterm_fg; // terminal fg color number + 1
|
|
int sg_cterm_bg; // terminal bg color number + 1
|
|
int sg_cterm_ul; // terminal ul color number + 1
|
|
int sg_cterm_attr; // Screen attr for color term mode
|
|
int sg_cterm_font; // terminal alternative font (0 for normal)
|
|
// for when using the GUI
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
guicolor_T sg_gui_fg; // GUI foreground color handle
|
|
guicolor_T sg_gui_bg; // GUI background color handle
|
|
guicolor_T sg_gui_sp; // GUI special color handle
|
|
#endif
|
|
#ifdef FEAT_GUI
|
|
GuiFont sg_font; // GUI font handle
|
|
#ifdef FEAT_XFONTSET
|
|
GuiFontset sg_fontset; // GUI fontset handle
|
|
#endif
|
|
char_u *sg_font_name; // GUI font or fontset name
|
|
int sg_gui_attr; // Screen attr for GUI mode
|
|
#endif
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
// Store the sp color name for the GUI or synIDattr()
|
|
int sg_gui; // "gui=" highlighting attributes
|
|
char_u *sg_gui_fg_name;// GUI foreground color name
|
|
char_u *sg_gui_bg_name;// GUI background color name
|
|
char_u *sg_gui_sp_name;// GUI special color name
|
|
#endif
|
|
int sg_link; // link to this highlight group ID
|
|
int sg_deflink; // default link; restored in highlight_clear()
|
|
int sg_set; // combination of SG_* flags
|
|
#ifdef FEAT_EVAL
|
|
sctx_T sg_deflink_sctx; // script where the default link was set
|
|
sctx_T sg_script_ctx; // script in which the group was last set
|
|
#endif
|
|
} hl_group_T;
|
|
|
|
// highlight groups for 'highlight' option
|
|
static garray_T highlight_ga;
|
|
#define HL_TABLE() ((hl_group_T *)((highlight_ga.ga_data)))
|
|
|
|
/*
|
|
* An attribute number is the index in attr_table plus ATTR_OFF.
|
|
*/
|
|
#define ATTR_OFF (HL_ALL + 1)
|
|
|
|
static void syn_unadd_group(void);
|
|
static void set_hl_attr(int idx);
|
|
static void highlight_list_one(int id);
|
|
static int highlight_list_arg(int id, int didh, int type, int iarg, char_u *sarg, char *name);
|
|
static int syn_add_group(char_u *name);
|
|
static int hl_has_settings(int idx, int check_link);
|
|
static void highlight_clear(int idx);
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
static void gui_do_one_color(int idx, int do_menu, int do_tooltip);
|
|
#endif
|
|
#ifdef FEAT_GUI
|
|
static int set_group_colors(char_u *name, guicolor_T *fgp, guicolor_T *bgp, int do_menu, int use_norm, int do_tooltip);
|
|
static void hl_do_font(int idx, char_u *arg, int do_normal, int do_menu, int do_tooltip, int free_font);
|
|
#endif
|
|
|
|
/*
|
|
* The default highlight groups. These are compiled-in for fast startup and
|
|
* they still work when the runtime files can't be found.
|
|
* When making changes here, also change runtime/colors/default.vim!
|
|
* The #ifdefs are needed to reduce the amount of static data. Helps to make
|
|
* the 16 bit DOS (museum) version compile.
|
|
*/
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
# define CENT(a, b) b
|
|
#else
|
|
# define CENT(a, b) a
|
|
#endif
|
|
static char *(highlight_init_both[]) = {
|
|
CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White",
|
|
"ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"),
|
|
CENT("IncSearch term=reverse cterm=reverse",
|
|
"IncSearch term=reverse cterm=reverse gui=reverse"),
|
|
CENT("ModeMsg term=bold cterm=bold",
|
|
"ModeMsg term=bold cterm=bold gui=bold"),
|
|
CENT("NonText term=bold ctermfg=Blue",
|
|
"NonText term=bold ctermfg=Blue gui=bold guifg=Blue"),
|
|
CENT("StatusLine term=reverse,bold cterm=reverse,bold",
|
|
"StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"),
|
|
CENT("StatusLineNC term=reverse cterm=reverse",
|
|
"StatusLineNC term=reverse cterm=reverse gui=reverse"),
|
|
"default link EndOfBuffer NonText",
|
|
CENT("VertSplit term=reverse cterm=reverse",
|
|
"VertSplit term=reverse cterm=reverse gui=reverse"),
|
|
#ifdef FEAT_CLIPBOARD
|
|
CENT("VisualNOS term=underline,bold cterm=underline,bold",
|
|
"VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"),
|
|
#endif
|
|
#ifdef FEAT_DIFF
|
|
CENT("DiffText term=reverse cterm=bold ctermbg=Red",
|
|
"DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"),
|
|
#endif
|
|
CENT("PmenuSbar ctermbg=Grey",
|
|
"PmenuSbar ctermbg=Grey guibg=Grey"),
|
|
CENT("TabLineSel term=bold cterm=bold",
|
|
"TabLineSel term=bold cterm=bold gui=bold"),
|
|
CENT("TabLineFill term=reverse cterm=reverse",
|
|
"TabLineFill term=reverse cterm=reverse gui=reverse"),
|
|
#ifdef FEAT_GUI
|
|
"Cursor guibg=fg guifg=bg",
|
|
"lCursor guibg=fg guifg=bg", // should be different, but what?
|
|
#endif
|
|
"default link QuickFixLine Search",
|
|
"default link CursorLineSign SignColumn",
|
|
"default link CursorLineFold FoldColumn",
|
|
"default link CurSearch Search",
|
|
"default link PmenuKind Pmenu",
|
|
"default link PmenuKindSel PmenuSel",
|
|
"default link PmenuMatch Pmenu",
|
|
"default link PmenuMatchSel PmenuSel",
|
|
"default link PmenuExtra Pmenu",
|
|
"default link PmenuExtraSel PmenuSel",
|
|
"default link PopupSelected PmenuSel",
|
|
"default link MessageWindow WarningMsg",
|
|
"default link PopupNotification WarningMsg",
|
|
CENT("Normal cterm=NONE", "Normal gui=NONE"),
|
|
NULL
|
|
};
|
|
|
|
// Default colors only used with a light background.
|
|
static char *(highlight_init_light[]) = {
|
|
CENT("Directory term=bold ctermfg=DarkBlue",
|
|
"Directory term=bold ctermfg=DarkBlue guifg=Blue"),
|
|
CENT("LineNr term=underline ctermfg=Brown",
|
|
"LineNr term=underline ctermfg=Brown guifg=Brown"),
|
|
CENT("CursorLineNr term=bold cterm=underline ctermfg=Brown",
|
|
"CursorLineNr term=bold cterm=underline ctermfg=Brown gui=bold guifg=Brown"),
|
|
CENT("MoreMsg term=bold ctermfg=DarkGreen",
|
|
"MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
|
|
CENT("Question term=standout ctermfg=DarkGreen",
|
|
"Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
|
|
CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE",
|
|
"Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"),
|
|
#ifdef FEAT_SPELL
|
|
CENT("SpellBad term=reverse ctermbg=LightRed",
|
|
"SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"),
|
|
CENT("SpellCap term=reverse ctermbg=LightBlue",
|
|
"SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"),
|
|
CENT("SpellRare term=reverse ctermbg=LightMagenta",
|
|
"SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"),
|
|
CENT("SpellLocal term=underline ctermbg=Cyan",
|
|
"SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"),
|
|
#endif
|
|
CENT("PmenuThumb ctermbg=Black",
|
|
"PmenuThumb ctermbg=Black guibg=Black"),
|
|
CENT("Pmenu ctermbg=LightMagenta ctermfg=Black",
|
|
"Pmenu ctermbg=LightMagenta ctermfg=Black guibg=LightMagenta"),
|
|
CENT("PmenuSel ctermbg=LightGrey ctermfg=Black",
|
|
"PmenuSel ctermbg=LightGrey ctermfg=Black guibg=Grey"),
|
|
CENT("SpecialKey term=bold ctermfg=DarkBlue",
|
|
"SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"),
|
|
CENT("Title term=bold ctermfg=DarkMagenta",
|
|
"Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"),
|
|
CENT("WarningMsg term=standout ctermfg=DarkRed",
|
|
"WarningMsg term=standout ctermfg=DarkRed guifg=Red"),
|
|
CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
|
|
"WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
|
|
#ifdef FEAT_FOLDING
|
|
CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue",
|
|
"Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"),
|
|
CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
|
|
"FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
|
|
#endif
|
|
#ifdef FEAT_SIGNS
|
|
CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
|
|
"SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
|
|
#endif
|
|
CENT("Visual ctermbg=Grey ctermfg=Black",
|
|
"Visual ctermbg=Grey ctermfg=Black guibg=LightGrey guifg=Black"),
|
|
#ifdef FEAT_DIFF
|
|
CENT("DiffAdd term=bold ctermbg=LightBlue",
|
|
"DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"),
|
|
CENT("DiffChange term=bold ctermbg=LightMagenta",
|
|
"DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"),
|
|
CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan",
|
|
"DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"),
|
|
#endif
|
|
CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey",
|
|
"TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"),
|
|
#ifdef FEAT_SYN_HL
|
|
CENT("CursorColumn term=reverse ctermbg=LightGrey",
|
|
"CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"),
|
|
CENT("CursorLine term=underline cterm=underline",
|
|
"CursorLine term=underline cterm=underline guibg=Grey90"),
|
|
CENT("ColorColumn term=reverse ctermbg=LightRed",
|
|
"ColorColumn term=reverse ctermbg=LightRed guibg=LightRed"),
|
|
#endif
|
|
#ifdef FEAT_CONCEAL
|
|
CENT("Conceal ctermbg=DarkGrey ctermfg=LightGrey",
|
|
"Conceal ctermbg=DarkGrey ctermfg=LightGrey guibg=DarkGrey guifg=LightGrey"),
|
|
#endif
|
|
CENT("MatchParen term=reverse ctermbg=Cyan",
|
|
"MatchParen term=reverse ctermbg=Cyan guibg=Cyan"),
|
|
#ifdef FEAT_TERMINAL
|
|
CENT("StatusLineTerm term=reverse,bold cterm=bold ctermfg=White ctermbg=DarkGreen",
|
|
"StatusLineTerm term=reverse,bold cterm=bold ctermfg=White ctermbg=DarkGreen gui=bold guifg=bg guibg=DarkGreen"),
|
|
CENT("StatusLineTermNC term=reverse ctermfg=White ctermbg=DarkGreen",
|
|
"StatusLineTermNC term=reverse ctermfg=White ctermbg=DarkGreen guifg=bg guibg=DarkGreen"),
|
|
#endif
|
|
#ifdef FEAT_MENU
|
|
CENT("ToolbarLine term=underline ctermbg=LightGrey",
|
|
"ToolbarLine term=underline ctermbg=LightGrey guibg=LightGrey"),
|
|
CENT("ToolbarButton cterm=bold ctermfg=White ctermbg=DarkGrey",
|
|
"ToolbarButton cterm=bold ctermfg=White ctermbg=DarkGrey gui=bold guifg=White guibg=Grey40"),
|
|
#endif
|
|
NULL
|
|
};
|
|
|
|
// Default colors only used with a dark background.
|
|
static char *(highlight_init_dark[]) = {
|
|
CENT("Directory term=bold ctermfg=LightCyan",
|
|
"Directory term=bold ctermfg=LightCyan guifg=Cyan"),
|
|
CENT("LineNr term=underline ctermfg=Yellow",
|
|
"LineNr term=underline ctermfg=Yellow guifg=Yellow"),
|
|
CENT("CursorLineNr term=bold cterm=underline ctermfg=Yellow",
|
|
"CursorLineNr term=bold cterm=underline ctermfg=Yellow gui=bold guifg=Yellow"),
|
|
CENT("MoreMsg term=bold ctermfg=LightGreen",
|
|
"MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"),
|
|
CENT("Question term=standout ctermfg=LightGreen",
|
|
"Question term=standout ctermfg=LightGreen gui=bold guifg=Green"),
|
|
CENT("Search term=reverse ctermbg=Yellow ctermfg=Black",
|
|
"Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
|
|
CENT("SpecialKey term=bold ctermfg=LightBlue",
|
|
"SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"),
|
|
#ifdef FEAT_SPELL
|
|
CENT("SpellBad term=reverse ctermbg=Red",
|
|
"SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"),
|
|
CENT("SpellCap term=reverse ctermbg=Blue",
|
|
"SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"),
|
|
CENT("SpellRare term=reverse ctermbg=Magenta",
|
|
"SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"),
|
|
CENT("SpellLocal term=underline ctermbg=Cyan",
|
|
"SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"),
|
|
#endif
|
|
CENT("PmenuThumb ctermbg=White",
|
|
"PmenuThumb ctermbg=White guibg=White"),
|
|
CENT("Pmenu ctermbg=Magenta ctermfg=Black",
|
|
"Pmenu ctermbg=Magenta ctermfg=Black guibg=Magenta"),
|
|
CENT("PmenuSel ctermbg=Black ctermfg=DarkGrey",
|
|
"PmenuSel ctermbg=Black ctermfg=DarkGrey guibg=DarkGrey"),
|
|
CENT("Title term=bold ctermfg=LightMagenta",
|
|
"Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"),
|
|
CENT("WarningMsg term=standout ctermfg=LightRed",
|
|
"WarningMsg term=standout ctermfg=LightRed guifg=Red"),
|
|
CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
|
|
"WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
|
|
#ifdef FEAT_FOLDING
|
|
CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan",
|
|
"Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"),
|
|
CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
|
|
"FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
|
|
#endif
|
|
#ifdef FEAT_SIGNS
|
|
CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
|
|
"SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
|
|
#endif
|
|
CENT("Visual ctermbg=Grey ctermfg=Black",
|
|
"Visual ctermbg=Grey ctermfg=Black guibg=#575757 guifg=LightGrey"),
|
|
#ifdef FEAT_DIFF
|
|
CENT("DiffAdd term=bold ctermbg=DarkBlue",
|
|
"DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"),
|
|
CENT("DiffChange term=bold ctermbg=DarkMagenta",
|
|
"DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"),
|
|
CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan",
|
|
"DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"),
|
|
#endif
|
|
CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey",
|
|
"TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"),
|
|
#ifdef FEAT_SYN_HL
|
|
CENT("CursorColumn term=reverse ctermbg=DarkGrey",
|
|
"CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"),
|
|
CENT("CursorLine term=underline cterm=underline",
|
|
"CursorLine term=underline cterm=underline guibg=Grey40"),
|
|
CENT("ColorColumn term=reverse ctermbg=DarkRed",
|
|
"ColorColumn term=reverse ctermbg=DarkRed guibg=DarkRed"),
|
|
#endif
|
|
CENT("MatchParen term=reverse ctermbg=DarkCyan",
|
|
"MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"),
|
|
#ifdef FEAT_CONCEAL
|
|
CENT("Conceal ctermbg=DarkGrey ctermfg=LightGrey",
|
|
"Conceal ctermbg=DarkGrey ctermfg=LightGrey guibg=DarkGrey guifg=LightGrey"),
|
|
#endif
|
|
#ifdef FEAT_TERMINAL
|
|
CENT("StatusLineTerm term=reverse,bold cterm=bold ctermfg=Black ctermbg=LightGreen",
|
|
"StatusLineTerm term=reverse,bold cterm=bold ctermfg=Black ctermbg=LightGreen gui=bold guifg=bg guibg=LightGreen"),
|
|
CENT("StatusLineTermNC term=reverse ctermfg=Black ctermbg=LightGreen",
|
|
"StatusLineTermNC term=reverse ctermfg=Black ctermbg=LightGreen guifg=bg guibg=LightGreen"),
|
|
#endif
|
|
#ifdef FEAT_MENU
|
|
CENT("ToolbarLine term=underline ctermbg=DarkGrey",
|
|
"ToolbarLine term=underline ctermbg=DarkGrey guibg=Grey50"),
|
|
CENT("ToolbarButton cterm=bold ctermfg=Black ctermbg=LightGrey",
|
|
"ToolbarButton cterm=bold ctermfg=Black ctermbg=LightGrey gui=bold guifg=Black guibg=LightGrey"),
|
|
#endif
|
|
NULL
|
|
};
|
|
|
|
#if defined(FEAT_SYN_HL) || defined(PROTO)
|
|
/*
|
|
* Returns the number of highlight groups.
|
|
*/
|
|
int
|
|
highlight_num_groups(void)
|
|
{
|
|
return highlight_ga.ga_len;
|
|
}
|
|
|
|
/*
|
|
* Returns the name of a highlight group.
|
|
*/
|
|
char_u *
|
|
highlight_group_name(int id)
|
|
{
|
|
return HL_TABLE()[id].sg_name;
|
|
}
|
|
|
|
/*
|
|
* Returns the ID of the link to a highlight group.
|
|
*/
|
|
int
|
|
highlight_link_id(int id)
|
|
{
|
|
return HL_TABLE()[id].sg_link;
|
|
}
|
|
#endif
|
|
|
|
void
|
|
init_highlight(
|
|
int both, // include groups where 'bg' doesn't matter
|
|
int reset) // clear group first
|
|
{
|
|
int i;
|
|
char **pp;
|
|
static int had_both = FALSE;
|
|
#ifdef FEAT_EVAL
|
|
char_u *p;
|
|
|
|
// Try finding the color scheme file. Used when a color file was loaded
|
|
// and 'background' or 't_Co' is changed.
|
|
p = get_var_value((char_u *)"g:colors_name");
|
|
if (p != NULL)
|
|
{
|
|
// The value of g:colors_name could be freed when sourcing the script,
|
|
// making "p" invalid, so copy it.
|
|
char_u *copy_p = vim_strsave(p);
|
|
int r;
|
|
|
|
if (copy_p != NULL)
|
|
{
|
|
r = load_colors(copy_p);
|
|
vim_free(copy_p);
|
|
if (r == OK)
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// Didn't use a color file, use the compiled-in colors.
|
|
if (both)
|
|
{
|
|
had_both = TRUE;
|
|
pp = highlight_init_both;
|
|
for (i = 0; pp[i] != NULL; ++i)
|
|
do_highlight((char_u *)pp[i], reset, TRUE);
|
|
}
|
|
else if (!had_both)
|
|
// Don't do anything before the call with both == TRUE from main().
|
|
// Not everything has been setup then, and that call will overrule
|
|
// everything anyway.
|
|
return;
|
|
|
|
if (*p_bg == 'l')
|
|
pp = highlight_init_light;
|
|
else
|
|
pp = highlight_init_dark;
|
|
for (i = 0; pp[i] != NULL; ++i)
|
|
do_highlight((char_u *)pp[i], reset, TRUE);
|
|
|
|
// Reverse looks ugly, but grey may not work for less than 8 colors. Thus
|
|
// let it depend on the number of colors available.
|
|
if (t_colors < 8)
|
|
do_highlight((char_u *)"Visual term=reverse cterm=reverse ctermbg=NONE ctermfg=NONE",
|
|
FALSE, TRUE);
|
|
// With 8 colors brown is equal to yellow, need to use black for Search fg
|
|
// to avoid Statement highlighted text disappears.
|
|
// Clear the attributes, needed when changing the t_Co value.
|
|
if (t_colors <= 8)
|
|
{
|
|
if (*p_bg == 'l')
|
|
do_highlight((char_u *)"Search ctermfg=black", FALSE, TRUE);
|
|
}
|
|
|
|
#ifdef FEAT_SYN_HL
|
|
// If syntax highlighting is enabled load the highlighting for it.
|
|
if (get_var_value((char_u *)"g:syntax_on") != NULL)
|
|
{
|
|
static int recursive = 0;
|
|
|
|
if (recursive >= 5)
|
|
emsg(_(e_recursive_loop_loading_syncolor_vim));
|
|
else
|
|
{
|
|
++recursive;
|
|
(void)source_runtime((char_u *)"syntax/syncolor.vim", DIP_ALL);
|
|
--recursive;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if defined(FEAT_EVAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
|
|
/*
|
|
* Load a default color list. Intended to support legacy color names but allows
|
|
* the user to override the color values. Only loaded once.
|
|
*/
|
|
static void
|
|
load_default_colors_lists(void)
|
|
{
|
|
// Lacking a default color list isn't the end of the world but it is likely
|
|
// an inconvenience so users should know when it is missing.
|
|
if (source_runtime((char_u *)"colors/lists/default.vim", DIP_ALL) != OK)
|
|
msg("failed to load colors/lists/default.vim");
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Load color file "name".
|
|
* Return OK for success, FAIL for failure.
|
|
*/
|
|
int
|
|
load_colors(char_u *name)
|
|
{
|
|
char_u *buf;
|
|
int retval = FAIL;
|
|
static int recursive = FALSE;
|
|
|
|
// When being called recursively, this is probably because setting
|
|
// 'background' caused the highlighting to be reloaded. This means it is
|
|
// working, thus we should return OK.
|
|
if (recursive)
|
|
return OK;
|
|
|
|
recursive = TRUE;
|
|
buf = alloc(STRLEN(name) + 12);
|
|
if (buf != NULL)
|
|
{
|
|
#if defined(FEAT_EVAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS))
|
|
load_default_colors_lists();
|
|
#endif
|
|
apply_autocmds(EVENT_COLORSCHEMEPRE, name,
|
|
curbuf->b_fname, FALSE, curbuf);
|
|
sprintf((char *)buf, "colors/%s.vim", name);
|
|
retval = source_runtime(buf, DIP_START + DIP_OPT);
|
|
vim_free(buf);
|
|
if (retval == OK)
|
|
apply_autocmds(EVENT_COLORSCHEME, name, curbuf->b_fname,
|
|
FALSE, curbuf);
|
|
}
|
|
recursive = FALSE;
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int color_numbers_16[28] = {0, 1, 2, 3,
|
|
4, 5, 6, 6,
|
|
7, 7, 7, 7,
|
|
8, 8,
|
|
9, 9, 10, 10,
|
|
11, 11, 12, 12, 13,
|
|
13, 14, 14, 15, -1};
|
|
// for xterm with 88 colors...
|
|
static int color_numbers_88[28] = {0, 4, 2, 6,
|
|
1, 5, 32, 72,
|
|
84, 84, 7, 7,
|
|
82, 82,
|
|
12, 43, 10, 61,
|
|
14, 63, 9, 74, 13,
|
|
75, 11, 78, 15, -1};
|
|
// for xterm with 256 colors...
|
|
static int color_numbers_256[28] = {0, 4, 2, 6,
|
|
1, 5, 130, 3,
|
|
248, 248, 7, 7,
|
|
242, 242,
|
|
12, 81, 10, 121,
|
|
14, 159, 9, 224, 13,
|
|
225, 11, 229, 15, -1};
|
|
// for terminals with less than 16 colors...
|
|
static int color_numbers_8[28] = {0, 4, 2, 6,
|
|
1, 5, 3, 3,
|
|
7, 7, 7, 7,
|
|
0+8, 0+8,
|
|
4+8, 4+8, 2+8, 2+8,
|
|
6+8, 6+8, 1+8, 1+8, 5+8,
|
|
5+8, 3+8, 3+8, 7+8, -1};
|
|
|
|
/*
|
|
* Lookup the "cterm" value to be used for color with index "idx" in
|
|
* color_name_tab[].
|
|
* "boldp" will be set to TRUE or FALSE for a foreground color when using 8
|
|
* colors, otherwise it will be unchanged.
|
|
*/
|
|
static int
|
|
lookup_color(int idx, int foreground, int *boldp)
|
|
{
|
|
int color = color_numbers_16[idx];
|
|
char_u *p;
|
|
|
|
// Use the _16 table to check if it's a valid color name.
|
|
if (color < 0)
|
|
return -1;
|
|
|
|
if (t_colors == 8)
|
|
{
|
|
// t_Co is 8: use the 8 colors table
|
|
#if defined(__QNXNTO__)
|
|
// On qnx, the 8 & 16 color arrays are the same
|
|
if (STRNCMP(T_NAME, "qansi", 5) == 0)
|
|
color = color_numbers_16[idx];
|
|
else
|
|
#endif
|
|
color = color_numbers_8[idx];
|
|
if (foreground)
|
|
{
|
|
// set/reset bold attribute to get light foreground
|
|
// colors (on some terminals, e.g. "linux")
|
|
if (color & 8)
|
|
*boldp = TRUE;
|
|
else
|
|
*boldp = FALSE;
|
|
}
|
|
color &= 7; // truncate to 8 colors
|
|
}
|
|
else if (t_colors == 16 || t_colors == 88
|
|
|| t_colors >= 256)
|
|
{
|
|
// Guess: if the termcap entry ends in 'm', it is
|
|
// probably an xterm-like terminal. Use the changed
|
|
// order for colors.
|
|
if (*T_CAF != NUL)
|
|
p = T_CAF;
|
|
else
|
|
p = T_CSF;
|
|
if (*p != NUL && (t_colors > 256
|
|
|| *(p + STRLEN(p) - 1) == 'm'))
|
|
{
|
|
if (t_colors == 88)
|
|
color = color_numbers_88[idx];
|
|
else if (t_colors >= 256)
|
|
color = color_numbers_256[idx];
|
|
else
|
|
color = color_numbers_8[idx];
|
|
}
|
|
#ifdef FEAT_TERMRESPONSE
|
|
if (t_colors >= 256 && color == 15 && is_mac_terminal)
|
|
// Terminal.app has a bug: 15 is light grey. Use white
|
|
// from the color cube instead.
|
|
color = 231;
|
|
#endif
|
|
}
|
|
return color;
|
|
}
|
|
|
|
/*
|
|
* Link highlight group 'from_hg' to 'to_hg'.
|
|
* 'dodefault' is set to TRUE for ":highlight default link".
|
|
* 'forceit' is set to TRUE for ":highlight! link"
|
|
* 'init' is set to TRUE when initializing all the highlight groups.
|
|
*/
|
|
static void
|
|
highlight_group_link(
|
|
char_u *from_hg,
|
|
int from_len,
|
|
char_u *to_hg,
|
|
int to_len,
|
|
int dodefault,
|
|
int forceit,
|
|
int init)
|
|
{
|
|
int from_id;
|
|
int to_id;
|
|
hl_group_T *hlgroup = NULL;
|
|
|
|
from_id = syn_check_group(from_hg, from_len);
|
|
if (STRNCMP(to_hg, "NONE", 4) == 0)
|
|
to_id = 0;
|
|
else
|
|
to_id = syn_check_group(to_hg, to_len);
|
|
|
|
if (from_id > 0)
|
|
{
|
|
hlgroup = &HL_TABLE()[from_id - 1];
|
|
if (dodefault && (forceit || hlgroup->sg_deflink == 0))
|
|
{
|
|
hlgroup->sg_deflink = to_id;
|
|
#ifdef FEAT_EVAL
|
|
hlgroup->sg_deflink_sctx = current_sctx;
|
|
hlgroup->sg_deflink_sctx.sc_lnum += SOURCING_LNUM;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (from_id > 0 && (!init || hlgroup->sg_set == 0))
|
|
{
|
|
// Don't allow a link when there already is some highlighting
|
|
// for the group, unless '!' is used
|
|
if (to_id > 0 && !forceit && !init
|
|
&& hl_has_settings(from_id - 1, dodefault))
|
|
{
|
|
if (SOURCING_NAME == NULL && !dodefault)
|
|
emsg(_(e_group_has_settings_highlight_link_ignored));
|
|
}
|
|
else if (hlgroup->sg_link != to_id
|
|
#ifdef FEAT_EVAL
|
|
|| hlgroup->sg_script_ctx.sc_sid != current_sctx.sc_sid
|
|
#endif
|
|
|| hlgroup->sg_cleared)
|
|
{
|
|
if (!init)
|
|
hlgroup->sg_set |= SG_LINK;
|
|
hlgroup->sg_link = to_id;
|
|
#ifdef FEAT_EVAL
|
|
hlgroup->sg_script_ctx = current_sctx;
|
|
hlgroup->sg_script_ctx.sc_lnum += SOURCING_LNUM;
|
|
#endif
|
|
hlgroup->sg_cleared = FALSE;
|
|
redraw_all_later(UPD_SOME_VALID);
|
|
|
|
// Only call highlight_changed() once after multiple changes.
|
|
need_highlight_changed = TRUE;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Reset all highlighting to the defaults. Removes all highlighting for the
|
|
* groups added by the user.
|
|
*/
|
|
static void
|
|
highlight_reset_all(void)
|
|
{
|
|
int idx;
|
|
|
|
#ifdef FEAT_GUI
|
|
// First, we do not destroy the old values, but allocate the new
|
|
// ones and update the display. THEN we destroy the old values.
|
|
// If we destroy the old values first, then the old values
|
|
// (such as GuiFont's or GuiFontset's) will still be displayed but
|
|
// invalid because they were free'd.
|
|
if (gui.in_use)
|
|
{
|
|
# ifdef FEAT_BEVAL_TIP
|
|
gui_init_tooltip_font();
|
|
# endif
|
|
# if defined(FEAT_MENU) && defined(FEAT_GUI_MOTIF)
|
|
gui_init_menu_font();
|
|
# endif
|
|
}
|
|
# if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11)
|
|
gui_mch_def_colors();
|
|
# endif
|
|
# ifdef FEAT_GUI_X11
|
|
# ifdef FEAT_MENU
|
|
|
|
// This only needs to be done when there is no Menu highlight
|
|
// group defined by default, which IS currently the case.
|
|
gui_mch_new_menu_colors();
|
|
# endif
|
|
if (gui.in_use)
|
|
{
|
|
gui_new_scrollbar_colors();
|
|
# ifdef FEAT_BEVAL_GUI
|
|
gui_mch_new_tooltip_colors();
|
|
# endif
|
|
# ifdef FEAT_MENU
|
|
gui_mch_new_menu_font();
|
|
# endif
|
|
}
|
|
# endif
|
|
|
|
// Ok, we're done allocating the new default graphics items.
|
|
// The screen should already be refreshed at this point.
|
|
// It is now Ok to clear out the old data.
|
|
#endif
|
|
#ifdef FEAT_EVAL
|
|
do_unlet((char_u *)"g:colors_name", TRUE);
|
|
#endif
|
|
restore_cterm_colors();
|
|
|
|
// Clear all default highlight groups and load the defaults.
|
|
for (idx = 0; idx < highlight_ga.ga_len; ++idx)
|
|
highlight_clear(idx);
|
|
init_highlight(TRUE, TRUE);
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
if (USE_24BIT)
|
|
highlight_gui_started();
|
|
else
|
|
#endif
|
|
highlight_changed();
|
|
redraw_later_clear();
|
|
}
|
|
|
|
/*
|
|
* Set the 'term' or 'cterm' or 'gui' attributes for the highlight group at
|
|
* index 'idx'.
|
|
* 'key' is one of 'TERM' or 'CTERM' or 'GUI'
|
|
* 'arg' is the list of attribute names separated by comma.
|
|
* 'init' is set to TRUE when initializing all the highlight groups.
|
|
* Returns TRUE if the attributes are set.
|
|
*/
|
|
static int
|
|
highlight_set_termgui_attr(int idx, char_u *key, char_u *arg, int init)
|
|
{
|
|
int attr;
|
|
size_t off;
|
|
keyvalue_T target;
|
|
keyvalue_T *entry;
|
|
|
|
attr = 0;
|
|
off = 0;
|
|
target.key = 0;
|
|
target.value.length = 0; // not used, see cmp_keyvalue_value_ni()
|
|
while (arg[off] != NUL)
|
|
{
|
|
target.value.string = arg + off;
|
|
entry = (keyvalue_T *)bsearch(&target, &highlight_tab,
|
|
ARRAY_LENGTH(highlight_tab), sizeof(highlight_tab[0]),
|
|
cmp_keyvalue_value_ni);
|
|
if (entry == NULL)
|
|
{
|
|
semsg(_(e_illegal_value_str), arg);
|
|
return FALSE;
|
|
}
|
|
|
|
attr |= entry->key;
|
|
off += entry->value.length;
|
|
if (arg[off] == ',') // another one follows
|
|
++off;
|
|
}
|
|
if (*key == 'T')
|
|
{
|
|
if (!init || !(HL_TABLE()[idx].sg_set & SG_TERM))
|
|
{
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_TERM;
|
|
HL_TABLE()[idx].sg_term = attr;
|
|
}
|
|
}
|
|
else if (*key == 'C')
|
|
{
|
|
if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM))
|
|
{
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_CTERM;
|
|
HL_TABLE()[idx].sg_cterm = attr;
|
|
HL_TABLE()[idx].sg_cterm_bold = FALSE;
|
|
}
|
|
}
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
else
|
|
{
|
|
if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
|
|
{
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_GUI;
|
|
HL_TABLE()[idx].sg_gui = attr;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#ifdef FEAT_GUI
|
|
/*
|
|
* Set the font for the highlight group at 'idx'.
|
|
* 'arg' is the font name.
|
|
* Returns TRUE if the font is changed.
|
|
*/
|
|
static int
|
|
highlight_set_font(
|
|
int idx,
|
|
char_u *arg,
|
|
int is_normal_group,
|
|
int is_menu_group,
|
|
int is_tooltip_group)
|
|
{
|
|
int did_change = FALSE;
|
|
|
|
// in non-GUI fonts are simply ignored
|
|
if (HL_TABLE()[idx].sg_font_name != NULL
|
|
&& STRCMP(HL_TABLE()[idx].sg_font_name, arg) == 0)
|
|
{
|
|
// Font name didn't change, ignore.
|
|
}
|
|
else if (!gui.shell_created)
|
|
{
|
|
// GUI not started yet, always accept the name.
|
|
vim_free(HL_TABLE()[idx].sg_font_name);
|
|
HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
|
|
did_change = TRUE;
|
|
}
|
|
else
|
|
{
|
|
GuiFont temp_sg_font = HL_TABLE()[idx].sg_font;
|
|
# ifdef FEAT_XFONTSET
|
|
GuiFontset temp_sg_fontset = HL_TABLE()[idx].sg_fontset;
|
|
# endif
|
|
// First, save the current font/fontset.
|
|
// Then try to allocate the font/fontset.
|
|
// If the allocation fails, HL_TABLE()[idx].sg_font OR
|
|
// sg_fontset will be set to NOFONT or NOFONTSET respectively.
|
|
|
|
HL_TABLE()[idx].sg_font = NOFONT;
|
|
# ifdef FEAT_XFONTSET
|
|
HL_TABLE()[idx].sg_fontset = NOFONTSET;
|
|
# endif
|
|
hl_do_font(idx, arg, is_normal_group, is_menu_group,
|
|
is_tooltip_group, FALSE);
|
|
|
|
# ifdef FEAT_XFONTSET
|
|
if (HL_TABLE()[idx].sg_fontset != NOFONTSET)
|
|
{
|
|
// New fontset was accepted. Free the old one, if there
|
|
// was one.
|
|
gui_mch_free_fontset(temp_sg_fontset);
|
|
vim_free(HL_TABLE()[idx].sg_font_name);
|
|
HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
|
|
did_change = TRUE;
|
|
}
|
|
else
|
|
HL_TABLE()[idx].sg_fontset = temp_sg_fontset;
|
|
# endif
|
|
if (HL_TABLE()[idx].sg_font != NOFONT)
|
|
{
|
|
// New font was accepted. Free the old one, if there was
|
|
// one.
|
|
gui_mch_free_font(temp_sg_font);
|
|
vim_free(HL_TABLE()[idx].sg_font_name);
|
|
HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
|
|
did_change = TRUE;
|
|
}
|
|
else
|
|
HL_TABLE()[idx].sg_font = temp_sg_font;
|
|
}
|
|
|
|
return did_change;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Set the cterm foreground color for the Normal highlight group to "color" and
|
|
* the bold attribute to "bold".
|
|
*/
|
|
static void
|
|
hl_set_ctermfg_normal_group(int color, int bold)
|
|
{
|
|
cterm_normal_fg_color = color + 1;
|
|
cterm_normal_fg_bold = bold;
|
|
#ifdef FEAT_GUI
|
|
// Don't do this if the GUI is used.
|
|
if (!gui.in_use && !gui.starting)
|
|
#endif
|
|
{
|
|
set_must_redraw(UPD_CLEAR);
|
|
if (termcap_active && color >= 0)
|
|
term_fg_color(color);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the cterm foreground color for the highlight group at 'idx' to 'color'.
|
|
*/
|
|
static void
|
|
highlight_set_ctermfg(int idx, int color, int is_normal_group)
|
|
{
|
|
HL_TABLE()[idx].sg_cterm_fg = color + 1;
|
|
if (is_normal_group)
|
|
hl_set_ctermfg_normal_group(color,
|
|
(HL_TABLE()[idx].sg_cterm & HL_BOLD));
|
|
}
|
|
|
|
/*
|
|
* Set the cterm background color for the Normal highlight group to "color".
|
|
*/
|
|
static void
|
|
hl_set_ctermbg_normal_group(int color)
|
|
{
|
|
cterm_normal_bg_color = color + 1;
|
|
#ifdef FEAT_GUI
|
|
// Don't mess with 'background' if the GUI is used.
|
|
if (!gui.in_use && !gui.starting)
|
|
#endif
|
|
{
|
|
set_must_redraw(UPD_CLEAR);
|
|
if (color >= 0)
|
|
{
|
|
int dark = -1;
|
|
|
|
if (termcap_active)
|
|
term_bg_color(color);
|
|
if (t_colors < 16)
|
|
dark = (color == 0 || color == 4);
|
|
// Limit the heuristic to the standard 16 colors
|
|
else if (color < 16)
|
|
dark = (color < 7 || color == 8);
|
|
// Set the 'background' option if the value is
|
|
// wrong.
|
|
if (dark != -1
|
|
&& dark != (*p_bg == 'd')
|
|
&& !option_was_set((char_u *)"bg"))
|
|
{
|
|
set_option_value_give_err((char_u *)"bg",
|
|
0L, (char_u *)(dark ? "dark" : "light"), 0);
|
|
reset_option_was_set((char_u *)"bg");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the cterm background color for the highlight group at 'idx' to 'color'.
|
|
*/
|
|
static void
|
|
highlight_set_ctermbg(int idx, int color, int is_normal_group)
|
|
{
|
|
HL_TABLE()[idx].sg_cterm_bg = color + 1;
|
|
if (is_normal_group)
|
|
hl_set_ctermbg_normal_group(color);
|
|
}
|
|
|
|
/*
|
|
* Set the cterm underline color for the Normal highlight group to "color".
|
|
*/
|
|
static void
|
|
hl_set_ctermul_normal_group(int color)
|
|
{
|
|
cterm_normal_ul_color = color + 1;
|
|
#ifdef FEAT_GUI
|
|
// Don't do this if the GUI is used.
|
|
if (!gui.in_use && !gui.starting)
|
|
#endif
|
|
{
|
|
set_must_redraw(UPD_CLEAR);
|
|
if (termcap_active && color >= 0)
|
|
term_ul_color(color);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the cterm underline color for the highlight group at 'idx' to 'color'.
|
|
*/
|
|
static void
|
|
highlight_set_ctermul(int idx, int color, int is_normal_group)
|
|
{
|
|
HL_TABLE()[idx].sg_cterm_ul = color + 1;
|
|
if (is_normal_group)
|
|
hl_set_ctermul_normal_group(color);
|
|
}
|
|
|
|
/*
|
|
* Set the cterm font for the highlight group at 'idx'.
|
|
* 'arg' is the color name or the numeric value as a string.
|
|
* 'init' is set to TRUE when initializing highlighting.
|
|
* Called for the ":highlight" command and the "hlset()" function.
|
|
*
|
|
* Returns TRUE if the font is set.
|
|
*/
|
|
static int
|
|
highlight_set_cterm_font(
|
|
int idx,
|
|
char_u *arg,
|
|
int init)
|
|
{
|
|
int font;
|
|
|
|
if (init && (HL_TABLE()[idx].sg_set & SG_CTERM))
|
|
return FALSE;
|
|
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_CTERM;
|
|
|
|
if (VIM_ISDIGIT(*arg))
|
|
font = atoi((char *)arg);
|
|
else if (STRICMP(arg, "NONE") == 0)
|
|
font = -1;
|
|
else
|
|
return FALSE;
|
|
|
|
HL_TABLE()[idx].sg_cterm_font = font + 1;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Set the cterm fg/bg/ul color for the highlight group at 'idx'.
|
|
* 'key' is one of 'CTERMFG' or 'CTERMBG' or 'CTERMUL'.
|
|
* 'keystart' is the color name/value.
|
|
* 'arg' is the color name or the numeric value as a string.
|
|
* 'is_normal_group' is set if the highlight group is 'NORMAL'
|
|
* 'init' is set to TRUE when initializing highlighting.
|
|
* Called for the ":highlight" command and the "hlset()" function.
|
|
*
|
|
* Returns TRUE if the color is set.
|
|
*/
|
|
static int
|
|
highlight_set_cterm_color(
|
|
int idx,
|
|
char_u *key,
|
|
char_u *key_start,
|
|
char_u *arg,
|
|
int is_normal_group,
|
|
int init)
|
|
{
|
|
int color;
|
|
|
|
if (init && (HL_TABLE()[idx].sg_set & SG_CTERM))
|
|
return FALSE;
|
|
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_CTERM;
|
|
|
|
// When setting the foreground color, and previously the "bold"
|
|
// flag was set for a light color, reset it now
|
|
if (key[5] == 'F' && HL_TABLE()[idx].sg_cterm_bold)
|
|
{
|
|
HL_TABLE()[idx].sg_cterm &= ~HL_BOLD;
|
|
HL_TABLE()[idx].sg_cterm_bold = FALSE;
|
|
}
|
|
|
|
if (VIM_ISDIGIT(*arg))
|
|
color = atoi((char *)arg);
|
|
else if (STRICMP(arg, "fg") == 0)
|
|
{
|
|
if (cterm_normal_fg_color)
|
|
color = cterm_normal_fg_color - 1;
|
|
else
|
|
{
|
|
emsg(_(e_fg_color_unknown));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (STRICMP(arg, "bg") == 0)
|
|
{
|
|
if (cterm_normal_bg_color > 0)
|
|
color = cterm_normal_bg_color - 1;
|
|
else
|
|
{
|
|
emsg(_(e_bg_color_unknown));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (STRICMP(arg, "ul") == 0)
|
|
{
|
|
if (cterm_normal_ul_color > 0)
|
|
color = cterm_normal_ul_color - 1;
|
|
else
|
|
{
|
|
emsg(_(e_ul_color_unknown));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int bold = MAYBE;
|
|
keyvalue_T target;
|
|
keyvalue_T *entry;
|
|
|
|
target.key = 0;
|
|
target.value.string = arg;
|
|
target.value.length = 0; // not used, see cmp_keyvalue_value_i()
|
|
entry = (keyvalue_T *)bsearch(&target, &color_name_tab,
|
|
ARRAY_LENGTH(color_name_tab), sizeof(color_name_tab[0]),
|
|
cmp_keyvalue_value_i);
|
|
if (entry == NULL)
|
|
{
|
|
semsg(_(e_color_name_or_number_not_recognized_str), key_start);
|
|
return FALSE;
|
|
}
|
|
|
|
color = lookup_color(entry->key, key[5] == 'F', &bold);
|
|
|
|
// set/reset bold attribute to get light foreground
|
|
// colors (on some terminals, e.g. "linux")
|
|
if (bold == TRUE)
|
|
{
|
|
HL_TABLE()[idx].sg_cterm |= HL_BOLD;
|
|
HL_TABLE()[idx].sg_cterm_bold = TRUE;
|
|
}
|
|
else if (bold == FALSE)
|
|
HL_TABLE()[idx].sg_cterm &= ~HL_BOLD;
|
|
}
|
|
|
|
// Add one to the argument, to avoid zero. Zero is used for
|
|
// "NONE", then "color" is -1.
|
|
if (key[5] == 'F')
|
|
highlight_set_ctermfg(idx, color, is_normal_group);
|
|
else if (key[5] == 'B')
|
|
highlight_set_ctermbg(idx, color, is_normal_group);
|
|
else // ctermul
|
|
highlight_set_ctermul(idx, color, is_normal_group);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
/*
|
|
* Set the GUI foreground color for the highlight group at 'idx'.
|
|
* Returns TRUE if the color is set.
|
|
*/
|
|
static int
|
|
highlight_set_guifg(
|
|
int idx,
|
|
char_u *arg,
|
|
int is_menu_group UNUSED,
|
|
int is_scrollbar_group UNUSED,
|
|
int is_tooltip_group UNUSED,
|
|
int *do_colors UNUSED,
|
|
int init)
|
|
{
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
long i;
|
|
# endif
|
|
char_u **namep;
|
|
int did_change = FALSE;
|
|
|
|
if (init && (HL_TABLE()[idx].sg_set & SG_GUI))
|
|
return FALSE;
|
|
|
|
namep = &HL_TABLE()[idx].sg_gui_fg_name;
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_GUI;
|
|
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
// In GUI guifg colors are only used when recognized
|
|
i = color_name2handle(arg);
|
|
if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !USE_24BIT)
|
|
{
|
|
HL_TABLE()[idx].sg_gui_fg = i;
|
|
# endif
|
|
if (*namep == NULL || STRCMP(*namep, arg) != 0)
|
|
{
|
|
vim_free(*namep);
|
|
if (STRCMP(arg, "NONE") != 0)
|
|
*namep = vim_strsave(arg);
|
|
else
|
|
*namep = NULL;
|
|
did_change = TRUE;
|
|
}
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
# ifdef FEAT_GUI_X11
|
|
if (is_menu_group && gui.menu_fg_pixel != i)
|
|
{
|
|
gui.menu_fg_pixel = i;
|
|
*do_colors = TRUE;
|
|
}
|
|
if (is_scrollbar_group && gui.scroll_fg_pixel != i)
|
|
{
|
|
gui.scroll_fg_pixel = i;
|
|
*do_colors = TRUE;
|
|
}
|
|
# ifdef FEAT_BEVAL_GUI
|
|
if (is_tooltip_group && gui.tooltip_fg_pixel != i)
|
|
{
|
|
gui.tooltip_fg_pixel = i;
|
|
*do_colors = TRUE;
|
|
}
|
|
# endif
|
|
# endif
|
|
}
|
|
# endif
|
|
|
|
return did_change;
|
|
}
|
|
|
|
/*
|
|
* Set the GUI background color for the highlight group at 'idx'.
|
|
* Returns TRUE if the color is set.
|
|
*/
|
|
static int
|
|
highlight_set_guibg(
|
|
int idx,
|
|
char_u *arg,
|
|
int is_menu_group UNUSED,
|
|
int is_scrollbar_group UNUSED,
|
|
int is_tooltip_group UNUSED,
|
|
int *do_colors UNUSED,
|
|
int init)
|
|
{
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
int i;
|
|
# endif
|
|
char_u **namep;
|
|
int did_change = FALSE;
|
|
|
|
if (init && (HL_TABLE()[idx].sg_set & SG_GUI))
|
|
return FALSE;
|
|
|
|
namep = &HL_TABLE()[idx].sg_gui_bg_name;
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_GUI;
|
|
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
// In GUI guibg colors are only used when recognized
|
|
i = color_name2handle(arg);
|
|
if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !USE_24BIT)
|
|
{
|
|
HL_TABLE()[idx].sg_gui_bg = i;
|
|
# endif
|
|
if (*namep == NULL || STRCMP(*namep, arg) != 0)
|
|
{
|
|
vim_free(*namep);
|
|
if (STRCMP(arg, "NONE") != 0)
|
|
*namep = vim_strsave(arg);
|
|
else
|
|
*namep = NULL;
|
|
did_change = TRUE;
|
|
}
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
# ifdef FEAT_GUI_X11
|
|
if (is_menu_group && gui.menu_bg_pixel != i)
|
|
{
|
|
gui.menu_bg_pixel = i;
|
|
*do_colors = TRUE;
|
|
}
|
|
if (is_scrollbar_group && gui.scroll_bg_pixel != i)
|
|
{
|
|
gui.scroll_bg_pixel = i;
|
|
*do_colors = TRUE;
|
|
}
|
|
# ifdef FEAT_BEVAL_GUI
|
|
if (is_tooltip_group && gui.tooltip_bg_pixel != i)
|
|
{
|
|
gui.tooltip_bg_pixel = i;
|
|
*do_colors = TRUE;
|
|
}
|
|
# endif
|
|
# endif
|
|
}
|
|
# endif
|
|
|
|
return did_change;
|
|
}
|
|
|
|
/*
|
|
* Set the GUI undercurl/strikethrough color for the highlight group at 'idx'.
|
|
* Returns TRUE if the color is set.
|
|
*/
|
|
static int
|
|
highlight_set_guisp(int idx, char_u *arg, int init)
|
|
{
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
int i;
|
|
# endif
|
|
int did_change = FALSE;
|
|
char_u **namep;
|
|
|
|
if (init && (HL_TABLE()[idx].sg_set & SG_GUI))
|
|
return FALSE;
|
|
|
|
namep = &HL_TABLE()[idx].sg_gui_sp_name;
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_GUI;
|
|
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
// In GUI guisp colors are only used when recognized
|
|
i = color_name2handle(arg);
|
|
if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !USE_24BIT)
|
|
{
|
|
HL_TABLE()[idx].sg_gui_sp = i;
|
|
# endif
|
|
if (*namep == NULL || STRCMP(*namep, arg) != 0)
|
|
{
|
|
vim_free(*namep);
|
|
if (STRCMP(arg, "NONE") != 0)
|
|
*namep = vim_strsave(arg);
|
|
else
|
|
*namep = NULL;
|
|
did_change = TRUE;
|
|
}
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
}
|
|
# endif
|
|
|
|
return did_change;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Set the start/stop terminal codes for a highlight group.
|
|
* Returns TRUE if the terminal code is set.
|
|
*/
|
|
static int
|
|
highlight_set_startstop_termcode(int idx, char_u *key, char_u *arg, int init)
|
|
{
|
|
int off;
|
|
char_u buf[100];
|
|
int len;
|
|
char_u *tname;
|
|
char_u *p;
|
|
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_TERM;
|
|
|
|
// The "start" and "stop" arguments can be a literal escape
|
|
// sequence, or a comma separated list of terminal codes.
|
|
if (STRNCMP(arg, "t_", 2) == 0)
|
|
{
|
|
off = 0;
|
|
buf[0] = 0;
|
|
while (arg[off] != NUL)
|
|
{
|
|
// Isolate one termcap name
|
|
for (len = 0; arg[off + len] &&
|
|
arg[off + len] != ','; ++len)
|
|
;
|
|
tname = vim_strnsave(arg + off, len);
|
|
if (tname == NULL) // out of memory
|
|
return FALSE;
|
|
// lookup the escape sequence for the item
|
|
p = get_term_code(tname);
|
|
vim_free(tname);
|
|
if (p == NULL) // ignore non-existing things
|
|
p = (char_u *)"";
|
|
|
|
// Append it to the already found stuff
|
|
if ((int)(STRLEN(buf) + STRLEN(p)) >= 99)
|
|
{
|
|
semsg(_(e_terminal_code_too_long_str), arg);
|
|
return FALSE;
|
|
}
|
|
STRCAT(buf, p);
|
|
|
|
// Advance to the next item
|
|
off += len;
|
|
if (arg[off] == ',') // another one follows
|
|
++off;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Copy characters from arg[] to buf[], translating <> codes.
|
|
for (p = arg, off = 0; off < 100 - 6 && *p; )
|
|
{
|
|
len = trans_special(&p, buf + off, FSK_SIMPLIFY, FALSE, NULL);
|
|
if (len > 0) // recognized special char
|
|
off += len;
|
|
else // copy as normal char
|
|
buf[off++] = *p++;
|
|
}
|
|
buf[off] = NUL;
|
|
}
|
|
|
|
if (STRCMP(buf, "NONE") == 0) // resetting the value
|
|
p = NULL;
|
|
else
|
|
p = vim_strsave(buf);
|
|
if (key[2] == 'A')
|
|
{
|
|
vim_free(HL_TABLE()[idx].sg_start);
|
|
HL_TABLE()[idx].sg_start = p;
|
|
}
|
|
else
|
|
{
|
|
vim_free(HL_TABLE()[idx].sg_stop);
|
|
HL_TABLE()[idx].sg_stop = p;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Handle the ":highlight .." command.
|
|
* When using ":hi clear" this is called recursively for each group with
|
|
* "forceit" and "init" both TRUE.
|
|
*/
|
|
void
|
|
do_highlight(
|
|
char_u *line,
|
|
int forceit,
|
|
int init) // TRUE when called for initializing
|
|
{
|
|
char_u *name_end;
|
|
char_u *linep;
|
|
char_u *key_start;
|
|
char_u *arg_start;
|
|
char_u *key = NULL, *arg = NULL;
|
|
long i;
|
|
int id;
|
|
int idx;
|
|
hl_group_T item_before;
|
|
int did_change = FALSE;
|
|
int dodefault = FALSE;
|
|
int doclear = FALSE;
|
|
int dolink = FALSE;
|
|
int error = FALSE;
|
|
int is_normal_group = FALSE; // "Normal" group
|
|
#ifdef FEAT_GUI_X11
|
|
int is_menu_group = FALSE; // "Menu" group
|
|
int is_scrollbar_group = FALSE; // "Scrollbar" group
|
|
int is_tooltip_group = FALSE; // "Tooltip" group
|
|
#else
|
|
# define is_menu_group 0
|
|
# define is_tooltip_group 0
|
|
# define is_scrollbar_group 0
|
|
#endif
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
int do_colors = FALSE; // need to update colors?
|
|
#endif
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
int did_highlight_changed = FALSE;
|
|
#endif
|
|
|
|
// If no argument, list current highlighting.
|
|
if (!init && ends_excmd2(line - 1, line))
|
|
{
|
|
for (i = 1; i <= highlight_ga.ga_len && !got_int; ++i)
|
|
// TODO: only call when the group has attributes set
|
|
highlight_list_one((int)i);
|
|
return;
|
|
}
|
|
|
|
// Isolate the name.
|
|
name_end = skiptowhite(line);
|
|
linep = skipwhite(name_end);
|
|
|
|
// Check for "default" argument.
|
|
if (STRNCMP(line, "default", name_end - line) == 0)
|
|
{
|
|
dodefault = TRUE;
|
|
line = linep;
|
|
name_end = skiptowhite(line);
|
|
linep = skipwhite(name_end);
|
|
}
|
|
|
|
// Check for "clear" or "link" argument.
|
|
if (STRNCMP(line, "clear", name_end - line) == 0)
|
|
doclear = TRUE;
|
|
if (STRNCMP(line, "link", name_end - line) == 0)
|
|
dolink = TRUE;
|
|
|
|
// ":highlight {group-name}": list highlighting for one group.
|
|
if (!doclear && !dolink && ends_excmd2(line, linep))
|
|
{
|
|
id = syn_namen2id(line, (int)(name_end - line));
|
|
if (id == 0)
|
|
semsg(_(e_highlight_group_name_not_found_str), line);
|
|
else
|
|
highlight_list_one(id);
|
|
return;
|
|
}
|
|
|
|
// Handle ":highlight link {from} {to}" command.
|
|
if (dolink)
|
|
{
|
|
char_u *from_start = linep;
|
|
char_u *from_end;
|
|
int from_len;
|
|
char_u *to_start;
|
|
char_u *to_end;
|
|
int to_len;
|
|
|
|
from_end = skiptowhite(from_start);
|
|
to_start = skipwhite(from_end);
|
|
to_end = skiptowhite(to_start);
|
|
|
|
if (ends_excmd2(line, from_start) || ends_excmd2(line, to_start))
|
|
{
|
|
semsg(_(e_not_enough_arguments_highlight_link_str), from_start);
|
|
return;
|
|
}
|
|
|
|
if (!ends_excmd2(line, skipwhite(to_end)))
|
|
{
|
|
semsg(_(e_too_many_arguments_highlight_link_str), from_start);
|
|
return;
|
|
}
|
|
|
|
from_len = (int)(from_end - from_start);
|
|
to_len = (int)(to_end - to_start);
|
|
highlight_group_link(from_start, from_len, to_start, to_len,
|
|
dodefault, forceit, init);
|
|
return;
|
|
}
|
|
|
|
if (doclear)
|
|
{
|
|
// ":highlight clear [group]" command.
|
|
if (ends_excmd2(line, linep))
|
|
{
|
|
// ":highlight clear" without group name
|
|
highlight_reset_all();
|
|
return;
|
|
}
|
|
line = linep;
|
|
name_end = skiptowhite(line);
|
|
linep = skipwhite(name_end);
|
|
}
|
|
|
|
// Find the group name in the table. If it does not exist yet, add it.
|
|
id = syn_check_group(line, (int)(name_end - line));
|
|
if (id == 0) // failed (out of memory)
|
|
return;
|
|
idx = id - 1; // index is ID minus one
|
|
|
|
// Return if "default" was used and the group already has settings.
|
|
if (dodefault && hl_has_settings(idx, TRUE))
|
|
return;
|
|
|
|
// Make a copy so we can check if any attribute actually changed.
|
|
item_before = HL_TABLE()[idx];
|
|
|
|
if (STRCMP(HL_TABLE()[idx].sg_name_u, "NORMAL") == 0)
|
|
is_normal_group = TRUE;
|
|
#ifdef FEAT_GUI_X11
|
|
else if (STRCMP(HL_TABLE()[idx].sg_name_u, "MENU") == 0)
|
|
is_menu_group = TRUE;
|
|
else if (STRCMP(HL_TABLE()[idx].sg_name_u, "SCROLLBAR") == 0)
|
|
is_scrollbar_group = TRUE;
|
|
else if (STRCMP(HL_TABLE()[idx].sg_name_u, "TOOLTIP") == 0)
|
|
is_tooltip_group = TRUE;
|
|
#endif
|
|
|
|
// Clear the highlighting for ":hi clear {group}" and ":hi clear".
|
|
if (doclear || (forceit && init))
|
|
{
|
|
highlight_clear(idx);
|
|
if (!doclear)
|
|
HL_TABLE()[idx].sg_set = 0;
|
|
}
|
|
|
|
if (!doclear)
|
|
while (!ends_excmd2(line, linep))
|
|
{
|
|
key_start = linep;
|
|
if (*linep == '=')
|
|
{
|
|
semsg(_(e_unexpected_equal_sign_str), key_start);
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
|
|
// Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg"
|
|
// or "guibg").
|
|
while (*linep && !VIM_ISWHITE(*linep) && *linep != '=')
|
|
++linep;
|
|
vim_free(key);
|
|
key = vim_strnsave_up(key_start, linep - key_start);
|
|
if (key == NULL)
|
|
{
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
linep = skipwhite(linep);
|
|
|
|
if (STRCMP(key, "NONE") == 0)
|
|
{
|
|
if (!init || HL_TABLE()[idx].sg_set == 0)
|
|
{
|
|
if (!init)
|
|
HL_TABLE()[idx].sg_set |= SG_TERM+SG_CTERM+SG_GUI;
|
|
highlight_clear(idx);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Check for the equal sign.
|
|
if (*linep != '=')
|
|
{
|
|
semsg(_(e_missing_equal_sign_str_2), key_start);
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
++linep;
|
|
|
|
// Isolate the argument.
|
|
linep = skipwhite(linep);
|
|
if (*linep == '\'') // guifg='color name'
|
|
{
|
|
arg_start = ++linep;
|
|
linep = vim_strchr(linep, '\'');
|
|
if (linep == NULL)
|
|
{
|
|
semsg(_(e_invalid_argument_str), key_start);
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arg_start = linep;
|
|
linep = skiptowhite(linep);
|
|
}
|
|
if (linep == arg_start)
|
|
{
|
|
semsg(_(e_missing_argument_str), key_start);
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
vim_free(arg);
|
|
arg = vim_strnsave(arg_start, linep - arg_start);
|
|
if (arg == NULL)
|
|
{
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
if (*linep == '\'')
|
|
++linep;
|
|
|
|
// Store the argument.
|
|
if (STRCMP(key, "TERM") == 0
|
|
|| STRCMP(key, "CTERM") == 0
|
|
|| STRCMP(key, "GUI") == 0)
|
|
{
|
|
if (!highlight_set_termgui_attr(idx, key, arg, init))
|
|
{
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else if (STRCMP(key, "FONT") == 0)
|
|
{
|
|
// in non-GUI fonts are simply ignored
|
|
#ifdef FEAT_GUI
|
|
if (highlight_set_font(idx, arg, is_normal_group,
|
|
is_menu_group, is_tooltip_group))
|
|
did_change = TRUE;
|
|
#endif
|
|
}
|
|
else if (STRCMP(key, "CTERMFG") == 0
|
|
|| STRCMP(key, "CTERMBG") == 0
|
|
|| STRCMP(key, "CTERMUL") == 0)
|
|
{
|
|
if (!highlight_set_cterm_color(idx, key, key_start, arg,
|
|
is_normal_group, init))
|
|
{
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else if (STRCMP(key, "CTERMFONT") == 0)
|
|
{
|
|
if (!highlight_set_cterm_font(idx, arg, init))
|
|
{
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else if (STRCMP(key, "GUIFG") == 0)
|
|
{
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
if (highlight_set_guifg(idx, arg, is_menu_group,
|
|
is_scrollbar_group, is_tooltip_group,
|
|
&do_colors, init))
|
|
did_change = TRUE;
|
|
#endif
|
|
}
|
|
else if (STRCMP(key, "GUIBG") == 0)
|
|
{
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
if (highlight_set_guibg(idx, arg, is_menu_group,
|
|
is_scrollbar_group, is_tooltip_group,
|
|
&do_colors, init))
|
|
did_change = TRUE;
|
|
#endif
|
|
}
|
|
else if (STRCMP(key, "GUISP") == 0)
|
|
{
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
if (highlight_set_guisp(idx, arg, init))
|
|
did_change = TRUE;
|
|
#endif
|
|
}
|
|
else if (STRCMP(key, "START") == 0 || STRCMP(key, "STOP") == 0)
|
|
{
|
|
if (!highlight_set_startstop_termcode(idx, key, arg, init))
|
|
{
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
semsg(_(e_illegal_argument_str_3), key_start);
|
|
error = TRUE;
|
|
break;
|
|
}
|
|
HL_TABLE()[idx].sg_cleared = FALSE;
|
|
|
|
// When highlighting has been given for a group, don't link it.
|
|
if (!init || !(HL_TABLE()[idx].sg_set & SG_LINK))
|
|
HL_TABLE()[idx].sg_link = 0;
|
|
|
|
// Continue with next argument.
|
|
linep = skipwhite(linep);
|
|
}
|
|
|
|
// If there is an error, and it's a new entry, remove it from the table.
|
|
if (error && idx == highlight_ga.ga_len)
|
|
syn_unadd_group();
|
|
else
|
|
{
|
|
if (is_normal_group)
|
|
{
|
|
HL_TABLE()[idx].sg_term_attr = 0;
|
|
HL_TABLE()[idx].sg_cterm_attr = 0;
|
|
#ifdef FEAT_GUI
|
|
HL_TABLE()[idx].sg_gui_attr = 0;
|
|
// Need to update all groups, because they might be using "bg"
|
|
// and/or "fg", which have been changed now.
|
|
#endif
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
if (USE_24BIT)
|
|
{
|
|
highlight_gui_started();
|
|
did_highlight_changed = TRUE;
|
|
redraw_all_later(UPD_NOT_VALID);
|
|
}
|
|
#endif
|
|
#ifdef FEAT_VTP
|
|
control_console_color_rgb();
|
|
#endif
|
|
}
|
|
#ifdef FEAT_GUI_X11
|
|
# ifdef FEAT_MENU
|
|
else if (is_menu_group)
|
|
{
|
|
if (gui.in_use && do_colors)
|
|
gui_mch_new_menu_colors();
|
|
}
|
|
# endif
|
|
else if (is_scrollbar_group)
|
|
{
|
|
if (gui.in_use && do_colors)
|
|
gui_new_scrollbar_colors();
|
|
else
|
|
set_hl_attr(idx);
|
|
}
|
|
# ifdef FEAT_BEVAL_GUI
|
|
else if (is_tooltip_group)
|
|
{
|
|
if (gui.in_use && do_colors)
|
|
gui_mch_new_tooltip_colors();
|
|
}
|
|
# endif
|
|
#endif
|
|
else
|
|
set_hl_attr(idx);
|
|
#ifdef FEAT_EVAL
|
|
HL_TABLE()[idx].sg_script_ctx = current_sctx;
|
|
HL_TABLE()[idx].sg_script_ctx.sc_lnum += SOURCING_LNUM;
|
|
#endif
|
|
}
|
|
|
|
vim_free(key);
|
|
vim_free(arg);
|
|
|
|
// Only call highlight_changed() once, after a sequence of highlight
|
|
// commands, and only if an attribute actually changed.
|
|
if ((did_change
|
|
|| memcmp(&HL_TABLE()[idx], &item_before, sizeof(item_before)) != 0)
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
&& !did_highlight_changed
|
|
#endif
|
|
)
|
|
{
|
|
// Do not trigger a redraw when highlighting is changed while
|
|
// redrawing. This may happen when evaluating 'statusline' changes the
|
|
// StatusLine group.
|
|
if (!updating_screen)
|
|
redraw_all_later(UPD_NOT_VALID);
|
|
need_highlight_changed = TRUE;
|
|
}
|
|
}
|
|
|
|
#if defined(EXITFREE) || defined(PROTO)
|
|
void
|
|
free_highlight(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < highlight_ga.ga_len; ++i)
|
|
{
|
|
highlight_clear(i);
|
|
vim_free(HL_TABLE()[i].sg_name);
|
|
vim_free(HL_TABLE()[i].sg_name_u);
|
|
}
|
|
ga_clear(&highlight_ga);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Reset the cterm colors to what they were before Vim was started, if
|
|
* possible. Otherwise reset them to zero.
|
|
*/
|
|
void
|
|
restore_cterm_colors(void)
|
|
{
|
|
#if defined(MSWIN) && !defined(FEAT_GUI_MSWIN)
|
|
// Since t_me has been set, this probably means that the user
|
|
// wants to use this as default colors. Need to reset default
|
|
// background/foreground colors.
|
|
mch_set_normal_colors();
|
|
#else
|
|
# ifdef VIMDLL
|
|
if (!gui.in_use)
|
|
{
|
|
mch_set_normal_colors();
|
|
return;
|
|
}
|
|
# endif
|
|
cterm_normal_fg_color = 0;
|
|
cterm_normal_fg_bold = 0;
|
|
cterm_normal_bg_color = 0;
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
cterm_normal_fg_gui_color = INVALCOLOR;
|
|
cterm_normal_bg_gui_color = INVALCOLOR;
|
|
cterm_normal_ul_gui_color = INVALCOLOR;
|
|
# endif
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if highlight group "idx" has any settings.
|
|
* When "check_link" is TRUE also check for an existing link.
|
|
*/
|
|
static int
|
|
hl_has_settings(int idx, int check_link)
|
|
{
|
|
return HL_TABLE()[idx].sg_cleared == 0
|
|
&& ( HL_TABLE()[idx].sg_term_attr != 0
|
|
|| HL_TABLE()[idx].sg_cterm_attr != 0
|
|
|| HL_TABLE()[idx].sg_cterm_fg != 0
|
|
|| HL_TABLE()[idx].sg_cterm_bg != 0
|
|
|| HL_TABLE()[idx].sg_cterm_font != 0
|
|
#ifdef FEAT_GUI
|
|
|| HL_TABLE()[idx].sg_gui_attr != 0
|
|
|| HL_TABLE()[idx].sg_gui_fg_name != NULL
|
|
|| HL_TABLE()[idx].sg_gui_bg_name != NULL
|
|
|| HL_TABLE()[idx].sg_gui_sp_name != NULL
|
|
|| HL_TABLE()[idx].sg_font_name != NULL
|
|
#endif
|
|
|| (check_link && (HL_TABLE()[idx].sg_set & SG_LINK)));
|
|
}
|
|
|
|
/*
|
|
* Clear highlighting for one group.
|
|
*/
|
|
static void
|
|
highlight_clear(int idx)
|
|
{
|
|
HL_TABLE()[idx].sg_cleared = TRUE;
|
|
|
|
HL_TABLE()[idx].sg_term = 0;
|
|
VIM_CLEAR(HL_TABLE()[idx].sg_start);
|
|
VIM_CLEAR(HL_TABLE()[idx].sg_stop);
|
|
HL_TABLE()[idx].sg_term_attr = 0;
|
|
HL_TABLE()[idx].sg_cterm = 0;
|
|
HL_TABLE()[idx].sg_cterm_bold = FALSE;
|
|
HL_TABLE()[idx].sg_cterm_fg = 0;
|
|
HL_TABLE()[idx].sg_cterm_bg = 0;
|
|
HL_TABLE()[idx].sg_cterm_attr = 0;
|
|
HL_TABLE()[idx].sg_cterm_font = 0;
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
HL_TABLE()[idx].sg_gui = 0;
|
|
VIM_CLEAR(HL_TABLE()[idx].sg_gui_fg_name);
|
|
VIM_CLEAR(HL_TABLE()[idx].sg_gui_bg_name);
|
|
VIM_CLEAR(HL_TABLE()[idx].sg_gui_sp_name);
|
|
#endif
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
HL_TABLE()[idx].sg_gui_fg = INVALCOLOR;
|
|
HL_TABLE()[idx].sg_gui_bg = INVALCOLOR;
|
|
HL_TABLE()[idx].sg_gui_sp = INVALCOLOR;
|
|
#endif
|
|
#ifdef FEAT_GUI
|
|
gui_mch_free_font(HL_TABLE()[idx].sg_font);
|
|
HL_TABLE()[idx].sg_font = NOFONT;
|
|
# ifdef FEAT_XFONTSET
|
|
gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
|
|
HL_TABLE()[idx].sg_fontset = NOFONTSET;
|
|
# endif
|
|
VIM_CLEAR(HL_TABLE()[idx].sg_font_name);
|
|
HL_TABLE()[idx].sg_gui_attr = 0;
|
|
#endif
|
|
// Restore default link and context if they exist. Otherwise clears.
|
|
HL_TABLE()[idx].sg_link = HL_TABLE()[idx].sg_deflink;
|
|
#ifdef FEAT_EVAL
|
|
// Since we set the default link, set the location to where the default
|
|
// link was set.
|
|
HL_TABLE()[idx].sg_script_ctx = HL_TABLE()[idx].sg_deflink_sctx;
|
|
#endif
|
|
}
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO)
|
|
/*
|
|
* Set the normal foreground and background colors according to the "Normal"
|
|
* highlighting group. For X11 also set "Menu", "Scrollbar", and
|
|
* "Tooltip" colors.
|
|
*/
|
|
void
|
|
set_normal_colors(void)
|
|
{
|
|
# ifdef FEAT_GUI
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
if (gui.in_use)
|
|
# endif
|
|
{
|
|
if (set_group_colors((char_u *)"Normal",
|
|
&gui.norm_pixel, &gui.back_pixel,
|
|
FALSE, TRUE, FALSE))
|
|
{
|
|
gui_mch_new_colors();
|
|
set_must_redraw(UPD_CLEAR);
|
|
}
|
|
# ifdef FEAT_GUI_X11
|
|
if (set_group_colors((char_u *)"Menu",
|
|
&gui.menu_fg_pixel, &gui.menu_bg_pixel,
|
|
TRUE, FALSE, FALSE))
|
|
{
|
|
# ifdef FEAT_MENU
|
|
gui_mch_new_menu_colors();
|
|
# endif
|
|
set_must_redraw(UPD_CLEAR);
|
|
}
|
|
# ifdef FEAT_BEVAL_GUI
|
|
if (set_group_colors((char_u *)"Tooltip",
|
|
&gui.tooltip_fg_pixel, &gui.tooltip_bg_pixel,
|
|
FALSE, FALSE, TRUE))
|
|
{
|
|
# ifdef FEAT_TOOLBAR
|
|
gui_mch_new_tooltip_colors();
|
|
# endif
|
|
set_must_redraw(UPD_CLEAR);
|
|
}
|
|
# endif
|
|
if (set_group_colors((char_u *)"Scrollbar",
|
|
&gui.scroll_fg_pixel, &gui.scroll_bg_pixel,
|
|
FALSE, FALSE, FALSE))
|
|
{
|
|
gui_new_scrollbar_colors();
|
|
set_must_redraw(UPD_CLEAR);
|
|
}
|
|
# endif
|
|
}
|
|
# endif
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
# ifdef FEAT_GUI
|
|
else
|
|
# endif
|
|
{
|
|
int idx;
|
|
|
|
idx = syn_name2id((char_u *)"Normal") - 1;
|
|
if (idx >= 0)
|
|
{
|
|
gui_do_one_color(idx, FALSE, FALSE);
|
|
|
|
// If the normal fg or bg color changed a complete redraw is
|
|
// required.
|
|
if (cterm_normal_fg_gui_color != HL_TABLE()[idx].sg_gui_fg
|
|
|| cterm_normal_bg_gui_color != HL_TABLE()[idx].sg_gui_bg)
|
|
{
|
|
// if the GUI color is INVALCOLOR then we use the default cterm
|
|
// color
|
|
cterm_normal_fg_gui_color = HL_TABLE()[idx].sg_gui_fg;
|
|
cterm_normal_bg_gui_color = HL_TABLE()[idx].sg_gui_bg;
|
|
set_must_redraw(UPD_CLEAR);
|
|
}
|
|
}
|
|
}
|
|
# endif
|
|
}
|
|
#endif
|
|
|
|
#if defined(FEAT_GUI) || defined(PROTO)
|
|
/*
|
|
* Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
|
|
*/
|
|
static int
|
|
set_group_colors(
|
|
char_u *name,
|
|
guicolor_T *fgp,
|
|
guicolor_T *bgp,
|
|
int do_menu,
|
|
int use_norm,
|
|
int do_tooltip)
|
|
{
|
|
int idx;
|
|
|
|
idx = syn_name2id(name) - 1;
|
|
if (idx < 0)
|
|
return FALSE;
|
|
|
|
gui_do_one_color(idx, do_menu, do_tooltip);
|
|
|
|
if (HL_TABLE()[idx].sg_gui_fg != INVALCOLOR)
|
|
*fgp = HL_TABLE()[idx].sg_gui_fg;
|
|
else if (use_norm)
|
|
*fgp = gui.def_norm_pixel;
|
|
if (HL_TABLE()[idx].sg_gui_bg != INVALCOLOR)
|
|
*bgp = HL_TABLE()[idx].sg_gui_bg;
|
|
else if (use_norm)
|
|
*bgp = gui.def_back_pixel;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Get the font of the "Normal" group.
|
|
* Returns "" when it's not found or not set.
|
|
*/
|
|
char_u *
|
|
hl_get_font_name(void)
|
|
{
|
|
int id;
|
|
char_u *s;
|
|
|
|
id = syn_name2id((char_u *)"Normal");
|
|
if (id > 0)
|
|
{
|
|
s = HL_TABLE()[id - 1].sg_font_name;
|
|
if (s != NULL)
|
|
return s;
|
|
}
|
|
return (char_u *)"";
|
|
}
|
|
|
|
/*
|
|
* Set font for "Normal" group. Called by gui_mch_init_font() when a font has
|
|
* actually chosen to be used.
|
|
*/
|
|
void
|
|
hl_set_font_name(char_u *font_name)
|
|
{
|
|
int id;
|
|
|
|
id = syn_name2id((char_u *)"Normal");
|
|
if (id <= 0)
|
|
return;
|
|
|
|
vim_free(HL_TABLE()[id - 1].sg_font_name);
|
|
HL_TABLE()[id - 1].sg_font_name = vim_strsave(font_name);
|
|
}
|
|
|
|
/*
|
|
* Set background color for "Normal" group. Called by gui_set_bg_color()
|
|
* when the color is known.
|
|
*/
|
|
void
|
|
hl_set_bg_color_name(
|
|
char_u *name) // must have been allocated
|
|
{
|
|
int id;
|
|
|
|
if (name == NULL)
|
|
return;
|
|
|
|
id = syn_name2id((char_u *)"Normal");
|
|
if (id <= 0)
|
|
return;
|
|
|
|
vim_free(HL_TABLE()[id - 1].sg_gui_bg_name);
|
|
HL_TABLE()[id - 1].sg_gui_bg_name = name;
|
|
}
|
|
|
|
/*
|
|
* Set foreground color for "Normal" group. Called by gui_set_fg_color()
|
|
* when the color is known.
|
|
*/
|
|
void
|
|
hl_set_fg_color_name(
|
|
char_u *name) // must have been allocated
|
|
{
|
|
int id;
|
|
|
|
if (name == NULL)
|
|
return;
|
|
|
|
id = syn_name2id((char_u *)"Normal");
|
|
if (id <= 0)
|
|
return;
|
|
|
|
vim_free(HL_TABLE()[id - 1].sg_gui_fg_name);
|
|
HL_TABLE()[id - 1].sg_gui_fg_name = name;
|
|
}
|
|
|
|
/*
|
|
* Return the handle for a font name.
|
|
* Returns NOFONT when failed.
|
|
*/
|
|
static GuiFont
|
|
font_name2handle(char_u *name)
|
|
{
|
|
if (STRCMP(name, "NONE") == 0)
|
|
return NOFONT;
|
|
|
|
return gui_mch_get_font(name, TRUE);
|
|
}
|
|
|
|
# ifdef FEAT_XFONTSET
|
|
/*
|
|
* Return the handle for a fontset name.
|
|
* Returns NOFONTSET when failed.
|
|
*/
|
|
static GuiFontset
|
|
fontset_name2handle(char_u *name, int fixed_width)
|
|
{
|
|
if (STRCMP(name, "NONE") == 0)
|
|
return NOFONTSET;
|
|
|
|
return gui_mch_get_fontset(name, TRUE, fixed_width);
|
|
}
|
|
# endif
|
|
|
|
/*
|
|
* Get the font or fontset for one highlight group.
|
|
*/
|
|
static void
|
|
hl_do_font(
|
|
int idx,
|
|
char_u *arg,
|
|
int do_normal, // set normal font
|
|
int do_menu UNUSED, // set menu font
|
|
int do_tooltip UNUSED, // set tooltip font
|
|
int free_font) // free current font/fontset
|
|
{
|
|
# ifdef FEAT_XFONTSET
|
|
// If 'guifontset' is not empty, first try using the name as a
|
|
// fontset. If that doesn't work, use it as a font name.
|
|
if (*p_guifontset != NUL
|
|
# ifdef FONTSET_ALWAYS
|
|
|| do_menu
|
|
# endif
|
|
# ifdef FEAT_BEVAL_TIP
|
|
// In Motif, the Tooltip highlight group is always a fontset
|
|
|| do_tooltip
|
|
# endif
|
|
)
|
|
{
|
|
if (free_font)
|
|
gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
|
|
HL_TABLE()[idx].sg_fontset = fontset_name2handle(arg, 0
|
|
# ifdef FONTSET_ALWAYS
|
|
|| do_menu
|
|
# endif
|
|
# ifdef FEAT_BEVAL_TIP
|
|
|| do_tooltip
|
|
# endif
|
|
);
|
|
}
|
|
if (HL_TABLE()[idx].sg_fontset != NOFONTSET)
|
|
{
|
|
// If it worked and it's the Normal group, use it as the normal
|
|
// fontset. Same for the Menu group.
|
|
if (do_normal)
|
|
gui_init_font(arg, TRUE);
|
|
# if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)
|
|
if (do_menu)
|
|
{
|
|
# ifdef FONTSET_ALWAYS
|
|
gui.menu_fontset = HL_TABLE()[idx].sg_fontset;
|
|
# else
|
|
// YIKES! This is a bug waiting to crash the program
|
|
gui.menu_font = HL_TABLE()[idx].sg_fontset;
|
|
# endif
|
|
gui_mch_new_menu_font();
|
|
}
|
|
# ifdef FEAT_BEVAL_GUI
|
|
if (do_tooltip)
|
|
{
|
|
// The Athena widget set could not handle switching between
|
|
// displaying a single font and a fontset.
|
|
// If the XtNinternational resource is set to True at widget
|
|
// creation, then a fontset is always used, otherwise an
|
|
// XFontStruct is used.
|
|
gui.tooltip_fontset = (XFontSet)HL_TABLE()[idx].sg_fontset;
|
|
gui_mch_new_tooltip_font();
|
|
}
|
|
# endif
|
|
# endif
|
|
}
|
|
else
|
|
# endif
|
|
{
|
|
if (free_font)
|
|
gui_mch_free_font(HL_TABLE()[idx].sg_font);
|
|
HL_TABLE()[idx].sg_font = font_name2handle(arg);
|
|
// If it worked and it's the Normal group, use it as the
|
|
// normal font. Same for the Menu group.
|
|
if (HL_TABLE()[idx].sg_font != NOFONT)
|
|
{
|
|
if (do_normal)
|
|
gui_init_font(arg, FALSE);
|
|
#ifndef FONTSET_ALWAYS
|
|
# if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)
|
|
if (do_menu)
|
|
{
|
|
gui.menu_font = HL_TABLE()[idx].sg_font;
|
|
gui_mch_new_menu_font();
|
|
}
|
|
# endif
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // FEAT_GUI
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO)
|
|
/*
|
|
* Return the handle for a color name.
|
|
* Returns INVALCOLOR when failed.
|
|
*/
|
|
guicolor_T
|
|
color_name2handle(char_u *name)
|
|
{
|
|
if (STRCMP(name, "NONE") == 0)
|
|
return INVALCOLOR;
|
|
|
|
if (STRICMP(name, "fg") == 0 || STRICMP(name, "foreground") == 0)
|
|
{
|
|
#if defined(FEAT_TERMGUICOLORS) && defined(FEAT_GUI)
|
|
if (gui.in_use)
|
|
#endif
|
|
#ifdef FEAT_GUI
|
|
return gui.norm_pixel;
|
|
#endif
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
if (cterm_normal_fg_gui_color != INVALCOLOR)
|
|
return cterm_normal_fg_gui_color;
|
|
// Guess that the foreground is black or white.
|
|
return GUI_GET_COLOR((char_u *)(*p_bg == 'l' ? "black" : "white"));
|
|
#endif
|
|
}
|
|
if (STRICMP(name, "bg") == 0 || STRICMP(name, "background") == 0)
|
|
{
|
|
#if defined(FEAT_TERMGUICOLORS) && defined(FEAT_GUI)
|
|
if (gui.in_use)
|
|
#endif
|
|
#ifdef FEAT_GUI
|
|
return gui.back_pixel;
|
|
#endif
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
if (cterm_normal_bg_gui_color != INVALCOLOR)
|
|
return cterm_normal_bg_gui_color;
|
|
// Guess that the background is white or black.
|
|
return GUI_GET_COLOR((char_u *)(*p_bg == 'l' ? "white" : "black"));
|
|
#endif
|
|
}
|
|
|
|
return GUI_GET_COLOR(name);
|
|
}
|
|
|
|
// On MS-Windows an RGB macro is available and it produces 0x00bbggrr color
|
|
// values as used by the MS-Windows GDI api. It should be used only for
|
|
// MS-Windows GDI builds.
|
|
# if defined(RGB) && defined(MSWIN) && !defined(FEAT_GUI)
|
|
# undef RGB
|
|
# endif
|
|
# ifndef RGB
|
|
# define RGB(r, g, b) (((r)<<16) | ((g)<<8) | (b))
|
|
# endif
|
|
|
|
# ifdef VIMDLL
|
|
static guicolor_T
|
|
gui_adjust_rgb(guicolor_T c)
|
|
{
|
|
if (gui.in_use)
|
|
return c;
|
|
else
|
|
return ((c & 0xff) << 16) | (c & 0x00ff00) | ((c >> 16) & 0xff);
|
|
}
|
|
# else
|
|
# define gui_adjust_rgb(c) (c)
|
|
# endif
|
|
|
|
static int
|
|
hex_digit(int c)
|
|
{
|
|
if (SAFE_isdigit(c))
|
|
return c - '0';
|
|
c = TOLOWER_ASC(c);
|
|
if (c >= 'a' && c <= 'f')
|
|
return c - 'a' + 10;
|
|
return 0x1ffffff;
|
|
}
|
|
|
|
static guicolor_T
|
|
decode_hex_color(char_u *hex)
|
|
{
|
|
guicolor_T color;
|
|
|
|
if (hex[0] != '#' || STRLEN(hex) != 7)
|
|
return INVALCOLOR;
|
|
|
|
// Name is in "#rrggbb" format
|
|
color = RGB(((hex_digit(hex[1]) << 4) + hex_digit(hex[2])),
|
|
((hex_digit(hex[3]) << 4) + hex_digit(hex[4])),
|
|
((hex_digit(hex[5]) << 4) + hex_digit(hex[6])));
|
|
if (color > 0xffffff)
|
|
return INVALCOLOR;
|
|
return gui_adjust_rgb(color);
|
|
}
|
|
|
|
#ifdef FEAT_EVAL
|
|
// Returns the color currently mapped to the given name or INVALCOLOR if no
|
|
// such name exists in the color table. The convention is to use lowercase for
|
|
// all keys in the v:colornames dictionary. The value can be either a string in
|
|
// the form #rrggbb or a number, either of which is converted to a guicolor_T.
|
|
static guicolor_T
|
|
colorname2rgb(char_u *name)
|
|
{
|
|
dict_T *colornames_table = get_vim_var_dict(VV_COLORNAMES);
|
|
char_u *lc_name;
|
|
dictitem_T *colentry;
|
|
char_u *colstr;
|
|
varnumber_T colnum;
|
|
|
|
lc_name = strlow_save(name);
|
|
if (lc_name == NULL)
|
|
return INVALCOLOR;
|
|
|
|
colentry = dict_find(colornames_table, lc_name, -1);
|
|
vim_free(lc_name);
|
|
if (colentry == NULL)
|
|
return INVALCOLOR;
|
|
|
|
if (colentry->di_tv.v_type == VAR_STRING)
|
|
{
|
|
colstr = tv_get_string_strict(&colentry->di_tv);
|
|
if ((STRLEN(colstr) == 7) && (*colstr == '#'))
|
|
{
|
|
return decode_hex_color(colstr);
|
|
}
|
|
else
|
|
{
|
|
semsg(_(e_bad_color_string_str), colstr);
|
|
return INVALCOLOR;
|
|
}
|
|
}
|
|
|
|
if (colentry->di_tv.v_type == VAR_NUMBER)
|
|
{
|
|
colnum = tv_get_number(&colentry->di_tv);
|
|
return (guicolor_T)colnum;
|
|
}
|
|
|
|
return INVALCOLOR;
|
|
}
|
|
|
|
#endif
|
|
|
|
guicolor_T
|
|
gui_get_color_cmn(char_u *name)
|
|
{
|
|
guicolor_T color;
|
|
// Only non X11 colors (not present in rgb.txt) and colors in
|
|
// color_name_tab[], useful when $VIMRUNTIME is not found,.
|
|
// must be sorted by the 'value' field because it is used by bsearch()!
|
|
static keyvalue_T rgb_tab[] = {
|
|
KEYVALUE_ENTRY(RGB(0x00, 0x00, 0x00), "black"),
|
|
KEYVALUE_ENTRY(RGB(0x00, 0x00, 0xFF), "blue"),
|
|
KEYVALUE_ENTRY(RGB(0xA5, 0x2A, 0x2A), "brown"),
|
|
KEYVALUE_ENTRY(RGB(0x00, 0xFF, 0xFF), "cyan"),
|
|
KEYVALUE_ENTRY(RGB(0x00, 0x00, 0x8B), "darkblue"),
|
|
KEYVALUE_ENTRY(RGB(0x00, 0x8B, 0x8B), "darkcyan"),
|
|
KEYVALUE_ENTRY(RGB(0xA9, 0xA9, 0xA9), "darkgray"),
|
|
KEYVALUE_ENTRY(RGB(0x00, 0x64, 0x00), "darkgreen"),
|
|
KEYVALUE_ENTRY(RGB(0xA9, 0xA9, 0xA9), "darkgrey"),
|
|
KEYVALUE_ENTRY(RGB(0x8B, 0x00, 0x8B), "darkmagenta"),
|
|
KEYVALUE_ENTRY(RGB(0x8B, 0x00, 0x00), "darkred"),
|
|
KEYVALUE_ENTRY(RGB(0x8B, 0x8B, 0x00), "darkyellow"), // No X11
|
|
KEYVALUE_ENTRY(RGB(0xBE, 0xBE, 0xBE), "gray"),
|
|
KEYVALUE_ENTRY(RGB(0x00, 0xFF, 0x00), "green"),
|
|
KEYVALUE_ENTRY(RGB(0xBE, 0xBE, 0xBE), "grey"),
|
|
KEYVALUE_ENTRY(RGB(0x66, 0x66, 0x66), "grey40"),
|
|
KEYVALUE_ENTRY(RGB(0x7F, 0x7F, 0x7F), "grey50"),
|
|
KEYVALUE_ENTRY(RGB(0xE5, 0xE5, 0xE5), "grey90"),
|
|
KEYVALUE_ENTRY(RGB(0xAD, 0xD8, 0xE6), "lightblue"),
|
|
KEYVALUE_ENTRY(RGB(0xE0, 0xFF, 0xFF), "lightcyan"),
|
|
KEYVALUE_ENTRY(RGB(0xD3, 0xD3, 0xD3), "lightgray"),
|
|
KEYVALUE_ENTRY(RGB(0x90, 0xEE, 0x90), "lightgreen"),
|
|
KEYVALUE_ENTRY(RGB(0xD3, 0xD3, 0xD3), "lightgrey"),
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0x8B, 0xFF), "lightmagenta"), // No XX
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0x8B, 0x8B), "lightred"), // No XX
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0xFF, 0xE0), "lightyellow"),
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0x00, 0xFF), "magenta"),
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0x00, 0x00), "red"),
|
|
KEYVALUE_ENTRY(RGB(0x2E, 0x8B, 0x57), "seagreen"),
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0xFF, 0xFF), "white"),
|
|
KEYVALUE_ENTRY(RGB(0xFF, 0xFF, 0x00), "yellow")
|
|
};
|
|
keyvalue_T target;
|
|
keyvalue_T *entry;
|
|
|
|
color = decode_hex_color(name);
|
|
if (color != INVALCOLOR)
|
|
return color;
|
|
|
|
target.key = 0;
|
|
target.value.string = name;
|
|
target.value.length = 0; // not used, see cmp_keyvalue_value_i()
|
|
entry = (keyvalue_T *)bsearch(&target, &rgb_tab, ARRAY_LENGTH(rgb_tab),
|
|
sizeof(rgb_tab[0]), cmp_keyvalue_value_i);
|
|
if (entry != NULL)
|
|
return gui_adjust_rgb((guicolor_T)entry->key);
|
|
|
|
#if defined(FEAT_EVAL)
|
|
/*
|
|
* Not a traditional color. Load additional color aliases and then consult the alias table.
|
|
*/
|
|
|
|
color = colorname2rgb(name);
|
|
if (color == INVALCOLOR)
|
|
{
|
|
load_default_colors_lists();
|
|
color = colorname2rgb(name);
|
|
}
|
|
|
|
return color;
|
|
#else
|
|
return INVALCOLOR;
|
|
#endif
|
|
}
|
|
|
|
guicolor_T
|
|
gui_get_rgb_color_cmn(int r, int g, int b)
|
|
{
|
|
guicolor_T color = RGB(r, g, b);
|
|
|
|
if (color > 0xffffff)
|
|
return INVALCOLOR;
|
|
return gui_adjust_rgb(color);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Table with the specifications for an attribute number.
|
|
* Note that this table is used by ALL buffers. This is required because the
|
|
* GUI can redraw at any time for any buffer.
|
|
*/
|
|
static garray_T term_attr_table = {0, 0, 0, 0, NULL};
|
|
|
|
#define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx]
|
|
|
|
static garray_T cterm_attr_table = {0, 0, 0, 0, NULL};
|
|
|
|
#define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx]
|
|
|
|
#ifdef FEAT_GUI
|
|
static garray_T gui_attr_table = {0, 0, 0, 0, NULL};
|
|
|
|
#define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx]
|
|
#endif
|
|
|
|
/*
|
|
* Return the attr number for a set of colors and font.
|
|
* Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
|
|
* if the combination is new.
|
|
* Return 0 for error (no more room).
|
|
*/
|
|
static int
|
|
get_attr_entry(garray_T *table, attrentry_T *aep)
|
|
{
|
|
int i;
|
|
attrentry_T *taep;
|
|
static int recursive = FALSE;
|
|
|
|
// Init the table, in case it wasn't done yet.
|
|
table->ga_itemsize = sizeof(attrentry_T);
|
|
table->ga_growsize = 7;
|
|
|
|
// Try to find an entry with the same specifications.
|
|
for (i = 0; i < table->ga_len; ++i)
|
|
{
|
|
taep = &(((attrentry_T *)table->ga_data)[i]);
|
|
if ( aep->ae_attr == taep->ae_attr
|
|
&& (
|
|
#ifdef FEAT_GUI
|
|
(table == &gui_attr_table
|
|
&& (aep->ae_u.gui.fg_color == taep->ae_u.gui.fg_color
|
|
&& aep->ae_u.gui.bg_color
|
|
== taep->ae_u.gui.bg_color
|
|
&& aep->ae_u.gui.sp_color
|
|
== taep->ae_u.gui.sp_color
|
|
&& aep->ae_u.gui.font == taep->ae_u.gui.font
|
|
# ifdef FEAT_XFONTSET
|
|
&& aep->ae_u.gui.fontset == taep->ae_u.gui.fontset
|
|
# endif
|
|
))
|
|
||
|
|
#endif
|
|
(table == &term_attr_table
|
|
&& (aep->ae_u.term.start == NULL)
|
|
== (taep->ae_u.term.start == NULL)
|
|
&& (aep->ae_u.term.start == NULL
|
|
|| STRCMP(aep->ae_u.term.start,
|
|
taep->ae_u.term.start) == 0)
|
|
&& (aep->ae_u.term.stop == NULL)
|
|
== (taep->ae_u.term.stop == NULL)
|
|
&& (aep->ae_u.term.stop == NULL
|
|
|| STRCMP(aep->ae_u.term.stop,
|
|
taep->ae_u.term.stop) == 0))
|
|
|| (table == &cterm_attr_table
|
|
&& aep->ae_u.cterm.fg_color
|
|
== taep->ae_u.cterm.fg_color
|
|
&& aep->ae_u.cterm.bg_color
|
|
== taep->ae_u.cterm.bg_color
|
|
&& aep->ae_u.cterm.ul_color
|
|
== taep->ae_u.cterm.ul_color
|
|
&& aep->ae_u.cterm.font
|
|
== taep->ae_u.cterm.font
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
&& aep->ae_u.cterm.fg_rgb
|
|
== taep->ae_u.cterm.fg_rgb
|
|
&& aep->ae_u.cterm.bg_rgb
|
|
== taep->ae_u.cterm.bg_rgb
|
|
&& aep->ae_u.cterm.ul_rgb
|
|
== taep->ae_u.cterm.ul_rgb
|
|
#endif
|
|
)))
|
|
|
|
return i + ATTR_OFF;
|
|
}
|
|
|
|
if (table->ga_len + ATTR_OFF > MAX_TYPENR)
|
|
{
|
|
// Running out of attribute entries! remove all attributes, and
|
|
// compute new ones for all groups.
|
|
// When called recursively, we are really out of numbers.
|
|
if (recursive)
|
|
{
|
|
emsg(_(e_too_many_different_highlighting_attributes_in_use));
|
|
return 0;
|
|
}
|
|
recursive = TRUE;
|
|
|
|
clear_hl_tables();
|
|
|
|
set_must_redraw(UPD_CLEAR);
|
|
|
|
for (i = 0; i < highlight_ga.ga_len; ++i)
|
|
set_hl_attr(i);
|
|
|
|
recursive = FALSE;
|
|
}
|
|
|
|
// This is a new combination of colors and font, add an entry.
|
|
if (ga_grow(table, 1) == FAIL)
|
|
return 0;
|
|
|
|
taep = &(((attrentry_T *)table->ga_data)[table->ga_len]);
|
|
CLEAR_POINTER(taep);
|
|
taep->ae_attr = aep->ae_attr;
|
|
#ifdef FEAT_GUI
|
|
if (table == &gui_attr_table)
|
|
{
|
|
taep->ae_u.gui.fg_color = aep->ae_u.gui.fg_color;
|
|
taep->ae_u.gui.bg_color = aep->ae_u.gui.bg_color;
|
|
taep->ae_u.gui.sp_color = aep->ae_u.gui.sp_color;
|
|
taep->ae_u.gui.font = aep->ae_u.gui.font;
|
|
# ifdef FEAT_XFONTSET
|
|
taep->ae_u.gui.fontset = aep->ae_u.gui.fontset;
|
|
# endif
|
|
}
|
|
#endif
|
|
if (table == &term_attr_table)
|
|
{
|
|
if (aep->ae_u.term.start == NULL)
|
|
taep->ae_u.term.start = NULL;
|
|
else
|
|
taep->ae_u.term.start = vim_strsave(aep->ae_u.term.start);
|
|
if (aep->ae_u.term.stop == NULL)
|
|
taep->ae_u.term.stop = NULL;
|
|
else
|
|
taep->ae_u.term.stop = vim_strsave(aep->ae_u.term.stop);
|
|
}
|
|
else if (table == &cterm_attr_table)
|
|
{
|
|
taep->ae_u.cterm.fg_color = aep->ae_u.cterm.fg_color;
|
|
taep->ae_u.cterm.bg_color = aep->ae_u.cterm.bg_color;
|
|
taep->ae_u.cterm.ul_color = aep->ae_u.cterm.ul_color;
|
|
taep->ae_u.cterm.font = aep->ae_u.cterm.font;
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
taep->ae_u.cterm.fg_rgb = aep->ae_u.cterm.fg_rgb;
|
|
taep->ae_u.cterm.bg_rgb = aep->ae_u.cterm.bg_rgb;
|
|
taep->ae_u.cterm.ul_rgb = aep->ae_u.cterm.ul_rgb;
|
|
#endif
|
|
}
|
|
++table->ga_len;
|
|
return (table->ga_len - 1 + ATTR_OFF);
|
|
}
|
|
|
|
#if defined(FEAT_TERMINAL) || defined(PROTO)
|
|
/*
|
|
* Get an attribute index for a cterm entry.
|
|
* Uses an existing entry when possible or adds one when needed.
|
|
*/
|
|
int
|
|
get_cterm_attr_idx(int attr, int fg, int bg)
|
|
{
|
|
attrentry_T at_en;
|
|
|
|
CLEAR_FIELD(at_en);
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
at_en.ae_u.cterm.fg_rgb = INVALCOLOR;
|
|
at_en.ae_u.cterm.bg_rgb = INVALCOLOR;
|
|
at_en.ae_u.cterm.ul_rgb = INVALCOLOR;
|
|
#endif
|
|
at_en.ae_attr = attr;
|
|
at_en.ae_u.cterm.fg_color = fg;
|
|
at_en.ae_u.cterm.bg_color = bg;
|
|
at_en.ae_u.cterm.ul_color = 0;
|
|
at_en.ae_u.cterm.font = 0;
|
|
return get_attr_entry(&cterm_attr_table, &at_en);
|
|
}
|
|
#endif
|
|
|
|
#if (defined(FEAT_TERMINAL) && defined(FEAT_TERMGUICOLORS)) || defined(PROTO)
|
|
/*
|
|
* Get an attribute index for a 'termguicolors' entry.
|
|
* Uses an existing entry when possible or adds one when needed.
|
|
*/
|
|
int
|
|
get_tgc_attr_idx(int attr, guicolor_T fg, guicolor_T bg)
|
|
{
|
|
attrentry_T at_en;
|
|
|
|
CLEAR_FIELD(at_en);
|
|
at_en.ae_attr = attr;
|
|
if (fg == INVALCOLOR && bg == INVALCOLOR)
|
|
{
|
|
// If both GUI colors are not set fall back to the cterm colors. Helps
|
|
// if the GUI only has an attribute, such as undercurl.
|
|
at_en.ae_u.cterm.fg_rgb = CTERMCOLOR;
|
|
at_en.ae_u.cterm.bg_rgb = CTERMCOLOR;
|
|
}
|
|
else
|
|
{
|
|
at_en.ae_u.cterm.fg_rgb = fg;
|
|
at_en.ae_u.cterm.bg_rgb = bg;
|
|
}
|
|
at_en.ae_u.cterm.ul_rgb = INVALCOLOR;
|
|
return get_attr_entry(&cterm_attr_table, &at_en);
|
|
}
|
|
#endif
|
|
|
|
#if (defined(FEAT_TERMINAL) && defined(FEAT_GUI)) || defined(PROTO)
|
|
/*
|
|
* Get an attribute index for a cterm entry.
|
|
* Uses an existing entry when possible or adds one when needed.
|
|
*/
|
|
int
|
|
get_gui_attr_idx(int attr, guicolor_T fg, guicolor_T bg)
|
|
{
|
|
attrentry_T at_en;
|
|
|
|
CLEAR_FIELD(at_en);
|
|
at_en.ae_attr = attr;
|
|
at_en.ae_u.gui.fg_color = fg;
|
|
at_en.ae_u.gui.bg_color = bg;
|
|
return get_attr_entry(&gui_attr_table, &at_en);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Clear all highlight tables.
|
|
*/
|
|
void
|
|
clear_hl_tables(void)
|
|
{
|
|
int i;
|
|
attrentry_T *taep;
|
|
|
|
#ifdef FEAT_GUI
|
|
ga_clear(&gui_attr_table);
|
|
#endif
|
|
for (i = 0; i < term_attr_table.ga_len; ++i)
|
|
{
|
|
taep = &(((attrentry_T *)term_attr_table.ga_data)[i]);
|
|
vim_free(taep->ae_u.term.start);
|
|
vim_free(taep->ae_u.term.stop);
|
|
}
|
|
ga_clear(&term_attr_table);
|
|
ga_clear(&cterm_attr_table);
|
|
}
|
|
|
|
/*
|
|
* Combine special attributes (e.g., for spelling) with other attributes
|
|
* (e.g., for syntax highlighting).
|
|
* "prim_attr" overrules "char_attr".
|
|
* This creates a new group when required.
|
|
* Since we expect there to be few spelling mistakes we don't cache the
|
|
* result.
|
|
* Return the resulting attributes.
|
|
*/
|
|
int
|
|
hl_combine_attr(int char_attr, int prim_attr)
|
|
{
|
|
attrentry_T *char_aep = NULL;
|
|
attrentry_T *prim_aep;
|
|
attrentry_T new_en;
|
|
|
|
if (char_attr == 0)
|
|
return prim_attr;
|
|
if (char_attr <= HL_ALL && prim_attr <= HL_ALL)
|
|
return ATTR_COMBINE(char_attr, prim_attr);
|
|
#ifdef FEAT_GUI
|
|
if (gui.in_use)
|
|
{
|
|
if (char_attr > HL_ALL)
|
|
char_aep = syn_gui_attr2entry(char_attr);
|
|
if (char_aep != NULL)
|
|
new_en = *char_aep;
|
|
else
|
|
{
|
|
CLEAR_FIELD(new_en);
|
|
new_en.ae_u.gui.fg_color = INVALCOLOR;
|
|
new_en.ae_u.gui.bg_color = INVALCOLOR;
|
|
new_en.ae_u.gui.sp_color = INVALCOLOR;
|
|
if (char_attr <= HL_ALL)
|
|
new_en.ae_attr = char_attr;
|
|
}
|
|
|
|
if (prim_attr <= HL_ALL)
|
|
new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_attr);
|
|
else
|
|
{
|
|
prim_aep = syn_gui_attr2entry(prim_attr);
|
|
if (prim_aep != NULL)
|
|
{
|
|
new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr,
|
|
prim_aep->ae_attr);
|
|
if (prim_aep->ae_u.gui.fg_color != INVALCOLOR)
|
|
new_en.ae_u.gui.fg_color = prim_aep->ae_u.gui.fg_color;
|
|
if (prim_aep->ae_u.gui.bg_color != INVALCOLOR)
|
|
new_en.ae_u.gui.bg_color = prim_aep->ae_u.gui.bg_color;
|
|
if (prim_aep->ae_u.gui.sp_color != INVALCOLOR)
|
|
new_en.ae_u.gui.sp_color = prim_aep->ae_u.gui.sp_color;
|
|
if (prim_aep->ae_u.gui.font != NOFONT)
|
|
new_en.ae_u.gui.font = prim_aep->ae_u.gui.font;
|
|
# ifdef FEAT_XFONTSET
|
|
if (prim_aep->ae_u.gui.fontset != NOFONTSET)
|
|
new_en.ae_u.gui.fontset = prim_aep->ae_u.gui.fontset;
|
|
# endif
|
|
}
|
|
}
|
|
return get_attr_entry(&gui_attr_table, &new_en);
|
|
}
|
|
#endif
|
|
|
|
if (IS_CTERM)
|
|
{
|
|
if (char_attr > HL_ALL)
|
|
char_aep = syn_cterm_attr2entry(char_attr);
|
|
if (char_aep != NULL)
|
|
new_en = *char_aep;
|
|
else
|
|
{
|
|
CLEAR_FIELD(new_en);
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
new_en.ae_u.cterm.bg_rgb = INVALCOLOR;
|
|
new_en.ae_u.cterm.fg_rgb = INVALCOLOR;
|
|
new_en.ae_u.cterm.ul_rgb = INVALCOLOR;
|
|
#endif
|
|
if (char_attr <= HL_ALL)
|
|
new_en.ae_attr = char_attr;
|
|
}
|
|
|
|
if (prim_attr <= HL_ALL)
|
|
new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_attr);
|
|
else
|
|
{
|
|
prim_aep = syn_cterm_attr2entry(prim_attr);
|
|
if (prim_aep != NULL)
|
|
{
|
|
new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr,
|
|
prim_aep->ae_attr);
|
|
if (prim_aep->ae_u.cterm.fg_color > 0)
|
|
new_en.ae_u.cterm.fg_color = prim_aep->ae_u.cterm.fg_color;
|
|
if (prim_aep->ae_u.cterm.bg_color > 0)
|
|
new_en.ae_u.cterm.bg_color = prim_aep->ae_u.cterm.bg_color;
|
|
if (prim_aep->ae_u.cterm.ul_color > 0)
|
|
new_en.ae_u.cterm.ul_color = prim_aep->ae_u.cterm.ul_color;
|
|
if (prim_aep->ae_u.cterm.font > 0)
|
|
new_en.ae_u.cterm.font = prim_aep->ae_u.cterm.font;
|
|
#ifdef FEAT_TERMGUICOLORS
|
|
// If both fg and bg are not set fall back to cterm colors.
|
|
// Helps for SpellBad which uses undercurl in the GUI.
|
|
if (COLOR_INVALID(prim_aep->ae_u.cterm.fg_rgb)
|
|
&& COLOR_INVALID(prim_aep->ae_u.cterm.bg_rgb))
|
|
{
|
|
if (prim_aep->ae_u.cterm.fg_color > 0)
|
|
new_en.ae_u.cterm.fg_rgb = CTERMCOLOR;
|
|
if (prim_aep->ae_u.cterm.bg_color > 0)
|
|
new_en.ae_u.cterm.bg_rgb = CTERMCOLOR;
|
|
}
|
|
else
|
|
{
|
|
if (prim_aep->ae_u.cterm.fg_rgb != INVALCOLOR)
|
|
new_en.ae_u.cterm.fg_rgb = prim_aep->ae_u.cterm.fg_rgb;
|
|
if (prim_aep->ae_u.cterm.bg_rgb != INVALCOLOR)
|
|
new_en.ae_u.cterm.bg_rgb = prim_aep->ae_u.cterm.bg_rgb;
|
|
}
|
|
if (prim_aep->ae_u.cterm.ul_rgb != INVALCOLOR)
|
|
new_en.ae_u.cterm.ul_rgb = prim_aep->ae_u.cterm.ul_rgb;
|
|
#endif
|
|
}
|
|
}
|
|
return get_attr_entry(&cterm_attr_table, &new_en);
|
|
}
|
|
|
|
if (char_attr > HL_ALL)
|
|
char_aep = syn_term_attr2entry(char_attr);
|
|
if (char_aep != NULL)
|
|
new_en = *char_aep;
|
|
else
|
|
{
|
|
CLEAR_FIELD(new_en);
|
|
if (char_attr <= HL_ALL)
|
|
new_en.ae_attr = char_attr;
|
|
}
|
|
|
|
if (prim_attr <= HL_ALL)
|
|
new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_attr);
|
|
else
|
|
{
|
|
prim_aep = syn_term_attr2entry(prim_attr);
|
|
if (prim_aep != NULL)
|
|
{
|
|
new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_aep->ae_attr);
|
|
if (prim_aep->ae_u.term.start != NULL)
|
|
{
|
|
new_en.ae_u.term.start = prim_aep->ae_u.term.start;
|
|
new_en.ae_u.term.stop = prim_aep->ae_u.term.stop;
|
|
}
|
|
}
|
|
}
|
|
return get_attr_entry(&term_attr_table, &new_en);
|
|
}
|
|
|
|
#ifdef FEAT_GUI
|
|
attrentry_T *
|
|
syn_gui_attr2entry(int attr)
|
|
{
|
|
attr -= ATTR_OFF;
|
|
if (attr >= gui_attr_table.ga_len) // did ":syntax clear"
|
|
return NULL;
|
|
return &(GUI_ATTR_ENTRY(attr));
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Get the highlight attributes (HL_BOLD etc.) from an attribute nr.
|
|
* Only to be used when "attr" > HL_ALL.
|
|
*/
|
|
int
|
|
syn_attr2attr(int attr)
|
|
{
|
|
attrentry_T *aep;
|
|
|
|
#ifdef FEAT_GUI
|
|
if (gui.in_use)
|
|
aep = syn_gui_attr2entry(attr);
|
|
else
|
|
#endif
|
|
if (IS_CTERM)
|
|
aep = syn_cterm_attr2entry(attr);
|
|
else
|
|
aep = syn_term_attr2entry(attr);
|
|
|
|
if (aep == NULL) // highlighting not set
|
|
return 0;
|
|
return aep->ae_attr;
|
|
}
|
|
|
|
|
|
attrentry_T *
|
|
syn_term_attr2entry(int attr)
|
|
{
|
|
attr -= ATTR_OFF;
|
|
if (attr >= term_attr_table.ga_len) // did ":syntax clear"
|
|
return NULL;
|
|
return &(TERM_ATTR_ENTRY(attr));
|
|
}
|
|
|
|
attrentry_T *
|
|
syn_cterm_attr2entry(int attr)
|
|
{
|
|
attr -= ATTR_OFF;
|
|
if (attr >= cterm_attr_table.ga_len) // did ":syntax clear"
|
|
return NULL;
|
|
return &(CTERM_ATTR_ENTRY(attr));
|
|
}
|
|
|
|
#define LIST_ATTR 1
|
|
#define LIST_STRING 2
|
|
#define LIST_INT 3
|
|
|
|
static void
|
|
highlight_list_one(int id)
|
|
{
|
|
hl_group_T *sgp;
|
|
int didh = FALSE;
|
|
|
|
sgp = &HL_TABLE()[id - 1]; // index is ID minus one
|
|
|
|
if (message_filtered(sgp->sg_name))
|
|
return;
|
|
|
|
didh = highlight_list_arg(id, didh, LIST_ATTR,
|
|
sgp->sg_term, NULL, "term");
|
|
didh = highlight_list_arg(id, didh, LIST_STRING,
|
|
0, sgp->sg_start, "start");
|
|
didh = highlight_list_arg(id, didh, LIST_STRING,
|
|
0, sgp->sg_stop, "stop");
|
|
|
|
didh = highlight_list_arg(id, didh, LIST_ATTR,
|
|
sgp->sg_cterm, NULL, "cterm");
|
|
didh = highlight_list_arg(id, didh, LIST_INT,
|
|
sgp->sg_cterm_fg, NULL, "ctermfg");
|
|
didh = highlight_list_arg(id, didh, LIST_INT,
|
|
sgp->sg_cterm_bg, NULL, "ctermbg");
|
|
didh = highlight_list_arg(id, didh, LIST_INT,
|
|
sgp->sg_cterm_ul, NULL, "ctermul");
|
|
didh = highlight_list_arg(id, didh, LIST_INT,
|
|
sgp->sg_cterm_font, NULL, "ctermfont");
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
didh = highlight_list_arg(id, didh, LIST_ATTR,
|
|
sgp->sg_gui, NULL, "gui");
|
|
didh = highlight_list_arg(id, didh, LIST_STRING,
|
|
0, sgp->sg_gui_fg_name, "guifg");
|
|
didh = highlight_list_arg(id, didh, LIST_STRING,
|
|
0, sgp->sg_gui_bg_name, "guibg");
|
|
didh = highlight_list_arg(id, didh, LIST_STRING,
|
|
0, sgp->sg_gui_sp_name, "guisp");
|
|
#endif
|
|
#ifdef FEAT_GUI
|
|
didh = highlight_list_arg(id, didh, LIST_STRING,
|
|
0, sgp->sg_font_name, "font");
|
|
#endif
|
|
|
|
if (sgp->sg_link && !got_int)
|
|
{
|
|
(void)syn_list_header(didh, 9999, id);
|
|
didh = TRUE;
|
|
msg_puts_attr("links to", HL_ATTR(HLF_D));
|
|
msg_putchar(' ');
|
|
msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name);
|
|
}
|
|
|
|
if (!didh)
|
|
highlight_list_arg(id, didh, LIST_STRING, 0, (char_u *)"cleared", "");
|
|
#ifdef FEAT_EVAL
|
|
if (p_verbose > 0)
|
|
last_set_msg(sgp->sg_script_ctx);
|
|
#endif
|
|
}
|
|
|
|
static int
|
|
highlight_list_arg(
|
|
int id,
|
|
int didh,
|
|
int type,
|
|
int iarg,
|
|
char_u *sarg,
|
|
char *name)
|
|
{
|
|
char_u buf[MAX_ATTR_LEN];
|
|
char_u *ts;
|
|
int i;
|
|
|
|
if (got_int)
|
|
return FALSE;
|
|
|
|
if (type == LIST_STRING ? (sarg == NULL) : (iarg == 0))
|
|
return didh;
|
|
|
|
ts = buf;
|
|
if (type == LIST_INT)
|
|
sprintf((char *)buf, "%d", iarg - 1);
|
|
else if (type == LIST_STRING)
|
|
ts = sarg;
|
|
else // type == LIST_ATTR
|
|
{
|
|
size_t buflen;
|
|
|
|
buf[0] = NUL;
|
|
buflen = 0;
|
|
for (i = 0; i < (int)ARRAY_LENGTH(highlight_index_tab); ++i)
|
|
{
|
|
if (iarg & highlight_index_tab[i]->key)
|
|
{
|
|
if (buflen > 0)
|
|
{
|
|
STRCPY(buf + buflen, (char_u *)",");
|
|
++buflen;
|
|
}
|
|
STRCPY(buf + buflen, highlight_index_tab[i]->value.string);
|
|
buflen += highlight_index_tab[i]->value.length;
|
|
iarg &= ~highlight_index_tab[i]->key; // don't want "inverse"/"reverse"
|
|
}
|
|
}
|
|
}
|
|
|
|
(void)syn_list_header(didh,
|
|
(int)(vim_strsize(ts) + STRLEN(name) + 1), id);
|
|
didh = TRUE;
|
|
if (!got_int)
|
|
{
|
|
if (*name != NUL)
|
|
{
|
|
msg_puts_attr(name, HL_ATTR(HLF_D));
|
|
msg_puts_attr("=", HL_ATTR(HLF_D));
|
|
}
|
|
msg_outtrans(ts);
|
|
}
|
|
return didh;
|
|
}
|
|
|
|
#if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO)
|
|
/*
|
|
* Return "1" if highlight group "id" has attribute "flag".
|
|
* Return NULL otherwise.
|
|
*/
|
|
char_u *
|
|
highlight_has_attr(
|
|
int id,
|
|
int flag,
|
|
int modec) // 'g' for GUI, 'c' for cterm, 't' for term
|
|
{
|
|
int attr;
|
|
|
|
if (id <= 0 || id > highlight_ga.ga_len)
|
|
return NULL;
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
if (modec == 'g')
|
|
attr = HL_TABLE()[id - 1].sg_gui;
|
|
else
|
|
#endif
|
|
{
|
|
if (modec == 'c')
|
|
attr = HL_TABLE()[id - 1].sg_cterm;
|
|
else
|
|
attr = HL_TABLE()[id - 1].sg_term;
|
|
}
|
|
|
|
if (attr & flag)
|
|
return (char_u *)"1";
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
|
|
/*
|
|
* Return color name of highlight group "id".
|
|
*/
|
|
char_u *
|
|
highlight_color(
|
|
int id,
|
|
char_u *what, // "font", "fg", "bg", "sp", "ul", "fg#", "bg#" or "sp#"
|
|
int modec) // 'g' for GUI, 'c' for cterm, 't' for term
|
|
{
|
|
static char_u name[20];
|
|
int n;
|
|
int fg = FALSE;
|
|
int sp = FALSE;
|
|
int ul = FALSE;
|
|
int font = FALSE;
|
|
|
|
if (id <= 0 || id > highlight_ga.ga_len)
|
|
return NULL;
|
|
|
|
if (TOLOWER_ASC(what[0]) == 'f' && TOLOWER_ASC(what[1]) == 'g')
|
|
fg = TRUE;
|
|
else if (TOLOWER_ASC(what[0]) == 'f' && TOLOWER_ASC(what[1]) == 'o'
|
|
&& TOLOWER_ASC(what[2]) == 'n' && TOLOWER_ASC(what[3]) == 't')
|
|
font = TRUE;
|
|
else if (TOLOWER_ASC(what[0]) == 's' && TOLOWER_ASC(what[1]) == 'p')
|
|
sp = TRUE;
|
|
else if (TOLOWER_ASC(what[0]) == 'u' && TOLOWER_ASC(what[1]) == 'l')
|
|
ul = TRUE;
|
|
else if (!(TOLOWER_ASC(what[0]) == 'b' && TOLOWER_ASC(what[1]) == 'g'))
|
|
return NULL;
|
|
if (modec == 'g')
|
|
{
|
|
# if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
# ifdef FEAT_GUI
|
|
// return font name
|
|
if (font)
|
|
return HL_TABLE()[id - 1].sg_font_name;
|
|
# endif
|
|
|
|
// return #RRGGBB form (only possible when GUI is running)
|
|
if ((USE_24BIT) && what[2] == '#')
|
|
{
|
|
guicolor_T color;
|
|
long_u rgb;
|
|
static char_u buf[10];
|
|
|
|
if (fg)
|
|
color = HL_TABLE()[id - 1].sg_gui_fg;
|
|
else if (sp)
|
|
color = HL_TABLE()[id - 1].sg_gui_sp;
|
|
else
|
|
color = HL_TABLE()[id - 1].sg_gui_bg;
|
|
if (color == INVALCOLOR)
|
|
return NULL;
|
|
rgb = (long_u)GUI_MCH_GET_RGB(color);
|
|
sprintf((char *)buf, "#%02x%02x%02x",
|
|
(unsigned)(rgb >> 16),
|
|
(unsigned)(rgb >> 8) & 255,
|
|
(unsigned)rgb & 255);
|
|
return buf;
|
|
}
|
|
# endif
|
|
if (fg)
|
|
return (HL_TABLE()[id - 1].sg_gui_fg_name);
|
|
if (sp)
|
|
return (HL_TABLE()[id - 1].sg_gui_sp_name);
|
|
return (HL_TABLE()[id - 1].sg_gui_bg_name);
|
|
}
|
|
if (sp)
|
|
return NULL;
|
|
if (modec == 'c')
|
|
{
|
|
if (fg)
|
|
n = HL_TABLE()[id - 1].sg_cterm_fg - 1;
|
|
else if (ul)
|
|
n = HL_TABLE()[id - 1].sg_cterm_ul - 1;
|
|
else if (font)
|
|
n = HL_TABLE()[id - 1].sg_cterm_font - 1;
|
|
else
|
|
n = HL_TABLE()[id - 1].sg_cterm_bg - 1;
|
|
if (n < 0)
|
|
return NULL;
|
|
sprintf((char *)name, "%d", n);
|
|
return name;
|
|
}
|
|
// term doesn't have color
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#if (defined(FEAT_SYN_HL) \
|
|
&& (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)) \
|
|
&& defined(FEAT_PRINTER)) || defined(PROTO)
|
|
/*
|
|
* Return color name of highlight group "id" as RGB value.
|
|
*/
|
|
long_u
|
|
highlight_gui_color_rgb(
|
|
int id,
|
|
int fg) // TRUE = fg, FALSE = bg
|
|
{
|
|
guicolor_T color;
|
|
|
|
if (id <= 0 || id > highlight_ga.ga_len)
|
|
return 0L;
|
|
|
|
if (fg)
|
|
color = HL_TABLE()[id - 1].sg_gui_fg;
|
|
else
|
|
color = HL_TABLE()[id - 1].sg_gui_bg;
|
|
|
|
if (color == INVALCOLOR)
|
|
return 0L;
|
|
|
|
return GUI_MCH_GET_RGB(color);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Output the syntax list header.
|
|
* Return TRUE when started a new line.
|
|
*/
|
|
int
|
|
syn_list_header(
|
|
int did_header, // did header already
|
|
int outlen, // length of string that comes
|
|
int id) // highlight group id
|
|
{
|
|
int endcol = 19;
|
|
int newline = TRUE;
|
|
int name_col = 0;
|
|
|
|
if (!did_header)
|
|
{
|
|
msg_putchar('\n');
|
|
if (got_int)
|
|
return TRUE;
|
|
msg_outtrans(HL_TABLE()[id - 1].sg_name);
|
|
name_col = msg_col;
|
|
endcol = 15;
|
|
}
|
|
else if (msg_col + outlen + 1 >= Columns)
|
|
{
|
|
msg_putchar('\n');
|
|
if (got_int)
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (msg_col >= endcol) // wrap around is like starting a new line
|
|
newline = FALSE;
|
|
}
|
|
|
|
if (msg_col >= endcol) // output at least one space
|
|
endcol = msg_col + 1;
|
|
if (Columns <= (long)endcol) // avoid hang for tiny window
|
|
endcol = (int)(Columns - 1);
|
|
|
|
msg_advance(endcol);
|
|
|
|
// Show "xxx" with the attributes.
|
|
if (!did_header)
|
|
{
|
|
if (endcol == Columns - 1 && endcol <= name_col)
|
|
msg_putchar(' ');
|
|
msg_puts_attr("xxx", syn_id2attr(id));
|
|
msg_putchar(' ');
|
|
}
|
|
|
|
return newline;
|
|
}
|
|
|
|
/*
|
|
* Set the attribute numbers for a highlight group.
|
|
* Called after one of the attributes has changed.
|
|
*/
|
|
static void
|
|
set_hl_attr(
|
|
int idx) // index in array
|
|
{
|
|
attrentry_T at_en;
|
|
hl_group_T *sgp = HL_TABLE() + idx;
|
|
|
|
// The "Normal" group doesn't need an attribute number
|
|
if (sgp->sg_name_u != NULL && STRCMP(sgp->sg_name_u, "NORMAL") == 0)
|
|
return;
|
|
|
|
#ifdef FEAT_GUI
|
|
// For the GUI mode: If there are other than "normal" highlighting
|
|
// attributes, need to allocate an attr number.
|
|
if (sgp->sg_gui_fg == INVALCOLOR
|
|
&& sgp->sg_gui_bg == INVALCOLOR
|
|
&& sgp->sg_gui_sp == INVALCOLOR
|
|
&& sgp->sg_font == NOFONT
|
|
# ifdef FEAT_XFONTSET
|
|
&& sgp->sg_fontset == NOFONTSET
|
|
# endif
|
|
)
|
|
{
|
|
sgp->sg_gui_attr = sgp->sg_gui;
|
|
}
|
|
else
|
|
{
|
|
at_en.ae_attr = sgp->sg_gui;
|
|
at_en.ae_u.gui.fg_color = sgp->sg_gui_fg;
|
|
at_en.ae_u.gui.bg_color = sgp->sg_gui_bg;
|
|
at_en.ae_u.gui.sp_color = sgp->sg_gui_sp;
|
|
at_en.ae_u.gui.font = sgp->sg_font;
|
|
# ifdef FEAT_XFONTSET
|
|
at_en.ae_u.gui.fontset = sgp->sg_fontset;
|
|
# endif
|
|
sgp->sg_gui_attr = get_attr_entry(&gui_attr_table, &at_en);
|
|
}
|
|
#endif
|
|
// For the term mode: If there are other than "normal" highlighting
|
|
// attributes, need to allocate an attr number.
|
|
if (sgp->sg_start == NULL && sgp->sg_stop == NULL)
|
|
sgp->sg_term_attr = sgp->sg_term;
|
|
else
|
|
{
|
|
at_en.ae_attr = sgp->sg_term;
|
|
at_en.ae_u.term.start = sgp->sg_start;
|
|
at_en.ae_u.term.stop = sgp->sg_stop;
|
|
sgp->sg_term_attr = get_attr_entry(&term_attr_table, &at_en);
|
|
}
|
|
|
|
// For the color term mode: If there are other than "normal"
|
|
// highlighting attributes, need to allocate an attr number.
|
|
if (sgp->sg_cterm_fg == 0 && sgp->sg_cterm_bg == 0 &&
|
|
sgp->sg_cterm_ul == 0 && sgp->sg_cterm_font == 0
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
&& sgp->sg_gui_fg == INVALCOLOR
|
|
&& sgp->sg_gui_bg == INVALCOLOR
|
|
&& sgp->sg_gui_sp == INVALCOLOR
|
|
# endif
|
|
)
|
|
sgp->sg_cterm_attr = sgp->sg_cterm;
|
|
else
|
|
{
|
|
at_en.ae_attr = sgp->sg_cterm;
|
|
at_en.ae_u.cterm.fg_color = sgp->sg_cterm_fg;
|
|
at_en.ae_u.cterm.bg_color = sgp->sg_cterm_bg;
|
|
at_en.ae_u.cterm.ul_color = sgp->sg_cterm_ul;
|
|
at_en.ae_u.cterm.font = sgp->sg_cterm_font;
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
at_en.ae_u.cterm.fg_rgb = GUI_MCH_GET_RGB2(sgp->sg_gui_fg);
|
|
at_en.ae_u.cterm.bg_rgb = GUI_MCH_GET_RGB2(sgp->sg_gui_bg);
|
|
// Only use the underline/undercurl color when used, it may clear the
|
|
// background color if not supported.
|
|
if (sgp->sg_cterm & (HL_UNDERLINE | HL_UNDERCURL
|
|
| HL_UNDERDOUBLE | HL_UNDERDOTTED | HL_UNDERDASHED))
|
|
at_en.ae_u.cterm.ul_rgb = GUI_MCH_GET_RGB2(sgp->sg_gui_sp);
|
|
else
|
|
at_en.ae_u.cterm.ul_rgb = INVALCOLOR;
|
|
if (at_en.ae_u.cterm.fg_rgb == INVALCOLOR
|
|
&& at_en.ae_u.cterm.bg_rgb == INVALCOLOR)
|
|
{
|
|
// If both fg and bg are invalid fall back to the cterm colors.
|
|
// Helps when the GUI only uses an attribute, e.g. undercurl.
|
|
at_en.ae_u.cterm.fg_rgb = CTERMCOLOR;
|
|
at_en.ae_u.cterm.bg_rgb = CTERMCOLOR;
|
|
}
|
|
# endif
|
|
sgp->sg_cterm_attr = get_attr_entry(&cterm_attr_table, &at_en);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Lookup a highlight group name and return its ID.
|
|
* If it is not found, 0 is returned.
|
|
*/
|
|
int
|
|
syn_name2id(char_u *name)
|
|
{
|
|
int i;
|
|
char_u name_u[MAX_SYN_NAME + 1];
|
|
|
|
// Avoid using stricmp() too much, it's slow on some systems
|
|
// Avoid alloc()/free(), these are slow too. ID names over 200 chars
|
|
// don't deserve to be found!
|
|
vim_strncpy(name_u, name, MAX_SYN_NAME);
|
|
vim_strup(name_u);
|
|
for (i = highlight_ga.ga_len; --i >= 0; )
|
|
if (HL_TABLE()[i].sg_name_u != NULL
|
|
&& STRCMP(name_u, HL_TABLE()[i].sg_name_u) == 0)
|
|
break;
|
|
return i + 1;
|
|
}
|
|
|
|
/*
|
|
* Lookup a highlight group name and return its attributes.
|
|
* Return zero if not found.
|
|
*/
|
|
int
|
|
syn_name2attr(char_u *name)
|
|
{
|
|
int id = syn_name2id(name);
|
|
|
|
if (id != 0)
|
|
return syn_id2attr(id);
|
|
return 0;
|
|
}
|
|
|
|
#if defined(FEAT_EVAL) || defined(PROTO)
|
|
/*
|
|
* Return TRUE if highlight group "name" exists.
|
|
*/
|
|
int
|
|
highlight_exists(char_u *name)
|
|
{
|
|
return (syn_name2id(name) > 0);
|
|
}
|
|
|
|
# if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
|
|
/*
|
|
* Return the name of highlight group "id".
|
|
* When not a valid ID return an empty string.
|
|
*/
|
|
char_u *
|
|
syn_id2name(int id)
|
|
{
|
|
if (id <= 0 || id > highlight_ga.ga_len)
|
|
return (char_u *)"";
|
|
return HL_TABLE()[id - 1].sg_name;
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
/*
|
|
* Like syn_name2id(), but take a pointer + length argument.
|
|
*/
|
|
int
|
|
syn_namen2id(char_u *linep, int len)
|
|
{
|
|
char_u *name;
|
|
int id = 0;
|
|
|
|
name = vim_strnsave(linep, len);
|
|
if (name == NULL)
|
|
return 0;
|
|
|
|
id = syn_name2id(name);
|
|
vim_free(name);
|
|
return id;
|
|
}
|
|
|
|
/*
|
|
* Find highlight group name in the table and return its ID.
|
|
* The argument is a pointer to the name and the length of the name.
|
|
* If it doesn't exist yet, a new entry is created.
|
|
* Return 0 for failure.
|
|
*/
|
|
int
|
|
syn_check_group(char_u *pp, int len)
|
|
{
|
|
int id;
|
|
char_u *name;
|
|
|
|
if (len > MAX_SYN_NAME)
|
|
{
|
|
emsg(_(e_highlight_group_name_too_long));
|
|
return 0;
|
|
}
|
|
name = vim_strnsave(pp, len);
|
|
if (name == NULL)
|
|
return 0;
|
|
|
|
id = syn_name2id(name);
|
|
if (id == 0) // doesn't exist yet
|
|
id = syn_add_group(name);
|
|
else
|
|
vim_free(name);
|
|
return id;
|
|
}
|
|
|
|
/*
|
|
* Add new highlight group and return its ID.
|
|
* "name" must be an allocated string, it will be consumed.
|
|
* Return 0 for failure.
|
|
*/
|
|
static int
|
|
syn_add_group(char_u *name)
|
|
{
|
|
char_u *p;
|
|
char_u *name_up;
|
|
|
|
// Check that the name is valid (ASCII letters, digits, underscores, dots, or hyphens).
|
|
for (p = name; *p != NUL; ++p)
|
|
{
|
|
if (!vim_isprintc(*p))
|
|
{
|
|
emsg(_(e_unprintable_character_in_group_name));
|
|
vim_free(name);
|
|
return 0;
|
|
}
|
|
else if (!ASCII_ISALNUM(*p) && *p != '_' && *p != '.' && *p != '-')
|
|
{
|
|
// This is an error, but since there previously was no check only
|
|
// give a warning.
|
|
msg_source(HL_ATTR(HLF_W));
|
|
msg(_("W18: Invalid character in group name"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// First call for this growarray: init growing array.
|
|
if (highlight_ga.ga_data == NULL)
|
|
{
|
|
highlight_ga.ga_itemsize = sizeof(hl_group_T);
|
|
highlight_ga.ga_growsize = 10;
|
|
}
|
|
|
|
if (highlight_ga.ga_len >= MAX_HL_ID)
|
|
{
|
|
emsg(_(e_too_many_highlight_and_syntax_groups));
|
|
vim_free(name);
|
|
return 0;
|
|
}
|
|
|
|
// Make room for at least one other syntax_highlight entry.
|
|
if (ga_grow(&highlight_ga, 1) == FAIL)
|
|
{
|
|
vim_free(name);
|
|
return 0;
|
|
}
|
|
|
|
name_up = vim_strsave_up(name);
|
|
if (name_up == NULL)
|
|
{
|
|
vim_free(name);
|
|
return 0;
|
|
}
|
|
|
|
CLEAR_POINTER(&(HL_TABLE()[highlight_ga.ga_len]));
|
|
HL_TABLE()[highlight_ga.ga_len].sg_name = name;
|
|
HL_TABLE()[highlight_ga.ga_len].sg_name_u = name_up;
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
|
|
HL_TABLE()[highlight_ga.ga_len].sg_gui_bg = INVALCOLOR;
|
|
HL_TABLE()[highlight_ga.ga_len].sg_gui_fg = INVALCOLOR;
|
|
HL_TABLE()[highlight_ga.ga_len].sg_gui_sp = INVALCOLOR;
|
|
#endif
|
|
++highlight_ga.ga_len;
|
|
|
|
return highlight_ga.ga_len; // ID is index plus one
|
|
}
|
|
|
|
/*
|
|
* When, just after calling syn_add_group(), an error is discovered, this
|
|
* function deletes the new name.
|
|
*/
|
|
static void
|
|
syn_unadd_group(void)
|
|
{
|
|
--highlight_ga.ga_len;
|
|
vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name);
|
|
vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name_u);
|
|
}
|
|
|
|
/*
|
|
* Translate a group ID to highlight attributes.
|
|
* "hl_id" must be valid: > 0, caller must check.
|
|
*/
|
|
int
|
|
syn_id2attr(int hl_id)
|
|
{
|
|
int attr;
|
|
hl_group_T *sgp;
|
|
|
|
hl_id = syn_get_final_id(hl_id);
|
|
sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one
|
|
|
|
#ifdef FEAT_GUI
|
|
// Only use GUI attr when the GUI is being used.
|
|
if (gui.in_use)
|
|
attr = sgp->sg_gui_attr;
|
|
else
|
|
#endif
|
|
if (IS_CTERM)
|
|
attr = sgp->sg_cterm_attr;
|
|
else
|
|
attr = sgp->sg_term_attr;
|
|
|
|
return attr;
|
|
}
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO)
|
|
/*
|
|
* Get the GUI colors and attributes for a group ID.
|
|
* NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
|
|
*/
|
|
int
|
|
syn_id2colors(int hl_id, guicolor_T *fgp, guicolor_T *bgp)
|
|
{
|
|
hl_group_T *sgp;
|
|
|
|
hl_id = syn_get_final_id(hl_id);
|
|
sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one
|
|
|
|
*fgp = sgp->sg_gui_fg;
|
|
*bgp = sgp->sg_gui_bg;
|
|
return sgp->sg_gui;
|
|
}
|
|
#endif
|
|
|
|
#if (defined(MSWIN) \
|
|
&& (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) \
|
|
&& defined(FEAT_TERMGUICOLORS)) \
|
|
|| defined(FEAT_TERMINAL) || defined(PROTO)
|
|
void
|
|
syn_id2cterm_bg(int hl_id, int *fgp, int *bgp)
|
|
{
|
|
hl_group_T *sgp;
|
|
|
|
hl_id = syn_get_final_id(hl_id);
|
|
sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one
|
|
*fgp = sgp->sg_cterm_fg - 1;
|
|
*bgp = sgp->sg_cterm_bg - 1;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Translate a group ID to the final group ID (following links).
|
|
*/
|
|
int
|
|
syn_get_final_id(int hl_id)
|
|
{
|
|
int count;
|
|
hl_group_T *sgp;
|
|
|
|
if (hl_id > highlight_ga.ga_len || hl_id < 1)
|
|
return 0; // Can be called from eval!!
|
|
|
|
// Follow links until there is no more.
|
|
// Look out for loops! Break after 100 links.
|
|
for (count = 100; --count >= 0; )
|
|
{
|
|
sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one
|
|
if (sgp->sg_link == 0 || sgp->sg_link > highlight_ga.ga_len)
|
|
break;
|
|
hl_id = sgp->sg_link;
|
|
}
|
|
|
|
return hl_id;
|
|
}
|
|
|
|
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO)
|
|
/*
|
|
* Call this function just after the GUI has started.
|
|
* Also called when 'termguicolors' was set, gui.in_use will be FALSE then.
|
|
* It finds the font and color handles for the highlighting groups.
|
|
*/
|
|
void
|
|
highlight_gui_started(void)
|
|
{
|
|
int idx;
|
|
|
|
// First get the colors from the "Normal" and "Menu" group, if set
|
|
if (USE_24BIT)
|
|
set_normal_colors();
|
|
|
|
for (idx = 0; idx < highlight_ga.ga_len; ++idx)
|
|
gui_do_one_color(idx, FALSE, FALSE);
|
|
|
|
highlight_changed();
|
|
}
|
|
|
|
static void
|
|
gui_do_one_color(
|
|
int idx,
|
|
int do_menu UNUSED, // TRUE: might set the menu font
|
|
int do_tooltip UNUSED) // TRUE: might set the tooltip font
|
|
{
|
|
int didit = FALSE;
|
|
|
|
# ifdef FEAT_GUI
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
if (gui.in_use)
|
|
# endif
|
|
if (HL_TABLE()[idx].sg_font_name != NULL)
|
|
{
|
|
hl_do_font(idx, HL_TABLE()[idx].sg_font_name, FALSE, do_menu,
|
|
do_tooltip, TRUE);
|
|
didit = TRUE;
|
|
}
|
|
# endif
|
|
if (HL_TABLE()[idx].sg_gui_fg_name != NULL)
|
|
{
|
|
HL_TABLE()[idx].sg_gui_fg =
|
|
color_name2handle(HL_TABLE()[idx].sg_gui_fg_name);
|
|
didit = TRUE;
|
|
}
|
|
if (HL_TABLE()[idx].sg_gui_bg_name != NULL)
|
|
{
|
|
HL_TABLE()[idx].sg_gui_bg =
|
|
color_name2handle(HL_TABLE()[idx].sg_gui_bg_name);
|
|
didit = TRUE;
|
|
}
|
|
if (HL_TABLE()[idx].sg_gui_sp_name != NULL)
|
|
{
|
|
HL_TABLE()[idx].sg_gui_sp =
|
|
color_name2handle(HL_TABLE()[idx].sg_gui_sp_name);
|
|
didit = TRUE;
|
|
}
|
|
if (didit) // need to get a new attr number
|
|
set_hl_attr(idx);
|
|
}
|
|
#endif
|
|
|
|
#if defined(USER_HIGHLIGHT) && defined(FEAT_STL_OPT)
|
|
/*
|
|
* Apply difference between User[1-9] and HLF_S to HLF_SNC, HLF_ST or HLF_STNC.
|
|
*/
|
|
static void
|
|
combine_stl_hlt(
|
|
int id,
|
|
int id_S,
|
|
int id_alt,
|
|
int hlcnt,
|
|
int i,
|
|
int hlf,
|
|
int *table)
|
|
{
|
|
hl_group_T *hlt = HL_TABLE();
|
|
|
|
if (id_alt == 0)
|
|
{
|
|
CLEAR_POINTER(&hlt[hlcnt + i]);
|
|
hlt[hlcnt + i].sg_term = highlight_attr[hlf];
|
|
hlt[hlcnt + i].sg_cterm = highlight_attr[hlf];
|
|
# if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
hlt[hlcnt + i].sg_gui = highlight_attr[hlf];
|
|
# endif
|
|
}
|
|
else
|
|
mch_memmove(&hlt[hlcnt + i],
|
|
&hlt[id_alt - 1],
|
|
sizeof(hl_group_T));
|
|
hlt[hlcnt + i].sg_link = 0;
|
|
|
|
hlt[hlcnt + i].sg_term ^=
|
|
hlt[id - 1].sg_term ^ hlt[id_S - 1].sg_term;
|
|
if (hlt[id - 1].sg_start != hlt[id_S - 1].sg_start)
|
|
hlt[hlcnt + i].sg_start = hlt[id - 1].sg_start;
|
|
if (hlt[id - 1].sg_stop != hlt[id_S - 1].sg_stop)
|
|
hlt[hlcnt + i].sg_stop = hlt[id - 1].sg_stop;
|
|
hlt[hlcnt + i].sg_cterm ^=
|
|
hlt[id - 1].sg_cterm ^ hlt[id_S - 1].sg_cterm;
|
|
if (hlt[id - 1].sg_cterm_fg != hlt[id_S - 1].sg_cterm_fg)
|
|
hlt[hlcnt + i].sg_cterm_fg = hlt[id - 1].sg_cterm_fg;
|
|
if (hlt[id - 1].sg_cterm_bg != hlt[id_S - 1].sg_cterm_bg)
|
|
hlt[hlcnt + i].sg_cterm_bg = hlt[id - 1].sg_cterm_bg;
|
|
if (hlt[id - 1].sg_cterm_font != hlt[id_S - 1].sg_cterm_font)
|
|
hlt[hlcnt + i].sg_cterm_font = hlt[id - 1].sg_cterm_font;
|
|
# if defined(FEAT_GUI) || defined(FEAT_EVAL)
|
|
hlt[hlcnt + i].sg_gui ^=
|
|
hlt[id - 1].sg_gui ^ hlt[id_S - 1].sg_gui;
|
|
# endif
|
|
# ifdef FEAT_GUI
|
|
if (hlt[id - 1].sg_gui_fg != hlt[id_S - 1].sg_gui_fg)
|
|
hlt[hlcnt + i].sg_gui_fg = hlt[id - 1].sg_gui_fg;
|
|
if (hlt[id - 1].sg_gui_bg != hlt[id_S - 1].sg_gui_bg)
|
|
hlt[hlcnt + i].sg_gui_bg = hlt[id - 1].sg_gui_bg;
|
|
if (hlt[id - 1].sg_gui_sp != hlt[id_S - 1].sg_gui_sp)
|
|
hlt[hlcnt + i].sg_gui_sp = hlt[id - 1].sg_gui_sp;
|
|
if (hlt[id - 1].sg_font != hlt[id_S - 1].sg_font)
|
|
hlt[hlcnt + i].sg_font = hlt[id - 1].sg_font;
|
|
# ifdef FEAT_XFONTSET
|
|
if (hlt[id - 1].sg_fontset != hlt[id_S - 1].sg_fontset)
|
|
hlt[hlcnt + i].sg_fontset = hlt[id - 1].sg_fontset;
|
|
# endif
|
|
# endif
|
|
highlight_ga.ga_len = hlcnt + i + 1;
|
|
set_hl_attr(hlcnt + i); // At long last we can apply
|
|
table[i] = syn_id2attr(hlcnt + i + 1);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Translate the 'highlight' option into attributes in highlight_attr[] and
|
|
* set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of
|
|
* corresponding highlights to use on top of HLF_SNC is computed.
|
|
* Called only when the 'highlight' option has been changed and upon first
|
|
* screen redraw after any :highlight command.
|
|
* Return FAIL when an invalid flag is found in 'highlight'. OK otherwise.
|
|
*/
|
|
int
|
|
highlight_changed(void)
|
|
{
|
|
int hlf;
|
|
int i;
|
|
char_u *p;
|
|
int attr;
|
|
char_u *end;
|
|
int id;
|
|
#ifdef USER_HIGHLIGHT
|
|
char_u userhl[30]; // use 30 to avoid compiler warning
|
|
# ifdef FEAT_STL_OPT
|
|
int id_S = -1;
|
|
int id_SNC = 0;
|
|
# ifdef FEAT_TERMINAL
|
|
int id_ST = 0;
|
|
int id_STNC = 0;
|
|
# endif
|
|
int hlcnt;
|
|
# endif
|
|
#endif
|
|
static int hl_flags[HLF_COUNT] = HL_FLAGS;
|
|
|
|
need_highlight_changed = FALSE;
|
|
|
|
#ifdef FEAT_TERMINAL
|
|
term_update_colors_all();
|
|
term_update_wincolor_all();
|
|
#endif
|
|
|
|
// Clear all attributes.
|
|
for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf)
|
|
highlight_attr[hlf] = 0;
|
|
|
|
// First set all attributes to their default value.
|
|
// Then use the attributes from the 'highlight' option.
|
|
for (i = 0; i < 2; ++i)
|
|
{
|
|
if (i)
|
|
p = p_hl;
|
|
else
|
|
p = get_highlight_default();
|
|
if (p == NULL) // just in case
|
|
continue;
|
|
|
|
while (*p)
|
|
{
|
|
for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf)
|
|
if (hl_flags[hlf] == *p)
|
|
break;
|
|
++p;
|
|
if (hlf == (int)HLF_COUNT || *p == NUL)
|
|
return FAIL;
|
|
|
|
// Allow several hl_flags to be combined, like "bu" for
|
|
// bold-underlined.
|
|
attr = 0;
|
|
for ( ; *p && *p != ','; ++p) // parse up to comma
|
|
{
|
|
if (VIM_ISWHITE(*p)) // ignore white space
|
|
continue;
|
|
|
|
if (attr > HL_ALL) // Combination with ':' is not allowed.
|
|
return FAIL;
|
|
|
|
// Note: Keep this in sync with expand_set_highlight().
|
|
switch (*p)
|
|
{
|
|
case 'b': attr |= HL_BOLD;
|
|
break;
|
|
case 'i': attr |= HL_ITALIC;
|
|
break;
|
|
case '-':
|
|
case 'n': // no highlighting
|
|
break;
|
|
case 'r': attr |= HL_INVERSE;
|
|
break;
|
|
case 's': attr |= HL_STANDOUT;
|
|
break;
|
|
case 'u': attr |= HL_UNDERLINE;
|
|
break;
|
|
case 'c': attr |= HL_UNDERCURL;
|
|
break;
|
|
case '2': attr |= HL_UNDERDOUBLE;
|
|
break;
|
|
case 'd': attr |= HL_UNDERDOTTED;
|
|
break;
|
|
case '=': attr |= HL_UNDERDASHED;
|
|
break;
|
|
case 't': attr |= HL_STRIKETHROUGH;
|
|
break;
|
|
case ':': ++p; // highlight group name
|
|
if (attr || *p == NUL) // no combinations
|
|
return FAIL;
|
|
end = vim_strchr(p, ',');
|
|
if (end == NULL)
|
|
end = p + STRLEN(p);
|
|
id = syn_check_group(p, (int)(end - p));
|
|
if (id == 0)
|
|
return FAIL;
|
|
attr = syn_id2attr(id);
|
|
p = end - 1;
|
|
#if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT)
|
|
if (hlf == (int)HLF_SNC)
|
|
id_SNC = syn_get_final_id(id);
|
|
# ifdef FEAT_TERMINAL
|
|
else if (hlf == (int)HLF_ST)
|
|
id_ST = syn_get_final_id(id);
|
|
else if (hlf == (int)HLF_STNC)
|
|
id_STNC = syn_get_final_id(id);
|
|
# endif
|
|
else if (hlf == (int)HLF_S)
|
|
id_S = syn_get_final_id(id);
|
|
#endif
|
|
break;
|
|
default: return FAIL;
|
|
}
|
|
}
|
|
highlight_attr[hlf] = attr;
|
|
|
|
p = skip_to_option_part(p); // skip comma and spaces
|
|
}
|
|
}
|
|
|
|
#ifdef USER_HIGHLIGHT
|
|
// Setup the user highlights
|
|
//
|
|
// Temporarily utilize 28 more hl entries:
|
|
// 9 for User1-User9 combined with StatusLineNC
|
|
// 9 for User1-User9 combined with StatusLineTerm
|
|
// 9 for User1-User9 combined with StatusLineTermNC
|
|
// 1 for StatusLine default
|
|
// Have to be in there simultaneously in case of table overflows in
|
|
// get_attr_entry()
|
|
# ifdef FEAT_STL_OPT
|
|
if (ga_grow(&highlight_ga, 28) == FAIL)
|
|
return FAIL;
|
|
hlcnt = highlight_ga.ga_len;
|
|
if (id_S == -1)
|
|
{
|
|
// Make sure id_S is always valid to simplify code below. Use the last
|
|
// entry.
|
|
CLEAR_POINTER(&HL_TABLE()[hlcnt + 27]);
|
|
HL_TABLE()[hlcnt + 18].sg_term = highlight_attr[HLF_S];
|
|
id_S = hlcnt + 19;
|
|
}
|
|
# endif
|
|
for (i = 0; i < 9; i++)
|
|
{
|
|
sprintf((char *)userhl, "User%d", i + 1);
|
|
id = syn_name2id(userhl);
|
|
if (id == 0)
|
|
{
|
|
highlight_user[i] = 0;
|
|
# ifdef FEAT_STL_OPT
|
|
highlight_stlnc[i] = 0;
|
|
# ifdef FEAT_TERMINAL
|
|
highlight_stlterm[i] = 0;
|
|
highlight_stltermnc[i] = 0;
|
|
# endif
|
|
# endif
|
|
}
|
|
else
|
|
{
|
|
highlight_user[i] = syn_id2attr(id);
|
|
# ifdef FEAT_STL_OPT
|
|
combine_stl_hlt(id, id_S, id_SNC, hlcnt, i,
|
|
HLF_SNC, highlight_stlnc);
|
|
# ifdef FEAT_TERMINAL
|
|
combine_stl_hlt(id, id_S, id_ST, hlcnt + 9, i,
|
|
HLF_ST, highlight_stlterm);
|
|
combine_stl_hlt(id, id_S, id_STNC, hlcnt + 18, i,
|
|
HLF_STNC, highlight_stltermnc);
|
|
# endif
|
|
# endif
|
|
}
|
|
}
|
|
# ifdef FEAT_STL_OPT
|
|
highlight_ga.ga_len = hlcnt;
|
|
# endif
|
|
|
|
#endif // USER_HIGHLIGHT
|
|
|
|
return OK;
|
|
}
|
|
|
|
static void highlight_list(void);
|
|
static void highlight_list_two(int cnt, int attr);
|
|
|
|
/*
|
|
* Handle command line completion for :highlight command.
|
|
*/
|
|
void
|
|
set_context_in_highlight_cmd(expand_T *xp, char_u *arg)
|
|
{
|
|
char_u *p;
|
|
|
|
// Default: expand group names
|
|
xp->xp_context = EXPAND_HIGHLIGHT;
|
|
xp->xp_pattern = arg;
|
|
include_link = 2;
|
|
include_default = 1;
|
|
|
|
if (*arg == NUL)
|
|
return;
|
|
|
|
// (part of) subcommand already typed
|
|
p = skiptowhite(arg);
|
|
if (*p == NUL)
|
|
return;
|
|
|
|
// past "default" or group name
|
|
include_default = 0;
|
|
if (STRNCMP("default", arg, p - arg) == 0)
|
|
{
|
|
arg = skipwhite(p);
|
|
xp->xp_pattern = arg;
|
|
p = skiptowhite(arg);
|
|
}
|
|
if (*p == NUL)
|
|
return;
|
|
|
|
// past group name
|
|
include_link = 0;
|
|
if (arg[1] == 'i' && arg[0] == 'N')
|
|
highlight_list();
|
|
if (STRNCMP("link", arg, p - arg) == 0
|
|
|| STRNCMP("clear", arg, p - arg) == 0)
|
|
{
|
|
xp->xp_pattern = skipwhite(p);
|
|
p = skiptowhite(xp->xp_pattern);
|
|
if (*p != NUL) // past first group name
|
|
{
|
|
xp->xp_pattern = skipwhite(p);
|
|
p = skiptowhite(xp->xp_pattern);
|
|
}
|
|
}
|
|
if (*p != NUL) // past group name(s)
|
|
xp->xp_context = EXPAND_NOTHING;
|
|
}
|
|
|
|
/*
|
|
* List highlighting matches in a nice way.
|
|
*/
|
|
static void
|
|
highlight_list(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 10; --i >= 0; )
|
|
highlight_list_two(i, HL_ATTR(HLF_D));
|
|
for (i = 40; --i >= 0; )
|
|
highlight_list_two(99, 0);
|
|
}
|
|
|
|
static void
|
|
highlight_list_two(int cnt, int attr)
|
|
{
|
|
msg_puts_attr(&("N \bI \b! \b"[cnt / 11]), attr);
|
|
msg_clr_eos();
|
|
out_flush();
|
|
ui_delay(cnt == 99 ? 40L : (long)cnt * 50L, FALSE);
|
|
}
|
|
|
|
/*
|
|
* Function given to ExpandGeneric() to obtain the list of group names.
|
|
*/
|
|
char_u *
|
|
get_highlight_name(expand_T *xp UNUSED, int idx)
|
|
{
|
|
return get_highlight_name_ext(xp, idx, TRUE);
|
|
}
|
|
|
|
/*
|
|
* Obtain a highlight group name.
|
|
* When "skip_cleared" is TRUE don't return a cleared entry.
|
|
*/
|
|
char_u *
|
|
get_highlight_name_ext(expand_T *xp UNUSED, int idx, int skip_cleared)
|
|
{
|
|
if (idx < 0)
|
|
return NULL;
|
|
|
|
// Items are never removed from the table, skip the ones that were
|
|
// cleared.
|
|
if (skip_cleared && idx < highlight_ga.ga_len && HL_TABLE()[idx].sg_cleared)
|
|
return (char_u *)"";
|
|
|
|
if (idx == highlight_ga.ga_len && include_none != 0)
|
|
return (char_u *)"none";
|
|
if (idx == highlight_ga.ga_len + include_none && include_default != 0)
|
|
return (char_u *)"default";
|
|
if (idx == highlight_ga.ga_len + include_none + include_default
|
|
&& include_link != 0)
|
|
return (char_u *)"link";
|
|
if (idx == highlight_ga.ga_len + include_none + include_default + 1
|
|
&& include_link != 0)
|
|
return (char_u *)"clear";
|
|
if (idx >= highlight_ga.ga_len)
|
|
return NULL;
|
|
return HL_TABLE()[idx].sg_name;
|
|
}
|
|
|
|
#if defined(FEAT_GUI) || defined(PROTO)
|
|
/*
|
|
* Free all the highlight group fonts.
|
|
* Used when quitting for systems which need it.
|
|
*/
|
|
void
|
|
free_highlight_fonts(void)
|
|
{
|
|
int idx;
|
|
|
|
for (idx = 0; idx < highlight_ga.ga_len; ++idx)
|
|
{
|
|
gui_mch_free_font(HL_TABLE()[idx].sg_font);
|
|
HL_TABLE()[idx].sg_font = NOFONT;
|
|
# ifdef FEAT_XFONTSET
|
|
gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
|
|
HL_TABLE()[idx].sg_fontset = NOFONTSET;
|
|
# endif
|
|
}
|
|
|
|
gui_mch_free_font(gui.norm_font);
|
|
# ifdef FEAT_XFONTSET
|
|
gui_mch_free_fontset(gui.fontset);
|
|
# endif
|
|
# ifndef FEAT_GUI_GTK
|
|
gui_mch_free_font(gui.bold_font);
|
|
gui_mch_free_font(gui.ital_font);
|
|
gui_mch_free_font(gui.boldital_font);
|
|
# endif
|
|
}
|
|
#endif
|
|
|
|
#if defined(FEAT_EVAL) || defined(PROTO)
|
|
/*
|
|
* Convert each of the highlight attribute bits (bold, standout, underline,
|
|
* etc.) set in 'hlattr' into a separate boolean item in a Dictionary with
|
|
* the attribute name as the key.
|
|
*/
|
|
static dict_T *
|
|
highlight_get_attr_dict(int hlattr)
|
|
{
|
|
dict_T *dict;
|
|
int i;
|
|
|
|
dict = dict_alloc();
|
|
if (dict == NULL)
|
|
return NULL;
|
|
|
|
for (i = 0; i < (int)ARRAY_LENGTH(highlight_index_tab); ++i)
|
|
{
|
|
if (hlattr & highlight_index_tab[i]->key)
|
|
{
|
|
dict_add_bool(dict, (char *)highlight_index_tab[i]->value.string,
|
|
VVAL_TRUE);
|
|
// don't want "inverse"/"reverse"
|
|
hlattr &= ~highlight_index_tab[i]->key;
|
|
}
|
|
}
|
|
|
|
return dict;
|
|
}
|
|
|
|
/*
|
|
* Return the attributes of the highlight group at index 'hl_idx' as a
|
|
* Dictionary. If 'resolve_link' is TRUE, then resolves the highlight group
|
|
* links recursively.
|
|
*/
|
|
static dict_T *
|
|
highlight_get_info(int hl_idx, int resolve_link)
|
|
{
|
|
dict_T *dict;
|
|
hl_group_T *sgp;
|
|
dict_T *attr_dict;
|
|
int hlgid;
|
|
|
|
dict = dict_alloc();
|
|
if (dict == NULL)
|
|
return dict;
|
|
|
|
sgp = &HL_TABLE()[hl_idx];
|
|
// highlight group id is 1-based
|
|
hlgid = hl_idx + 1;
|
|
|
|
if (dict_add_string(dict, "name", sgp->sg_name) == FAIL)
|
|
goto error;
|
|
if (dict_add_number(dict, "id", hlgid) == FAIL)
|
|
goto error;
|
|
|
|
if (sgp->sg_link && resolve_link)
|
|
{
|
|
// resolve the highlight group link recursively
|
|
while (sgp->sg_link)
|
|
{
|
|
hlgid = sgp->sg_link;
|
|
sgp = &HL_TABLE()[sgp->sg_link - 1];
|
|
}
|
|
}
|
|
|
|
if (sgp->sg_term != 0)
|
|
{
|
|
attr_dict = highlight_get_attr_dict(sgp->sg_term);
|
|
if (attr_dict != NULL)
|
|
if (dict_add_dict(dict, "term", attr_dict) == FAIL)
|
|
goto error;
|
|
}
|
|
if (sgp->sg_start != NULL)
|
|
if (dict_add_string(dict, "start", sgp->sg_start) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_stop != NULL)
|
|
if (dict_add_string(dict, "stop", sgp->sg_stop) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_cterm != 0)
|
|
{
|
|
attr_dict = highlight_get_attr_dict(sgp->sg_cterm);
|
|
if (attr_dict != NULL)
|
|
if (dict_add_dict(dict, "cterm", attr_dict) == FAIL)
|
|
goto error;
|
|
}
|
|
if (sgp->sg_cterm_fg != 0)
|
|
if (dict_add_string(dict, "ctermfg",
|
|
highlight_color(hlgid, (char_u *)"fg", 'c')) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_cterm_bg != 0)
|
|
if (dict_add_string(dict, "ctermbg",
|
|
highlight_color(hlgid, (char_u *)"bg", 'c')) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_cterm_ul != 0)
|
|
if (dict_add_string(dict, "ctermul",
|
|
highlight_color(hlgid, (char_u *)"ul", 'c')) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_cterm_font != 0)
|
|
if (dict_add_string(dict, "ctermfont",
|
|
highlight_color(hlgid, (char_u *)"font", 'c')) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_gui != 0)
|
|
{
|
|
attr_dict = highlight_get_attr_dict(sgp->sg_gui);
|
|
if (attr_dict != NULL)
|
|
if (dict_add_dict(dict, "gui", attr_dict) == FAIL)
|
|
goto error;
|
|
}
|
|
if (sgp->sg_gui_fg_name != NULL)
|
|
if (dict_add_string(dict, "guifg",
|
|
highlight_color(hlgid, (char_u *)"fg", 'g')) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_gui_bg_name != NULL)
|
|
if (dict_add_string(dict, "guibg",
|
|
highlight_color(hlgid, (char_u *)"bg", 'g')) == FAIL)
|
|
goto error;
|
|
if (sgp->sg_gui_sp_name != NULL)
|
|
if (dict_add_string(dict, "guisp",
|
|
highlight_color(hlgid, (char_u *)"sp", 'g')) == FAIL)
|
|
goto error;
|
|
# ifdef FEAT_GUI
|
|
if (sgp->sg_font_name != NULL)
|
|
if (dict_add_string(dict, "font", sgp->sg_font_name) == FAIL)
|
|
goto error;
|
|
# endif
|
|
if (sgp->sg_link)
|
|
{
|
|
char_u *link;
|
|
|
|
link = HL_TABLE()[sgp->sg_link - 1].sg_name;
|
|
if (link != NULL && dict_add_string(dict, "linksto", link) == FAIL)
|
|
goto error;
|
|
|
|
if (sgp->sg_deflink)
|
|
dict_add_bool(dict, "default", VVAL_TRUE);
|
|
}
|
|
if (dict_len(dict) == 2)
|
|
// If only 'name' is present, then the highlight group is cleared.
|
|
dict_add_bool(dict, "cleared", VVAL_TRUE);
|
|
|
|
return dict;
|
|
|
|
error:
|
|
vim_free(dict);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* "hlget([name])" function
|
|
* Return the attributes of a specific highlight group (if specified) or all
|
|
* the highlight groups.
|
|
*/
|
|
void
|
|
f_hlget(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
list_T *list;
|
|
dict_T *dict;
|
|
int i;
|
|
char_u *hlarg = NULL;
|
|
int resolve_link = FALSE;
|
|
|
|
if (rettv_list_alloc(rettv) == FAIL)
|
|
return;
|
|
|
|
if (check_for_opt_string_arg(argvars, 0) == FAIL
|
|
|| (argvars[0].v_type != VAR_UNKNOWN
|
|
&& check_for_opt_bool_arg(argvars, 1) == FAIL))
|
|
return;
|
|
|
|
if (argvars[0].v_type != VAR_UNKNOWN)
|
|
{
|
|
// highlight group name supplied
|
|
hlarg = tv_get_string_chk(&argvars[0]);
|
|
if (hlarg == NULL)
|
|
return;
|
|
|
|
if (argvars[1].v_type != VAR_UNKNOWN)
|
|
{
|
|
int error = FALSE;
|
|
|
|
resolve_link = tv_get_bool_chk(&argvars[1], &error);
|
|
if (error)
|
|
return;
|
|
}
|
|
}
|
|
|
|
list = rettv->vval.v_list;
|
|
for (i = 0; i < highlight_ga.ga_len && !got_int; ++i)
|
|
{
|
|
if (hlarg == NULL || STRICMP(hlarg, HL_TABLE()[i].sg_name) == 0)
|
|
{
|
|
dict = highlight_get_info(i, resolve_link);
|
|
if (dict != NULL)
|
|
list_append_dict(list, dict);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns the string value at 'dict[key]'. Returns NULL, if 'key' is not in
|
|
* 'dict' or the value is not a string type. If the value is not a string type
|
|
* or is NULL, then 'error' is set to TRUE.
|
|
*/
|
|
static char_u *
|
|
hldict_get_string(dict_T *dict, char_u *key, int *error)
|
|
{
|
|
dictitem_T *di;
|
|
|
|
*error = FALSE;
|
|
di = dict_find(dict, key, -1);
|
|
if (di == NULL)
|
|
return NULL;
|
|
|
|
if (di->di_tv.v_type != VAR_STRING || di->di_tv.vval.v_string == NULL)
|
|
{
|
|
emsg(_(e_string_required));
|
|
*error = TRUE;
|
|
return NULL;
|
|
}
|
|
|
|
return di->di_tv.vval.v_string;
|
|
}
|
|
|
|
/*
|
|
* Convert the highlight attribute Dictionary at 'dict[key]' into a string
|
|
* value in 'attr_str' of length 'len'. Returns FALSE if 'dict[key]' is not a
|
|
* Dictionary or is NULL.
|
|
*/
|
|
static int
|
|
hldict_attr_to_str(
|
|
dict_T *dict,
|
|
char_u *key,
|
|
char_u *attr_str,
|
|
size_t len)
|
|
{
|
|
dictitem_T *di;
|
|
dict_T *attrdict;
|
|
int i;
|
|
char_u *p;
|
|
|
|
attr_str[0] = NUL;
|
|
di = dict_find(dict, key, -1);
|
|
if (di == NULL)
|
|
return TRUE;
|
|
|
|
if (di->di_tv.v_type != VAR_DICT || di->di_tv.vval.v_dict == NULL)
|
|
{
|
|
emsg(_(e_dictionary_required));
|
|
return FALSE;
|
|
}
|
|
|
|
attrdict = di->di_tv.vval.v_dict;
|
|
|
|
// If the attribute dict is empty, then return NONE to clear the attributes
|
|
if (dict_len(attrdict) == 0)
|
|
{
|
|
vim_strcat(attr_str, (char_u *)"NONE", len);
|
|
return TRUE;
|
|
}
|
|
|
|
p = attr_str;
|
|
for (i = 0; i < (int)ARRAY_LENGTH(highlight_tab); ++i)
|
|
{
|
|
if (dict_get_bool(attrdict, (char *)highlight_tab[i].value.string,
|
|
VVAL_FALSE) == VVAL_TRUE)
|
|
{
|
|
if (p != attr_str && (size_t)(p - attr_str + 2) < len)
|
|
STRCPY(p, (char_u *)",");
|
|
if (p - attr_str + highlight_tab[i].value.length + 1 < len)
|
|
{
|
|
STRCPY(p, highlight_tab[i].value.string);
|
|
p += highlight_tab[i].value.length;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Temporary buffer used to store the command string produced by hlset().
|
|
// IObuff cannot be used for this as the error messages produced by hlset()
|
|
// internally use IObuff.
|
|
#define HLSETBUFSZ 512
|
|
static char_u hlsetBuf[HLSETBUFSZ + 1];
|
|
|
|
/*
|
|
* Add the highlight attribute "attr" of length "attrlen" and "value" at
|
|
* "dptr", which points into "hlsetBuf".
|
|
* Returns the updated pointer.
|
|
*/
|
|
static char_u *
|
|
add_attr_and_value(char_u *dptr, char_u *attr, int attrlen, char_u *value)
|
|
{
|
|
size_t vallen;
|
|
|
|
// Do nothing if the value is not specified or is empty
|
|
if (value == NULL || *value == NUL)
|
|
return dptr;
|
|
|
|
vallen = STRLEN(value);
|
|
if (dptr + attrlen + vallen + 1 < hlsetBuf + HLSETBUFSZ)
|
|
{
|
|
STRCPY(dptr, attr);
|
|
dptr += attrlen;
|
|
STRCPY(dptr, value);
|
|
dptr += vallen;
|
|
}
|
|
|
|
return dptr;
|
|
}
|
|
|
|
/*
|
|
* Add or update a highlight group using 'dict' items. Returns TRUE if
|
|
* successfully updated the highlight group.
|
|
*/
|
|
static int
|
|
hlg_add_or_update(dict_T *dict)
|
|
{
|
|
char_u *name;
|
|
int error;
|
|
char_u term_attr[MAX_ATTR_LEN];
|
|
char_u cterm_attr[MAX_ATTR_LEN];
|
|
char_u gui_attr[MAX_ATTR_LEN];
|
|
char_u *start;
|
|
char_u *stop;
|
|
char_u *ctermfg;
|
|
char_u *ctermbg;
|
|
char_u *ctermul;
|
|
char_u *ctermfont;
|
|
char_u *guifg;
|
|
char_u *guibg;
|
|
char_u *guisp;
|
|
# ifdef FEAT_GUI
|
|
char_u *font;
|
|
# endif
|
|
int forceit = FALSE;
|
|
int dodefault = FALSE;
|
|
int done = FALSE;
|
|
char_u *p;
|
|
|
|
name = hldict_get_string(dict, (char_u *)"name", &error);
|
|
if (name == NULL || *name == NUL || error)
|
|
return FALSE;
|
|
|
|
if (dict_get_bool(dict, "force", VVAL_FALSE) == VVAL_TRUE)
|
|
forceit = TRUE;
|
|
|
|
if (dict_get_bool(dict, "default", VVAL_FALSE) == VVAL_TRUE)
|
|
dodefault = TRUE;
|
|
|
|
if (dict_has_key(dict, "cleared"))
|
|
{
|
|
varnumber_T cleared;
|
|
|
|
// clear a highlight group
|
|
cleared = dict_get_bool(dict, "cleared", FALSE);
|
|
if (cleared == TRUE)
|
|
{
|
|
vim_snprintf((char *)hlsetBuf, HLSETBUFSZ, "clear %s", name);
|
|
do_highlight(hlsetBuf, forceit, FALSE);
|
|
done = TRUE;
|
|
}
|
|
}
|
|
|
|
if (dict_has_key(dict, "linksto"))
|
|
{
|
|
char_u *linksto;
|
|
|
|
// link highlight groups
|
|
linksto = hldict_get_string(dict, (char_u *)"linksto", &error);
|
|
if (linksto == NULL || *linksto == NUL || error)
|
|
return FALSE;
|
|
|
|
vim_snprintf((char *)hlsetBuf, HLSETBUFSZ, "%slink %s %s",
|
|
dodefault ? "default " : "", name, linksto);
|
|
do_highlight(hlsetBuf, forceit, FALSE);
|
|
|
|
done = TRUE;
|
|
}
|
|
|
|
// If 'cleared' or 'linksto' are specified, then don't process the other
|
|
// attributes.
|
|
if (done)
|
|
return TRUE;
|
|
|
|
start = hldict_get_string(dict, (char_u *)"start", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
stop = hldict_get_string(dict, (char_u *)"stop", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
if (!hldict_attr_to_str(dict, (char_u *)"term", term_attr,
|
|
sizeof(term_attr)))
|
|
return FALSE;
|
|
|
|
if (!hldict_attr_to_str(dict, (char_u *)"cterm", cterm_attr,
|
|
sizeof(cterm_attr)))
|
|
return FALSE;
|
|
|
|
ctermfg = hldict_get_string(dict, (char_u *)"ctermfg", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
ctermbg = hldict_get_string(dict, (char_u *)"ctermbg", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
ctermul = hldict_get_string(dict, (char_u *)"ctermul", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
ctermfont = hldict_get_string(dict, (char_u *)"ctermfont", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
if (!hldict_attr_to_str(dict, (char_u *)"gui", gui_attr, sizeof(gui_attr)))
|
|
return FALSE;
|
|
|
|
guifg = hldict_get_string(dict, (char_u *)"guifg", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
guibg = hldict_get_string(dict, (char_u *)"guibg", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
guisp = hldict_get_string(dict, (char_u *)"guisp", &error);
|
|
if (error)
|
|
return FALSE;
|
|
|
|
# ifdef FEAT_GUI
|
|
font = hldict_get_string(dict, (char_u *)"font", &error);
|
|
if (error)
|
|
return FALSE;
|
|
# endif
|
|
|
|
// If none of the attributes are specified, then do nothing.
|
|
if (term_attr[0] == NUL && start == NULL && stop == NULL
|
|
&& cterm_attr[0] == NUL && ctermfg == NULL && ctermbg == NULL
|
|
&& ctermul == NULL && ctermfont == NULL && gui_attr[0] == NUL
|
|
# ifdef FEAT_GUI
|
|
&& font == NULL
|
|
# endif
|
|
&& guifg == NULL && guibg == NULL && guisp == NULL
|
|
)
|
|
return TRUE;
|
|
|
|
hlsetBuf[0] = NUL;
|
|
p = hlsetBuf;
|
|
if (dodefault)
|
|
p = add_attr_and_value(p, (char_u *)"default", 7, (char_u *)" ");
|
|
p = add_attr_and_value(p, (char_u *)"", 0, name);
|
|
p = add_attr_and_value(p, (char_u *)" term=", 6, term_attr);
|
|
p = add_attr_and_value(p, (char_u *)" start=", 7, start);
|
|
p = add_attr_and_value(p, (char_u *)" stop=", 6, stop);
|
|
p = add_attr_and_value(p, (char_u *)" cterm=", 7, cterm_attr);
|
|
p = add_attr_and_value(p, (char_u *)" ctermfg=", 9, ctermfg);
|
|
p = add_attr_and_value(p, (char_u *)" ctermbg=", 9, ctermbg);
|
|
p = add_attr_and_value(p, (char_u *)" ctermul=", 9, ctermul);
|
|
p = add_attr_and_value(p, (char_u *)" ctermfont=", 9, ctermfont);
|
|
p = add_attr_and_value(p, (char_u *)" gui=", 5, gui_attr);
|
|
# ifdef FEAT_GUI
|
|
p = add_attr_and_value(p, (char_u *)" font=", 6, font);
|
|
# endif
|
|
p = add_attr_and_value(p, (char_u *)" guifg=", 7, guifg);
|
|
p = add_attr_and_value(p, (char_u *)" guibg=", 7, guibg);
|
|
(void)add_attr_and_value(p, (char_u *)" guisp=", 7, guisp);
|
|
|
|
do_highlight(hlsetBuf, forceit, FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* "hlset([{highlight_attr}])" function
|
|
* Add or modify highlight groups
|
|
*/
|
|
void
|
|
f_hlset(typval_T *argvars, typval_T *rettv)
|
|
{
|
|
listitem_T *li;
|
|
dict_T *dict;
|
|
|
|
rettv->vval.v_number = -1;
|
|
|
|
if (check_for_list_arg(argvars, 0) == FAIL)
|
|
return;
|
|
|
|
FOR_ALL_LIST_ITEMS(argvars->vval.v_list, li)
|
|
{
|
|
if (li->li_tv.v_type != VAR_DICT)
|
|
{
|
|
emsg(_(e_dictionary_required));
|
|
return;
|
|
}
|
|
|
|
dict = li->li_tv.vval.v_dict;
|
|
if (!hlg_add_or_update(dict))
|
|
return;
|
|
}
|
|
|
|
rettv->vval.v_number = 0;
|
|
}
|
|
#endif
|