CodeCow/Notepad3
1
0
Fork 0
mirror of https://github.com/rizonesoft/Notepad3.git synced 2026-06-14 21:09:05 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

+ chg: Styling current vs. default comparison instead of change flag

Browse Source
This commit is contained in:
Rainer Kottenhoff 2019-03-16 03:30:54 +01:00
parent beea99aff6
commit f3df116a66
50 changed files with 135 additions and 616 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Notepad3.c
View File

@ -3333,13 +3333,13 @@ static void _DynamicThemesMenuCmd(int cmd)
bool result = true;
if ((s_idxSelectedTheme > 1) && PathFileExists(Theme_Files[s_idxSelectedTheme].szFilePath))
{
result = Style_ImportFromFile(Theme_Files[s_idxSelectedTheme].szFilePath, false);
result = Style_ImportFromFile(Theme_Files[s_idxSelectedTheme].szFilePath);
}
else if (s_idxSelectedTheme == 1) {
result = Style_ImportFromFile(Globals.IniFile, false);
result = Style_ImportFromFile(Globals.IniFile);
}
else {
result = Style_ImportFromFile(L"", false);
result = Style_ImportFromFile(L"");
}
if (result) {

14
src/StyleLexers/EditLexer.h
View File

@ -15,19 +15,6 @@
#define BUFSIZE_STYLE_VALUE 256
// -----------------------------------------------------------------------------
typedef enum
{
FCT_SETTING_CHANGE, // value -b: reset style bit, 0: get bit-set, +b: set style bit
FCT_PASS
}
LexFunctionType;
typedef __int64 (*LexFunctionPtr_t)(LexFunctionType type, int value);
// -----------------------------------------------------------------------------
typedef struct _editstyle
@ -61,7 +48,6 @@ typedef struct _editlexer
LPCWSTR pszName;
LPCWSTR pszDefExt;
WCHAR szExtensions[BUFZIZE_STYLE_EXTENTIONS];
LexFunctionPtr_t pFctPtr;
PKEYWORDLIST pKeyWords;
EDITSTYLE Styles[];

23
src/StyleLexers/styleLexAHK.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_AHK = {
"break continue else exit exitapp gosub goto if ifequal ifexist ifgreater ifgreaterorequal "
"ifinstring ifless iflessorequal ifmsgbox ifnotequal ifnotexist ifnotinstring ifwinactive "
@ -120,7 +112,6 @@ KEYWORDLIST KeyWords_AHK = {
EDITLEXER lexAHK = {
SCLEX_AHK, IDS_LEX_AHK, L"AutoHotkey Script", L"", L"",
&LexFunction, // static
&KeyWords_AHK, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ SCE_AHK_DEFAULT, IDS_LEX_STR_63126, L"Default", L"", L"" },
@ -133,14 +124,14 @@ SCLEX_AHK, IDS_LEX_AHK, L"AutoHotkey Script", L"", L"",
{ {SCE_AHK_IDENTIFIER}, IDS_LEX_STR_63129, L"Identifier", L"fore:#CF2F0F", L"" },
{ {SCE_AHK_VARREF}, IDS_LEX_STR_63309, L"Variable Dereferencing", L"fore:#CF2F0F; back:#E4FFE4", L"" },
{ {SCE_AHK_LABEL}, IDS_LEX_STR_63235, L"Label", L"fore:#000000; back:#FFFFA1", L"" },
{ {SCE_AHK_WORD_CF}, IDS_LEX_STR_63310, L"Flow of Control", L"fore:#480048; bold", L"" },
{ {SCE_AHK_WORD_CF}, IDS_LEX_STR_63310, L"Flow of Control", L"bold; fore:#480048", L"" },
{ {SCE_AHK_WORD_CMD}, IDS_LEX_STR_63236, L"Command", L"fore:#004080", L"" },
{ {SCE_AHK_WORD_FN}, IDS_LEX_STR_63277, L"Function", L"fore:#0F707F; italic", L"" },
{ {SCE_AHK_WORD_DIR}, IDS_LEX_STR_63203, L"Directive", L"fore:#F04020; italic", L"" },
{ {SCE_AHK_WORD_KB}, IDS_LEX_STR_63311, L"Keys & Buttons", L"fore:#FF00FF; bold", L"" },
{ {SCE_AHK_WORD_VAR}, IDS_LEX_STR_63312, L"Built-In Variables", L"fore:#CF00CF; italic", L"" },
{ {SCE_AHK_WORD_SP}, IDS_LEX_STR_63280, L"Special", L"fore:#0000FF; italic", L"" },
{ {SCE_AHK_WORD_FN}, IDS_LEX_STR_63277, L"Function", L"italic; fore:#0F707F", L"" },
{ {SCE_AHK_WORD_DIR}, IDS_LEX_STR_63203, L"Directive", L"italic; fore:#F04020", L"" },
{ {SCE_AHK_WORD_KB}, IDS_LEX_STR_63311, L"Keys & Buttons", L"bold; fore:#FF00FF", L"" },
{ {SCE_AHK_WORD_VAR}, IDS_LEX_STR_63312, L"Built-In Variables", L"italic; fore:#CF00CF", L"" },
{ {SCE_AHK_WORD_SP}, IDS_LEX_STR_63280, L"Special", L"italic; fore:#0000FF", L"" },
//{ {SCE_AHK_WORD_UD}, IDS_LEX_STR_63106, L"User Defined", L"fore:#800020", L"" },
{ {SCE_AHK_VARREFKW}, IDS_LEX_STR_63313, L"Variable Keyword", L"fore:#CF00CF; italic; back:#F9F9FF", L"" },
{ {SCE_AHK_VARREFKW}, IDS_LEX_STR_63313, L"Variable Keyword", L"italic; fore:#CF00CF; back:#F9F9FF", L"" },
{ {SCE_AHK_ERROR}, IDS_LEX_STR_63261, L"Error", L"back:#FFC0C0", L"" },
EDITLEXER_SENTINEL } };

19
src/StyleLexers/styleLexAHKL.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_AHKL = {
// Directives
"#allowsamelinecomments #clipboardtimeout #commentflag #errorstdout #escapechar #hotkeyinterval "
@ -129,7 +121,6 @@ KEYWORDLIST KeyWords_AHKL = {
EDITLEXER lexAHKL = {
SCLEX_AHKL, IDS_LEX_AHKL, L"AutoHotkey_L Script", L"ahkl; ahk; ia; scriptlet", L"",
&LexFunction, // static
&KeyWords_AHKL, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_AHK_NEUTRAL}, IDS_LEX_STR_63126, L"Default", L"", L"" },
@ -146,15 +137,15 @@ SCLEX_AHKL, IDS_LEX_AHKL, L"AutoHotkey_L Script", L"ahkl; ahk; ia; scriptlet", L
{ {SCE_AHKL_VARREF}, IDS_LEX_STR_63309, L"Variable Dereferencing", L"fore:#990055", L"" },
{ {SCE_AHKL_OBJECT}, IDS_LEX_STR_63347, L"Object", L"fore:#008888", L"" },
{ {SCE_AHKL_USERFUNCTION}, IDS_LEX_STR_63305, L"User-Defined Function", L"fore:#0000DD", L"" },
{ {SCE_AHKL_DIRECTIVE}, IDS_LEX_STR_63203, L"Directive", L"fore:#4A0000; italic", L"" },
{ {SCE_AHKL_COMMAND}, IDS_LEX_STR_63236, L"Command", L"fore:#0000DD; bold", L"" },
{ {SCE_AHKL_DIRECTIVE}, IDS_LEX_STR_63203, L"Directive", L"italic; fore:#4A0000", L"" },
{ {SCE_AHKL_COMMAND}, IDS_LEX_STR_63236, L"Command", L"bold; fore:#0000DD", L"" },
{ {SCE_AHKL_PARAM}, IDS_LEX_STR_63281, L"Parameter", L"fore:#0085DD", L"" },
{ {SCE_AHKL_CONTROLFLOW}, IDS_LEX_STR_63310, L"Flow of Control", L"fore:#0000DD;", L"" },
{ {SCE_AHKL_CONTROLFLOW}, IDS_LEX_STR_63310, L"Flow of Control", L"fore:#0000DD", L"" },
{ {SCE_AHKL_BUILTINFUNCTION}, IDS_LEX_STR_63277, L"Function", L"fore:#DD00DD", L"" },
{ {SCE_AHKL_BUILTINVAR}, IDS_LEX_STR_63312, L"Built-In Variables", L"fore:#EE3010; bold", L"" },
{ {SCE_AHKL_BUILTINVAR}, IDS_LEX_STR_63312, L"Built-In Variables", L"bold; fore:#EE3010", L"" },
{ {SCE_AHKL_KEY}, IDS_LEX_STR_63348, L"Key", L"fore:#A2A2A2", L"" },
//{ {SCE_AHKL_USERDEFINED}, IDS_LEX_STR_63106, L"User Defined", L"fore:#800020", L"" },
//{ {SCE_AHKL_USERDEFINED}, IDS_LEX_STR_63106, L"User Defined", L"fore:#800020", L"" },
{ {SCE_AHKL_ESCAPESEQ}, IDS_LEX_STR_63306, L"Escape", L"fore:#660000; italic", L"" },
{ {SCE_AHKL_ESCAPESEQ}, IDS_LEX_STR_63306, L"Escape", L"italic; fore:#660000", L"" },
{ {SCE_AHKL_ERROR}, IDS_LEX_STR_63261, L"Error", L"back:#FF0000", L"" },
EDITLEXER_SENTINEL } };

9
src/StyleLexers/styleLexASM.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_ASM = {
"aaa aad aam aas adc add and arpl bound bsf bsr bswap bt btc btr bts call cbw cdq cflush clc cld "
"cli clts cmc cmova cmovae cmovb cmovbe cmovc cmove cmovg cmovge cmovl cmovle cmovna cmovnae "
@ -102,7 +94,6 @@ KEYWORDLIST KeyWords_ASM = {
EDITLEXER lexASM = {
SCLEX_ASM, IDS_LEX_ASM_SCR, L"Assembly Script", L"asm", L"",
&LexFunction, // static
&KeyWords_ASM, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_ASM_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexAU3.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_AU3 = {
"and byref case const continuecase continueloop default dim do else elseif endfunc endif "
"endselect endswitch endwith enum exit exitloop false for func global if in local next not "
@ -658,7 +650,6 @@ KEYWORDLIST KeyWords_AU3 = {
EDITLEXER lexAU3 = {
SCLEX_AU3, IDS_LEX_AUTOIT3, L"AutoIt3 Script", L"au3", L"",
&LexFunction, // static
&KeyWords_AU3, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ SCE_AU3_DEFAULT, IDS_LEX_STR_63126, L"Default", L"", L"" },

15
src/StyleLexers/styleLexAVS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_AVS = {
"true false return global",
"addborders alignedsplice amplify amplifydb animate applyrange assumebff assumefieldbased assumefps "
@ -87,7 +79,6 @@ KEYWORDLIST KeyWords_AVS = {
EDITLEXER lexAVS = {
SCLEX_AVS, IDS_LEX_AVI_SYNTH, L"AviSynth Script", L"avs; avsi", L"",
&LexFunction, // static
&KeyWords_AVS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_AVS_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
@ -95,9 +86,9 @@ SCLEX_AVS, IDS_LEX_AVI_SYNTH, L"AviSynth Script", L"avs; avsi", L"",
{ {SCE_AVS_OPERATOR}, IDS_LEX_STR_63132, L"Operator", L"", L"" },
{ {MULTI_STYLE(SCE_AVS_STRING,SCE_AVS_TRIPLESTRING,0,0)}, IDS_LEX_STR_63131, L"String", L"fore:#7F007F", L"" },
{ {SCE_AVS_NUMBER}, IDS_LEX_STR_63130, L"Number", L"fore:#007F7F", L"" },
{ {SCE_AVS_KEYWORD}, IDS_LEX_STR_63128, L"Keyword", L"fore:#00007F; bold", L"" },
{ {SCE_AVS_FILTER}, IDS_LEX_STR_63314, L"Filter", L"fore:#00007F; bold", L"" },
{ {SCE_AVS_PLUGIN}, IDS_LEX_STR_63315, L"Plugin", L"fore:#0080C0; bold", L"" },
{ {SCE_AVS_KEYWORD}, IDS_LEX_STR_63128, L"Keyword", L"bold; fore:#00007F", L"" },
{ {SCE_AVS_FILTER}, IDS_LEX_STR_63314, L"Filter", L"bold; fore:#00007F", L"" },
{ {SCE_AVS_PLUGIN}, IDS_LEX_STR_63315, L"Plugin", L"bold; fore:#0080C0", L"" },
{ {SCE_AVS_FUNCTION}, IDS_LEX_STR_63277, L"Function", L"fore:#007F7F", L"" },
{ {SCE_AVS_CLIPPROP}, IDS_LEX_STR_63316, L"Clip Property", L"fore:#00007F", L"" },
//{ {SCE_AVS_USERDFN}, IDS_LEX_STR_63106, L"User Defined", L"fore:#8000FF", L"" },

9
src/StyleLexers/styleLexAwk.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_Awk = {
// Keywords
"break case continue default do else exit function for if in next return switch while "
@ -29,7 +21,6 @@ KEYWORDLIST KeyWords_Awk = {
EDITLEXER lexAwk = {
SCLEX_PYTHON, IDS_LEX_AWK_SCR, L"Awk Script", L"awk", L"",
&LexFunction, // static
&KeyWords_Awk,{
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_P_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexBASH.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_BASH = {
"alias ar asa awk banner basename bash bc bdiff break bunzip2 bzip2 cal calendar case cat "
"cc cd chmod cksum clear cmp col comm compress continue cp cpio crypt csplit ctags cut date "
@ -29,7 +21,6 @@ KEYWORDLIST KeyWords_BASH = {
EDITLEXER lexBASH = {
SCLEX_BASH, IDS_LEX_SHELL_SCR, L"Shell Script", L"sh", L"",
&LexFunction, // static
&KeyWords_BASH, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_SH_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexBAT.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_BAT = {
"arp assoc attrib bcdedit bootcfg break cacls call cd change chcp chdir chkdsk chkntfs choice cipher "
"cleanmgr cls cmd cmdkey color com comp compact con convert copy country ctty date defined defrag del "
@ -26,7 +18,6 @@ KEYWORDLIST KeyWords_BAT = {
EDITLEXER lexBAT = {
SCLEX_BATCH, IDS_LEX_BATCH, L"Batch Files", L"bat; cmd", L"",
&LexFunction, // static
&KeyWords_BAT, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_BAT_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

12
src/StyleLexers/styleLexCMAKE.c
View File

@ -2,13 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_CMAKE = {
"add_custom_command add_custom_target add_definitions add_dependencies add_executable add_library "
"add_subdirectory add_test aux_source_directory build_command build_name cmake_minimum_required "
@ -40,12 +33,11 @@ KEYWORDLIST KeyWords_CMAKE = {
EDITLEXER lexCmake = {
SCLEX_CMAKE, IDS_LEX_CMAKE, L"Cmake Script", L"cmake; ctest", L"",
&LexFunction, // static
&KeyWords_CMAKE, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_CMAKE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {SCE_CMAKE_COMMENT}, IDS_LEX_STR_63127, L"Comment", L"fore:#008000", L"" },
{ {MULTI_STYLE(SCE_CMAKE_STRINGDQ,SCE_CMAKE_STRINGLQ,SCE_CMAKE_STRINGRQ,0)}, IDS_LEX_STR_63131, L"String", L"back:#EEEEEE; fore:#7F007F", L"" },
{ {MULTI_STYLE(SCE_CMAKE_STRINGDQ,SCE_CMAKE_STRINGLQ,SCE_CMAKE_STRINGRQ,0)}, IDS_LEX_STR_63131, L"String", L"fore:#7F007F; back:#EEEEEE", L"" },
{ {SCE_CMAKE_COMMANDS}, IDS_LEX_STR_63277, L"Function", L"fore:#00007F", L"" },
{ {SCE_CMAKE_PARAMETERS}, IDS_LEX_STR_63281, L"Parameter", L"fore:#7F200F", L"" },
{ {SCE_CMAKE_VARIABLE}, IDS_LEX_STR_63249, L"Variable", L"fore:#CC3300", L"" },
@ -53,7 +45,7 @@ SCLEX_CMAKE, IDS_LEX_CMAKE, L"Cmake Script", L"cmake; ctest", L"",
{ {SCE_CMAKE_FOREACHDEF}, IDS_LEX_STR_63326, L"For Each Def", L"fore:#00007F", L"" },
{ {SCE_CMAKE_IFDEFINEDEF}, IDS_LEX_STR_63327, L"If Def", L"fore:#00007F", L"" },
{ {SCE_CMAKE_MACRODEF}, IDS_LEX_STR_63328, L"Macro Def", L"fore:#00007F", L"" },
{ {SCE_CMAKE_STRINGVAR}, IDS_LEX_STR_63267, L"Variable within String", L"back:#EEEEEE; fore:#CC3300", L"" },
{ {SCE_CMAKE_STRINGVAR}, IDS_LEX_STR_63267, L"Variable within String", L"fore:#CC3300; back:#EEEEEE", L"" },
{ {SCE_CMAKE_NUMBER}, IDS_LEX_STR_63130, L"Number", L"fore:#008080", L"" },
//{ {SCE_CMAKE_USERDEFINED}, IDS_LEX_STR_63106, L"User Defined", L"fore:#800020", L"" },
EDITLEXER_SENTINEL } };

9
src/StyleLexers/styleLexCOFFEESCRIPT.c
View File

@ -2,20 +2,11 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_COFFEESCRIPT = EMPTY_KEYWORDLIST;
EDITLEXER lexCOFFEESCRIPT = {
SCLEX_COFFEESCRIPT, IDS_LEX_COFFEE_SCR, L"Coffeescript", L"coffee; Cakefile", L"",
&LexFunction, // static
&KeyWords_COFFEESCRIPT, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_COFFEESCRIPT_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexCONF.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_CONF = {
"acceptfilter acceptmutex acceptpathinfo accessconfig accessfilename action addalt addaltbyencoding "
"addaltbytype addcharset adddefaultcharset adddescription addencoding addhandler addicon addiconbyencoding "
@ -125,7 +117,6 @@ KEYWORDLIST KeyWords_CONF = {
EDITLEXER lexCONF = {
SCLEX_CONF, IDS_LEX_APC_CFG, L"Apache Config Files", L"conf; htaccess", L"",
&LexFunction, // static
&KeyWords_CONF, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_CONF_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexCPP.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_CPP = {
// Primary keywords
"alignas auto bool break case catch char char16_t char32_t class const constexpr const_cast "
@ -49,7 +41,6 @@ KEYWORDLIST KeyWords_CPP = {
EDITLEXER lexCPP = {
SCLEX_CPP, IDS_LEX_CPP_SRC, L"C/C++ Source Code", L"c; cpp; cxx; cc; h; hpp; hxx; hh; m; mm; idl; inl; odl", L"",
&LexFunction, // static
&KeyWords_CPP, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_C_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexCS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_CS = {
"abstract add alias as ascending async await base bool break by byte case catch char checked "
"class const continue decimal default delegate descending do double dynamic else "
@ -147,7 +139,6 @@ KEYWORDLIST KeyWords_CS = {
EDITLEXER lexCS = {
SCLEX_CPP, IDS_LEX_CSHARP_SRC, L"C# Source Code", L"cs", L"",
&LexFunction, // static
&KeyWords_CS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_C_DEFAULT}, IDS_LEX_STR_63126, L"C Default", L"", L"" },

9
src/StyleLexers/styleLexCSS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_CSS = {
"align-content align-items align-self alignment-adjust alignment-baseline animation animation-delay "
"animation-direction animation-duration animation-fill-mode animation-iteration-count animation-name "
@ -74,7 +66,6 @@ KEYWORDLIST KeyWords_CSS = {
EDITLEXER lexCSS = {
SCLEX_CSS, IDS_LEX_CSS_STYLE, L"CSS Style Sheets", L"css; less; sass; scss", L"",
&LexFunction, // static
&KeyWords_CSS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_CSS_DEFAULT}, IDS_LEX_STR_63126, L"CSS Default", L"", L"" },

11
src/StyleLexers/styleLexD.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_D = {
// Primary keywords and identifiers
"abstract alias align asm assert auto body break case cast catch class const continue "
@ -40,12 +32,11 @@ KEYWORDLIST KeyWords_D = {
EDITLEXER lexD = {
SCLEX_D, IDS_LEX_D_SRC, L"D Source Code", L"d; dd; di", L"",
&LexFunction, // static
&KeyWords_D, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_D_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {MULTI_STYLE(SCE_D_COMMENT,SCE_D_COMMENTLINE,SCE_D_COMMENTNESTED,0)}, IDS_LEX_STR_63127, L"Comment", L"fore:#008000", L"" },
{ {SCE_D_COMMENTDOC}, IDS_LEX_STR_63259, L"Comment Doc", L"fore:#040A0", L"" },
{ {SCE_D_COMMENTDOC}, IDS_LEX_STR_63259, L"Comment Doc", L"fore:#0040A0", L"" },
{ {SCE_D_NUMBER}, IDS_LEX_STR_63130, L"Number", L"fore:#FF0000", L"" },
{ {SCE_D_WORD}, IDS_LEX_STR_63128, L"Keyword", L"bold; fore:#0A246A", L"" },
{ {SCE_D_WORD}, IDS_LEX_STR_63260, L"Keyword 2nd", L"bold; fore:#0A246A", L"" },

9
src/StyleLexers/styleLexDIFF.c
View File

@ -2,20 +2,11 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_DIFF = EMPTY_KEYWORDLIST;
EDITLEXER lexDIFF = {
SCLEX_DIFF, IDS_LEX_DIFF, L"Diff Files", L"diff; patch", L"",
&LexFunction, // static
&KeyWords_DIFF, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_DIFF_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexGo.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_Go = {
// Primary keywords and identifiers
"break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type "
@ -33,7 +25,6 @@ KEYWORDLIST KeyWords_Go = {
EDITLEXER lexGo = {
SCLEX_D, IDS_LEX_GO_SRC, L"Go Source Code", L"go", L"",
&LexFunction, // static
&KeyWords_Go,{
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_D_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexHTML.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_HTML = {
"!doctype ^aria- ^data- a abbr accept accept-charset accesskey acronym action address align alink "
"alt and applet archive area article aside async audio autocomplete autofocus autoplay axis b "
@ -69,7 +61,6 @@ KEYWORDLIST KeyWords_HTML = {
EDITLEXER lexHTML = {
SCLEX_HTML, IDS_LEX_WEB_SRC, L"Web Source Code", L"html; htm; asp; aspx; shtml; htd; xhtml; php; php3; phtml; htt; cfm; tpl; dtd; hta; htc", L"",
&LexFunction, // static
&KeyWords_HTML, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {MULTI_STYLE(SCE_H_TAG,SCE_H_TAGEND,0,0)}, IDS_LEX_STR_63136, L"HTML Tag", L"fore:#648000", L"" },

11
src/StyleLexers/styleLexINNO.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_INNO = {
"code components custommessages dirs files icons ini installdelete langoptions languages messages "
"registry run setup types tasks uninstalldelete uninstallrun _istool",
@ -49,14 +41,13 @@ KEYWORDLIST KeyWords_INNO = {
EDITLEXER lexINNO = {
SCLEX_INNOSETUP, IDS_LEX_INNO, L"Inno Setup Script", L"iss; isl; islu", L"",
&LexFunction, // static
&KeyWords_INNO, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_INNO_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {SCE_INNO_COMMENT}, IDS_LEX_STR_63127, L"Comment", L"fore:#008000", L"" },
{ {SCE_INNO_KEYWORD}, IDS_LEX_STR_63128, L"Keyword", L"fore:#0000FF", L"" },
{ {SCE_INNO_PARAMETER}, IDS_LEX_STR_63281, L"Parameter", L"fore:#0000FF", L"" },
{ {SCE_INNO_SECTION}, IDS_LEX_STR_63232, L"Section", L"fore:#000080; bold", L"" },
{ {SCE_INNO_SECTION}, IDS_LEX_STR_63232, L"Section", L"bold; fore:#000080", L"" },
{ {SCE_INNO_PREPROC}, IDS_LEX_STR_63133, L"Preprocessor", L"fore:#CC0000", L"" },
{ {SCE_INNO_INLINE_EXPANSION}, IDS_LEX_STR_63282, L"Inline Expansion", L"fore:#800080", L"" },
{ {SCE_INNO_COMMENT_PASCAL}, IDS_LEX_STR_63283, L"Pascal Comment", L"fore:#008000", L"" },

9
src/StyleLexers/styleLexJAVA.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_JAVA = {
"@interface abstract assert boolean break byte case catch char class const "
"continue default do double else enum extends final finally float for future "
@ -26,7 +18,6 @@ KEYWORDLIST KeyWords_JAVA = {
EDITLEXER lexJAVA = {
SCLEX_CPP, IDS_LEX_JAVA_SRC, L"Java Source Code", L"java", L"",
&LexFunction, // static
&KeyWords_JAVA, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_C_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexJS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_JS = {
"abstract boolean break byte case catch char class const continue debugger default delete do "
"double else enum export extends false final finally float for function goto if implements "
@ -21,7 +13,6 @@ KEYWORDLIST KeyWords_JS = {
EDITLEXER lexJS = {
SCLEX_CPP, IDS_LEX_J_SCR, L"JavaScript", L"js; jse; jsm; as", L"",
&LexFunction, // static
&KeyWords_JS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_C_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexJSON.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_JSON = {
"false true null",
"@id @context @type @value @language @container @list @set @reverse @index @base @vocab @graph",
@ -18,7 +10,6 @@ KEYWORDLIST KeyWords_JSON = {
EDITLEXER lexJSON = {
SCLEX_JSON, IDS_LEX_JSON, L"JSON", L"json; eslintrc; jshintrc; jsonld", L"",
&LexFunction, // static
&KeyWords_JSON, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_C_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexLUA.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_LUA = {
"and break do else elseif end false for function goto if "
"in local nil not or repeat return then true until while",
@ -41,7 +33,6 @@ KEYWORDLIST KeyWords_LUA = {
EDITLEXER lexLUA = {
SCLEX_LUA, IDS_LEX_LUA, L"Lua Script", L"lua", L"",
&LexFunction, // static
&KeyWords_LUA, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_LUA_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexMAK.c
View File

@ -2,20 +2,11 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_MAK = EMPTY_KEYWORDLIST;
EDITLEXER lexMAK = {
SCLEX_MAKEFILE, IDS_LEX_MAKEFILES, L"Makefiles", L"mak; make; mk; dsp; msc; msvc", L"",
&LexFunction, // static
&KeyWords_MAK, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_MAKE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

25
src/StyleLexers/styleLexMARKDOWN.c
View File

@ -2,35 +2,26 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_MARKDOWN = EMPTY_KEYWORDLIST;
EDITLEXER lexMARKDOWN = {
SCLEX_MARKDOWN, IDS_LEX_MARKDOWN, L"Markdown", L"md; markdown; mdown; mkdn; mkd", L"",
&LexFunction, // static
&KeyWords_MARKDOWN, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_MARKDOWN_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {SCE_MARKDOWN_LINE_BEGIN}, IDS_LEX_STR_63317, L"Line Begin", L"", L"" },
{ {MULTI_STYLE(SCE_MARKDOWN_STRONG1,SCE_MARKDOWN_STRONG2,0,0)}, IDS_LEX_STR_63318, L"Strong", L"bold", L"" },
{ {MULTI_STYLE(SCE_MARKDOWN_EM1,SCE_MARKDOWN_EM2,0,0)}, IDS_LEX_STR_63319, L"Emphasis", L"italic", L"" },
{ {SCE_MARKDOWN_HEADER1}, IDS_LEX_STR_63320, L"Header 1", L"fore:#FF0088; bold", L"" },
{ {SCE_MARKDOWN_HEADER2}, IDS_LEX_STR_63321, L"Header 2", L"fore:#FF0088; bold", L"" },
{ {SCE_MARKDOWN_HEADER3}, IDS_LEX_STR_63322, L"Header 3", L"fore:#FF0088; bold", L"" },
{ {SCE_MARKDOWN_HEADER4}, IDS_LEX_STR_63323, L"Header 4", L"fore:#FF0088; bold", L"" },
{ {SCE_MARKDOWN_HEADER5}, IDS_LEX_STR_63324, L"Header 5", L"fore:#FF0088; bold", L"" },
{ {SCE_MARKDOWN_HEADER6}, IDS_LEX_STR_63325, L"Header 6", L"fore:#FF0088; bold", L"" },
{ {SCE_MARKDOWN_HEADER1}, IDS_LEX_STR_63320, L"Header 1", L"bold; fore:#FF0088", L"" },
{ {SCE_MARKDOWN_HEADER2}, IDS_LEX_STR_63321, L"Header 2", L"bold; fore:#FF0088", L"" },
{ {SCE_MARKDOWN_HEADER3}, IDS_LEX_STR_63322, L"Header 3", L"bold; fore:#FF0088", L"" },
{ {SCE_MARKDOWN_HEADER4}, IDS_LEX_STR_63323, L"Header 4", L"bold; fore:#FF0088", L"" },
{ {SCE_MARKDOWN_HEADER5}, IDS_LEX_STR_63324, L"Header 5", L"bold; fore:#FF0088", L"" },
{ {SCE_MARKDOWN_HEADER6}, IDS_LEX_STR_63325, L"Header 6", L"bold; fore:#FF0088", L"" },
{ {SCE_MARKDOWN_PRECHAR}, IDS_LEX_STR_63326, L"Pre Char", L"fore:#00007F", L"" },
{ {SCE_MARKDOWN_ULIST_ITEM}, IDS_LEX_STR_63327, L"Unordered List", L"fore:#0080FF; bold", L"" },
{ {SCE_MARKDOWN_OLIST_ITEM}, IDS_LEX_STR_63268, L"Ordered List", L"fore:#0080FF; bold", L"" },
{ {SCE_MARKDOWN_ULIST_ITEM}, IDS_LEX_STR_63327, L"Unordered List", L"bold; fore:#0080FF", L"" },
{ {SCE_MARKDOWN_OLIST_ITEM}, IDS_LEX_STR_63268, L"Ordered List", L"bold; fore:#0080FF", L"" },
{ {SCE_MARKDOWN_BLOCKQUOTE}, IDS_LEX_STR_63328, L"Block Quote", L"fore:#00007F", L"" },
{ {SCE_MARKDOWN_STRIKEOUT}, IDS_LEX_STR_63329, L"Strikeout", L"", L"" },
{ {SCE_MARKDOWN_HRULE}, IDS_LEX_STR_63330, L"Horizontal Rule", L"bold", L"" },

10
src/StyleLexers/styleLexMATLAB.c
View File

@ -2,13 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_MATLAB = {
"break case catch continue else elseif end for function global if otherwise "
"persistent return switch try while ",
@ -17,14 +10,13 @@ KEYWORDLIST KeyWords_MATLAB = {
EDITLEXER lexMATLAB = {
SCLEX_MATLAB, IDS_LEX_MATLAB, L"MATLAB", L"matlab", L"",
&LexFunction, // static
&KeyWords_MATLAB, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_MATLAB_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {SCE_MATLAB_COMMENT}, IDS_LEX_STR_63127, L"Comment", L"fore:#008000", L"" },
{ {SCE_MATLAB_COMMAND}, IDS_LEX_STR_63236, L"Command", L"bold", L"" },
{ {SCE_MATLAB_NUMBER}, IDS_LEX_STR_63130, L"Number", L"fore:#FF8000", L"" },
{ {SCE_MATLAB_KEYWORD}, IDS_LEX_STR_63128, L"Keyword", L"fore:#00007F; bold", L"" },
{ {SCE_MATLAB_KEYWORD}, IDS_LEX_STR_63128, L"Keyword", L"bold; fore:#00007F", L"" },
{ {MULTI_STYLE(SCE_MATLAB_STRING,SCE_MATLAB_DOUBLEQUOTESTRING,0,0)}, IDS_LEX_STR_63131, L"String", L"fore:#7F007F", L"" },
{ {SCE_MATLAB_OPERATOR}, IDS_LEX_STR_63132, L"Operator", L"", L"" },
{ {SCE_MATLAB_IDENTIFIER}, IDS_LEX_STR_63129, L"Identifier", L"", L"" },

9
src/StyleLexers/styleLexNSIS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_NSIS = {
"!addincludedir !addplugindir !appendfile !cd !define !delfile !echo !else !endif !error "
"!execute !finalize !getdllversion !if !ifdef !ifmacrodef !ifmacrondef !ifndef !include !insertmacro !macro "
@ -66,7 +58,6 @@ KEYWORDLIST KeyWords_NSIS = {
EDITLEXER lexNSIS = {
SCLEX_NSIS, IDS_LEX_NSIS, L"NSIS Script", L"nsi; nsh", L"",
&LexFunction, // static
&KeyWords_NSIS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//,{ {SCE_NSIS_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

13
src/StyleLexers/styleLexNim.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
// https://github.com/nim-lang/Nim/blob/devel/doc/keywords.txt
KEYWORDLIST KeyWords_Nim = {
@ -24,11 +16,10 @@ KEYWORDLIST KeyWords_Nim = {
EDITLEXER lexNim = {
SCLEX_NIM, IDS_LEX_NIM_SRC, L"Nim Source Code", L"nim; nimrod", L"",
&LexFunction, // static
&KeyWords_Nim,{
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_NIM_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {MULTI_STYLE(SCE_NIM_COMMENT,SCE_NIM_COMMENTDOC,SCE_NIM_COMMENTLINE,SCE_NIM_COMMENTLINEDOC)}, IDS_LEX_STR_63127, L"Comment", L"fore:#484A86; italics", L"" },
{ {MULTI_STYLE(SCE_NIM_COMMENT,SCE_NIM_COMMENTDOC,SCE_NIM_COMMENTLINE,SCE_NIM_COMMENTLINEDOC)}, IDS_LEX_STR_63127, L"Comment", L"italic; fore:#484A86", L"" },
{ {SCE_NIM_WORD}, IDS_LEX_STR_63128, L"Keyword", L"bold; fore:#5E8F60", L"" },
{ {SCE_NIM_IDENTIFIER}, IDS_LEX_STR_63129, L"Identifier", L"", L"" },
{ {MULTI_STYLE(SCE_NIM_STRING,SCE_NIM_STRINGEOL,0,0)}, IDS_LEX_STR_63211, L"String Double Quoted", L"fore:#A4255B", L"" },
@ -38,6 +29,6 @@ SCLEX_NIM, IDS_LEX_NIM_SRC, L"Nim Source Code", L"nim; nimrod", L"",
{ {SCE_NIM_NUMBER}, IDS_LEX_STR_63130, L"Number", L"fore:#252DBE", L"" },
{ {SCE_NIM_OPERATOR}, IDS_LEX_STR_63132, L"Operator", L"bold; fore:#4B4B4B", L"" },
{ {SCE_NIM_FUNCNAME}, IDS_LEX_STR_63247, L"Function name", L"fore:#4B4B4B", L"" },
{ {SCE_NIM_NUMERROR}, IDS_LEX_STR_63252, L"Parsing Error", L"fore:#FFFF00; back:#A00000; italics", L"" },
{ {SCE_NIM_NUMERROR}, IDS_LEX_STR_63252, L"Parsing Error", L"italic; fore:#FFFF00; back:#A00000", L"" },
//{ {SCE_NIM_BACKTICKS}, IDS_LEX_STR_63246, L"Class name", L"fore:#660066", L"" },
EDITLEXER_SENTINEL } };

9
src/StyleLexers/styleLexPAS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_PAS = {
"absolute abstract alias and array as asm assembler begin break case cdecl class const constructor continue cppdecl default "
"destructor dispose div do downto else end end. except exit export exports external false far far16 file finalization finally for "
@ -22,7 +14,6 @@ KEYWORDLIST KeyWords_PAS = {
EDITLEXER lexPAS = {
SCLEX_PASCAL, IDS_LEX_PASCAL_SRC, L"Pascal Source Code", L"pas; dpr; dpk; dfm; inc; pp", L"",
&LexFunction, // static
&KeyWords_PAS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_PAS_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexPL.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_PL = {
"__DATA__ __END__ __FILE__ __LINE__ __PACKAGE__ abs accept alarm and atan2 AUTOLOAD BEGIN "
"bind binmode bless break caller chdir CHECK chmod chomp chop chown chr chroot close closedir "
@ -36,7 +28,6 @@ KEYWORDLIST KeyWords_PL = {
EDITLEXER lexPL = {
SCLEX_PERL, IDS_LEX_PERL_SCR, L"Perl Script", L"pl; pm; cgi; pod", L"",
&LexFunction, // static
&KeyWords_PL, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_PL_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

11
src/StyleLexers/styleLexPROPS.c
View File

@ -2,25 +2,16 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_PROPS = EMPTY_KEYWORDLIST;
EDITLEXER lexPROPS = {
SCLEX_PROPERTIES, IDS_LEX_CONF, L"Configuration Files", L"ini; inf; cfg; properties; oem; sif; url; sed; theme", L"",
&LexFunction, // static
&KeyWords_PROPS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_PROPS_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {SCE_PROPS_COMMENT}, IDS_LEX_STR_63127, L"Comment", L"fore:#008000", L"" },
{ {SCE_PROPS_SECTION}, IDS_LEX_STR_63232, L"Section", L"fore:#000000; back:#FF8040; bold; eolfilled", L"" },
{ {SCE_PROPS_SECTION}, IDS_LEX_STR_63232, L"Section", L"bold; fore:#000000; back:#FF8040; eolfilled", L"" },
{ {SCE_PROPS_ASSIGNMENT}, IDS_LEX_STR_63233, L"Assignment", L"fore:#FF0000", L"" },
{ {SCE_PROPS_DEFVAL}, IDS_LEX_STR_63234, L"Default Value", L"fore:#FF0000", L"" },
EDITLEXER_SENTINEL } };

9
src/StyleLexers/styleLexPS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_PS = {
"begin break catch continue data do dynamicparam else elseif end exit filter finally for foreach "
"from function if in local param private process return switch throw trap try until where while",
@ -68,7 +60,6 @@ KEYWORDLIST KeyWords_PS = {
EDITLEXER lexPS = {
SCLEX_POWERSHELL, IDS_LEX_PWRSHELL, L"PowerShell Script", L"ps1; psd1; psm1", L"",
&LexFunction, // static
&KeyWords_PS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_POWERSHELL_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexPY.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_PY = {
"and as assert break class continue def del elif else except "
"exec False finally for from global if import in is lambda None "
@ -19,7 +11,6 @@ KEYWORDLIST KeyWords_PY = {
EDITLEXER lexPY = {
SCLEX_PYTHON, IDS_LEX_PYTHON, L"Python Script", L"py; pyw", L"",
&LexFunction, // static
&KeyWords_PY, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_P_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

11
src/StyleLexers/styleLexR.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_R = {
// Language Keywords
"if else repeat while function for in next break "
@ -88,7 +80,6 @@ KEYWORDLIST KeyWords_R = {
EDITLEXER lexR = {
SCLEX_R, IDS_LEX_R_STAT, L"R-S-SPlus Statistics Code", L"R", L"",
&LexFunction, // static
&KeyWords_R,{
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_R_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
@ -101,5 +92,5 @@ SCLEX_R, IDS_LEX_R_STAT, L"R-S-SPlus Statistics Code", L"R", L"",
{ {SCE_R_OPERATOR}, IDS_LEX_STR_63132, L"Operator", L"bold; fore:#B000B0", L"" },
{ {SCE_R_IDENTIFIER}, IDS_LEX_STR_63129, L"Identifier", L"", L"" },
{ {SCE_R_INFIX}, IDS_LEX_STR_63269, L"Infix", L"fore:#660066", L"" },
{ {SCE_R_INFIXEOL}, IDS_LEX_STR_63270, L"Infix EOL", L"fore:#FF4000; ,back:#E0C0E0; eolfilled", L"" },
{ {SCE_R_INFIXEOL}, IDS_LEX_STR_63270, L"Infix EOL", L"fore:#FF4000; back:#E0C0E0; eolfilled", L"" },
EDITLEXER_SENTINEL } };

9
src/StyleLexers/styleLexRC.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_RC = {
"ACCELERATORS ALT AUTO3STATE AUTOCHECKBOX AUTORADIOBUTTON "
"BEGIN BITMAP BLOCK BUTTON CAPTION CHARACTERISTICS CHECKBOX "
@ -24,7 +16,6 @@ KEYWORDLIST KeyWords_RC = {
EDITLEXER lexRC = {
SCLEX_CPP, IDS_LEX_RESOURCE_SCR, L"Resource Script", L"rc; rc2; rct; rh; r; dlg", L"",
&LexFunction, // static
&KeyWords_RC, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_C_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexRUBY.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_RUBY = {
"__FILE__ __LINE__ alias and begin break case class def defined? do else elsif end ensure "
"false for in if module next nil not or redo rescue retry return self super then true "
@ -18,7 +10,6 @@ KEYWORDLIST KeyWords_RUBY = {
EDITLEXER lexRUBY = {
SCLEX_RUBY, IDS_LEX_RUBY, L"Ruby Script", L"rb; ruby; rbw; rake; rjs; Rakefile; gemspec", L"",
&LexFunction, // static
&KeyWords_RUBY, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_RB_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

11
src/StyleLexers/styleLexRegistry.c
View File

@ -2,19 +2,10 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_Registry = EMPTY_KEYWORDLIST;
EDITLEXER lexRegistry = {
SCLEX_REGISTRY, IDS_LEX_REG_FILES, L"Registry Files", L"reg", L"",
&LexFunction, // static
&KeyWords_Registry, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_REG_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
@ -23,7 +14,7 @@ SCLEX_REGISTRY, IDS_LEX_REG_FILES, L"Registry Files", L"reg", L"",
{ {MULTI_STYLE(SCE_REG_STRING,SCE_REG_STRING_GUID,0,0)}, IDS_LEX_STR_63131, L"String", L"fore:#008000", L"" },
{ {SCE_REG_VALUETYPE}, IDS_LEX_STR_63286, L"Value Type", L"bold; fore:#00007F", L"" },
{ {SCE_REG_HEXDIGIT}, IDS_LEX_STR_63287, L"Hex", L"fore:#7F0B0C", L"" },
{ {SCE_REG_ADDEDKEY}, IDS_LEX_STR_63288, L"Added Key", L"fore:#000000; back:#FF8040; bold; eolfilled", L"" }, //fore:#530155
{ {SCE_REG_ADDEDKEY}, IDS_LEX_STR_63288, L"Added Key", L"bold; fore:#000000; back:#FF8040; eolfilled", L"" }, //fore:#530155
{ {SCE_REG_DELETEDKEY}, IDS_LEX_STR_63289, L"Deleted Key", L"fore:#FF0000", L"" },
{ {SCE_REG_ESCAPED}, IDS_LEX_STR_63290, L"Escaped", L"bold; fore:#7D8187", L"" },
{ {SCE_REG_KEYPATH_GUID}, IDS_LEX_STR_63291, L"GUID in Key Path", L"fore:#7B5F15", L"" },

9
src/StyleLexers/styleLexRust.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_Rust = {
// Primary keywords and identifiers
"as be break const continue crate else enum extern false fn for "
@ -34,7 +26,6 @@ KEYWORDLIST KeyWords_Rust = {
EDITLEXER lexRust = {
SCLEX_RUST, IDS_LEX_RUST_SRC, L"Rust Source Code", L"rs; rust", L"",
&LexFunction, // static
&KeyWords_Rust,{
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_RUST_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexSQL.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_SQL = {
"abort accessible action add after all alter analyze and as asc asensitive attach autoincrement "
"before begin between bigint binary bit blob both by call cascade case cast change char character "
@ -38,7 +30,6 @@ KEYWORDLIST KeyWords_SQL = {
EDITLEXER lexSQL = {
SCLEX_SQL, IDS_LEX_SQL, L"SQL Query", L"sql", L"",
&LexFunction, // static
&KeyWords_SQL, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_SQL_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

39
src/StyleLexers/styleLexStandard.c
View File

@ -1,39 +1,11 @@
#include "StyleLexers.h"
// ----------------------------------------------------------------------------
static __int64 StdLexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
static __int64 Std2ndLexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
static __int64 AnsiLexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
static __int64 LatexLexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_NULL = EMPTY_KEYWORDLIST;
EDITLEXER lexStandard = {
SCLEX_NULL, IDS_LEX_DEF_TXT, L"Default Text", L"txt; text; wtx; log; asc; doc", L"",
&StdLexFunction, // static
&KeyWords_NULL, {
/* 0 */ { {STYLE_DEFAULT}, IDS_LEX_STD_STYLE, L"Default Style", L"font:Default", L"" },
/* 1 */ { {STYLE_LINENUMBER}, IDS_LEX_STD_MARGIN, L"Margins and Line Numbers", L"size:-2; fore:#008080", L"" },
@ -44,11 +16,11 @@ SCLEX_NULL, IDS_LEX_DEF_TXT, L"Default Text", L"txt; text; wtx; log; asc; doc",
/* 6 */ { {_STYLE_GETSTYLEID(STY_SEL_TXT)}, IDS_LEX_STD_SEL, L"Selected Text (Colors)", L"fore:#FF4000; back:#4040FF; eolfilled; alpha:80", L"" },
/* 7 */ { {_STYLE_GETSTYLEID(STY_WHITESPACE)}, IDS_LEX_STD_WSPC, L"Whitespace (Colors, Size 0-12)", L"fore:#FF4000", L"" },
/* 8 */ { {_STYLE_GETSTYLEID(STY_CUR_LN)}, IDS_LEX_STD_LN_BACKGR, L"Current Line Background (Color)", L"size:2; fore:#A0A0A0; back:#FFFF00; alpha:50", L"" },
/* 9 */ { {_STYLE_GETSTYLEID(STY_CARET)}, IDS_LEX_STD_CARET, L"Caret (Color, Size 1-3)", L"ovrbar; size:1", L"" },
/* 9 */ { {_STYLE_GETSTYLEID(STY_CARET)}, IDS_LEX_STD_CARET, L"Caret (Color, Size 1-3)", L"size:1; ovrbar", L"" },
/* 10 */ { {_STYLE_GETSTYLEID(STY_LONG_LN_MRK)}, IDS_LEX_STD_LONG_LN, L"Long Line Marker (Colors)", L"fore:#FFC000", L"" },
/* 11 */ { {_STYLE_GETSTYLEID(STY_X_LN_SPACE)}, IDS_LEX_STD_X_SPC, L"Extra Line Spacing (Size)", L"size:2", L"" },
/* 12 */ { {_STYLE_GETSTYLEID(STY_BOOK_MARK)}, IDS_LEX_STD_BKMRK, L"Bookmarks and Folding (Colors, Size)", L"size:+2; fore:#000000; back:#00DC00; alpha:100", L"" },
/* 13 */ { {_STYLE_GETSTYLEID(STY_MARK_OCC)}, IDS_LEX_STR_63262, L"Mark Occurrences (Indicator)", L"alpha:100; alpha2:100; indic_roundbox", L"" },
/* 13 */ { {_STYLE_GETSTYLEID(STY_MARK_OCC)}, IDS_LEX_STR_63262, L"Mark Occurrences (Indicator)", L"fore:#FF0000; alpha:100; alpha2:100; indic_roundbox", L"" },
/* 14 */ { {_STYLE_GETSTYLEID(STY_URL_HOTSPOT)}, IDS_LEX_STR_63264, L"Hyperlink Hotspots", L"italic; fore:#0000FF", L"" },
/* 15 */ { {_STYLE_GETSTYLEID(STY_IME_COLOR)}, IDS_LEX_STR_63352, L"Inline-IME Color", L"fore:#00AA00", L"" },
EDITLEXER_SENTINEL } };
@ -56,7 +28,6 @@ SCLEX_NULL, IDS_LEX_DEF_TXT, L"Default Text", L"txt; text; wtx; log; asc; doc",
EDITLEXER lexStandard2nd = {
SCLEX_NULL, IDS_LEX_STR_63266, L"2nd Default Text", L"txt; text; wtx; log; asc; doc", L"",
&Std2ndLexFunction, // static
&KeyWords_NULL,{
/* 0 */ { {STYLE_DEFAULT}, IDS_LEX_2ND_STYLE, L"2nd Default Style", L"font:Courier New", L"" },
/* 1 */ { {STYLE_LINENUMBER}, IDS_LEX_2ND_MARGIN, L"2nd Margins and Line Numbers", L"font:Courier New; size:-2; fore:#008080", L"" },
@ -67,11 +38,11 @@ SCLEX_NULL, IDS_LEX_STR_63266, L"2nd Default Text", L"txt; text; wtx; log; asc;
/* 6 */ { {_STYLE_GETSTYLEID(STY_SEL_TXT)}, IDS_LEX_2ND_SEL, L"2nd Selected Text (Colors)", L"fore:#FF4000; eolfilled", L"" },
/* 7 */ { {_STYLE_GETSTYLEID(STY_WHITESPACE)}, IDS_LEX_2ND_WSPC, L"2nd Whitespace (Colors, Size 0-12)", L"fore:#FF4000", L"" },
/* 8 */ { {_STYLE_GETSTYLEID(STY_CUR_LN)}, IDS_LEX_2ND_LN_BACKGR, L"2nd Current Line Background (Color)", L"size:2; fore:#0000B0; back:#FFFF00; alpha:50", L"" },
/* 9 */ { {_STYLE_GETSTYLEID(STY_CARET)}, IDS_LEX_2ND_CARET, L"2nd Caret (Color, Size 1-3)", L"ovrbar; size:1", L"" },
/* 9 */ { {_STYLE_GETSTYLEID(STY_CARET)}, IDS_LEX_2ND_CARET, L"2nd Caret (Color, Size 1-3)", L"size:1; ovrbar", L"" },
/* 10 */ { {_STYLE_GETSTYLEID(STY_LONG_LN_MRK)}, IDS_LEX_2ND_LONG_LN, L"2nd Long Line Marker (Colors)", L"fore:#FFC000", L"" },
/* 11 */ { {_STYLE_GETSTYLEID(STY_X_LN_SPACE)}, IDS_LEX_2ND_X_SPC, L"2nd Extra Line Spacing (Size)", L"", L"" },
/* 12 */ { {_STYLE_GETSTYLEID(STY_BOOK_MARK)}, IDS_LEX_2ND_BKMRK, L"2nd Bookmarks and Folding (Colors, Size)", L"size:+2; fore:#000000; back:#00DC00; alpha:100; charset:2; case:U", L"" },
/* 13 */ { {_STYLE_GETSTYLEID(STY_MARK_OCC)}, IDS_LEX_STR_63263, L"2nd Mark Occurrences (Indicator)", L"fore:#0x000000; alpha:100; alpha2:220; indic_box", L"" },
/* 13 */ { {_STYLE_GETSTYLEID(STY_MARK_OCC)}, IDS_LEX_STR_63263, L"2nd Mark Occurrences (Indicator)", L"fore:#000000; alpha:100; alpha2:220; indic_box", L"" },
/* 14 */ { {_STYLE_GETSTYLEID(STY_URL_HOTSPOT)}, IDS_LEX_STR_63265, L"2nd Hyperlink Hotspots", L"bold; fore:#FF0000", L"" },
/* 15 */ { {_STYLE_GETSTYLEID(STY_IME_COLOR)}, IDS_LEX_STR_63353, L"2nd Inline-IME Color", L"fore:#FF0000", L"" },
EDITLEXER_SENTINEL } };
@ -79,7 +50,6 @@ SCLEX_NULL, IDS_LEX_STR_63266, L"2nd Default Text", L"txt; text; wtx; log; asc;
EDITLEXER lexANSI = {
SCLEX_NULL, IDS_LEX_ANSI_ART, L"ANSI Art", L"nfo; diz", L"",
&AnsiLexFunction, // static
&KeyWords_NULL,{
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"font:Lucida Console; none; size:11", L"" },
{ {STYLE_LINENUMBER}, IDS_LEX_STD_MARGIN, L"Margins and Line Numbers", L"font:Lucida Console; size:-2", L"" },
@ -91,7 +61,6 @@ SCLEX_NULL, IDS_LEX_ANSI_ART, L"ANSI Art", L"nfo; diz", L"",
EDITLEXER lexLATEX = {
SCLEX_LATEX, IDS_LEX_LATEX, L"LaTeX Files", L"tex; latex; sty", L"",
&LatexLexFunction, // static
&KeyWords_NULL, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_L_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexTCL.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_TCL = {
// TCL Keywords
"after append array auto_execok auto_import auto_load auto_load_index auto_qualify beep "
@ -42,7 +34,6 @@ KEYWORDLIST KeyWords_TCL = {
EDITLEXER lexTCL = {
SCLEX_TCL, IDS_LEX_TCL, L"Tcl Script", L"tcl; itcl", L"",
&LexFunction, // static
&KeyWords_TCL, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_TCL_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexVB.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_VB = {
"addhandler addressof alias and andalso ansi any as assembly auto boolean byref byte byval call "
"case catch cbool cbyte cchar cdate cdbl cdec char cint class clng cobj compare const cshort csng "
@ -27,7 +19,6 @@ KEYWORDLIST KeyWords_VB = {
EDITLEXER lexVB = {
SCLEX_VB, IDS_LEX_VIS_BAS, L"Visual Basic", L"vb; bas; frm; cls; ctl; pag; dsr; dob", L"",
&LexFunction, // static
&KeyWords_VB, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_B_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexVBS.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_VBS = {
"alias and as attribute begin boolean byref byte byval call case class compare const continue "
"currency date declare dim do double each else elseif empty end enum eqv erase error event exit "
@ -22,7 +14,6 @@ KEYWORDLIST KeyWords_VBS = {
EDITLEXER lexVBS = {
SCLEX_VBSCRIPT, IDS_LEX_VB_SCR, L"VBScript", L"vbs; dsm", L"",
&LexFunction, // static
&KeyWords_VBS, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_B_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexVHDL.c
View File

@ -2,14 +2,6 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_VHDL = {
"access after alias all architecture array assert attribute begin block body buffer bus case component configuration "
"constant disconnect downto else elsif end entity exit file for function generate generic group guarded if impure in "
@ -30,7 +22,6 @@ KEYWORDLIST KeyWords_VHDL = {
EDITLEXER lexVHDL = {
SCLEX_VHDL, IDS_LEX_VHDL, L"VHDL", L"vhdl; vhd", L"",
&LexFunction, // static
&KeyWords_VHDL, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_VHDL_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },

9
src/StyleLexers/styleLexXML.c
View File

@ -2,20 +2,11 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_XML = EMPTY_KEYWORDLIST;
EDITLEXER lexXML = {
SCLEX_XML, IDS_LEX_XML_DOC, L"XML Document", L"xml; xsl; rss; svg; xul; xsd; xslt; axl; rdf; xaml; vcproj", L"",
&LexFunction, // static
&KeyWords_XML, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
{ {MULTI_STYLE(SCE_H_TAG,SCE_H_TAGUNKNOWN,SCE_H_TAGEND,0)}, IDS_LEX_STR_63187, L"XML Tag", L"fore:#881280", L"" },

13
src/StyleLexers/styleLexYAML.c
View File

@ -2,19 +2,10 @@
// ----------------------------------------------------------------------------
static __int64 LexFunction(LexFunctionType type, int value)
{
LEX_FUNCTION_BODY(type, value);
return 0LL;
};
// ----------------------------------------------------------------------------
KEYWORDLIST KeyWords_YAML = { "y n yes no on off true false", "", "", "", "", "", "", "", "" };
EDITLEXER lexYAML = {
SCLEX_YAML, IDS_LEX_YAML, L"YAML", L"yaml; yml", L"",
&LexFunction, // static
&KeyWords_YAML, {
{ {STYLE_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
//{ {SCE_YAML_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
@ -23,8 +14,8 @@ SCLEX_YAML, IDS_LEX_YAML, L"YAML", L"yaml; yml", L"",
{ {SCE_YAML_KEYWORD}, IDS_LEX_STR_63128, L"Keyword", L"fore:#880088", L"" },
{ {SCE_YAML_NUMBER}, IDS_LEX_STR_63130, L"Number", L"fore:#FF8000", L"" },
{ {SCE_YAML_REFERENCE}, IDS_LEX_STR_63333, L"Reference", L"fore:#008888", L"" },
{ {SCE_YAML_DOCUMENT}, IDS_LEX_STR_63334, L"Document", L"fore:#FFFFFF; bold; back:#000088; eolfilled", L"" },
{ {SCE_YAML_DOCUMENT}, IDS_LEX_STR_63334, L"Document", L"bold; fore:#FFFFFF; back:#000088; eolfilled", L"" },
{ {SCE_YAML_TEXT}, IDS_LEX_STR_63335, L"Text", L"fore:#404040", L"" },
{ {SCE_YAML_ERROR}, IDS_LEX_STR_63261, L"Error", L"fore:#FFFFFF; bold; italic; back:#FF0000; eolfilled", L"" },
{ {SCE_YAML_ERROR}, IDS_LEX_STR_63261, L"Error", L"bold; italic; fore:#FFFFFF; back:#FF0000; eolfilled", L"" },
{ {SCE_YAML_OPERATOR}, IDS_LEX_STR_63132, L"Operator", L"fore:#333366", L"" },
EDITLEXER_SENTINEL } };

215
src/Styles.c
View File

@ -229,7 +229,26 @@ void Style_Load()
_SetBaseFontSize(fBFS);
_SetCurrentFontSize(fBFS);
Style_ImportFromFile(Globals.IniFile, true);
// Default colors
s_colorDefault[0] = RGB(0x00, 0x00, 0x00);
s_colorDefault[1] = RGB(0x0A, 0x24, 0x6A);
s_colorDefault[2] = RGB(0x3A, 0x6E, 0xA5);
s_colorDefault[3] = RGB(0x00, 0x3C, 0xE6);
s_colorDefault[4] = RGB(0x00, 0x66, 0x33);
s_colorDefault[5] = RGB(0x60, 0x80, 0x20);
s_colorDefault[6] = RGB(0x64, 0x80, 0x00);
s_colorDefault[7] = RGB(0xA4, 0x60, 0x00);
s_colorDefault[8] = RGB(0xFF, 0xFF, 0xFF);
s_colorDefault[9] = RGB(0xFF, 0xFF, 0xE2);
s_colorDefault[10] = RGB(0xFF, 0xF1, 0xA8);
s_colorDefault[11] = RGB(0xFF, 0xC0, 0x00);
s_colorDefault[12] = RGB(0xFF, 0x40, 0x00);
s_colorDefault[13] = RGB(0xC8, 0x00, 0x00);
s_colorDefault[14] = RGB(0xB0, 0x00, 0xB0);
s_colorDefault[15] = RGB(0xB2, 0x8B, 0x40);
Style_ImportFromFile(Globals.IniFile);
// 2nd Default Style has same filename extension list as (1st) Default Style
StringCchCopyW(lexStandard2nd.szExtensions, COUNTOF(lexStandard2nd.szExtensions), lexStandard.szExtensions);
@ -263,7 +282,7 @@ bool Style_Import(HWND hwnd)
if (GetOpenFileName(&ofn))
{
result = Style_ImportFromFile(szFile, true);
result = Style_ImportFromFile(szFile);
}
return result;
}
@ -273,14 +292,9 @@ bool Style_Import(HWND hwnd)
//
// Style_ImportFromFile()
//
bool Style_ImportFromFile(const WCHAR* szFile, bool bDefaultGuard)
bool Style_ImportFromFile(const WCHAR* szFile)
{
bool bResetToDefault = false;
if (!szFile || szFile[0] == L'\0') {
bResetToDefault = true;
bDefaultGuard = false;
}
bool bResetToDefault = (!szFile || szFile[0] == L'\0') ? true : false;
bool result = false;
@ -290,23 +304,6 @@ bool Style_ImportFromFile(const WCHAR* szFile, bool bDefaultGuard)
if (pIniSection) {
// Default colors
s_colorDefault[0] = RGB(0x00, 0x00, 0x00);
s_colorDefault[1] = RGB(0x0A, 0x24, 0x6A);
s_colorDefault[2] = RGB(0x3A, 0x6E, 0xA5);
s_colorDefault[3] = RGB(0x00, 0x3C, 0xE6);
s_colorDefault[4] = RGB(0x00, 0x66, 0x33);
s_colorDefault[5] = RGB(0x60, 0x80, 0x20);
s_colorDefault[6] = RGB(0x64, 0x80, 0x00);
s_colorDefault[7] = RGB(0xA4, 0x60, 0x00);
s_colorDefault[8] = RGB(0xFF, 0xFF, 0xFF);
s_colorDefault[9] = RGB(0xFF, 0xFF, 0xE2);
s_colorDefault[10] = RGB(0xFF, 0xF1, 0xA8);
s_colorDefault[11] = RGB(0xFF, 0xC0, 0x00);
s_colorDefault[12] = RGB(0xFF, 0x40, 0x00);
s_colorDefault[13] = RGB(0xC8, 0x00, 0x00);
s_colorDefault[14] = RGB(0xB0, 0x00, 0xB0);
s_colorDefault[15] = RGB(0xB2, 0x8B, 0x40);
if (!bResetToDefault)
{
@ -355,43 +352,20 @@ bool Style_ImportFromFile(const WCHAR* szFile, bool bDefaultGuard)
// Lexer
for (int iLexer = 0; iLexer < COUNTOF(g_pLexArray); iLexer++) {
LexFunctionPtr_t const pLexFunction = g_pLexArray[iLexer]->pFctPtr;
if (!bResetToDefault) {
GetPrivateProfileSection(g_pLexArray[iLexer]->pszName, pIniSection, (int)len, szFile);
}
if (IniSectionGetString(pIniSection, L"FileNameExtensions", g_pLexArray[iLexer]->pszDefExt,
g_pLexArray[iLexer]->szExtensions, COUNTOF(g_pLexArray[iLexer]->szExtensions)) > 0)
{
if (bDefaultGuard) {
if (StringCchCompareXIW(g_pLexArray[iLexer]->szExtensions, g_pLexArray[iLexer]->pszDefExt) != 0)
{
(*pLexFunction)(FCT_SETTING_CHANGE, 1);
}
}
else {
(*pLexFunction)(FCT_SETTING_CHANGE, -1); // reset
}
}
IniSectionGetString(pIniSection, L"FileNameExtensions", g_pLexArray[iLexer]->pszDefExt,
g_pLexArray[iLexer]->szExtensions, COUNTOF(g_pLexArray[iLexer]->szExtensions));
unsigned i = 0;
while (g_pLexArray[iLexer]->Styles[i].iStyle != -1)
{
if (IniSectionGetString(pIniSection, g_pLexArray[iLexer]->Styles[i].pszName,
IniSectionGetString(pIniSection, g_pLexArray[iLexer]->Styles[i].pszName,
g_pLexArray[iLexer]->Styles[i].pszDefault,
g_pLexArray[iLexer]->Styles[i].szValue,
COUNTOF(g_pLexArray[iLexer]->Styles[i].szValue)) > 0)
{
if (bDefaultGuard) {
if (StringCchCompareXIW(g_pLexArray[iLexer]->Styles[i].szValue, g_pLexArray[iLexer]->Styles[i].pszDefault) != 0)
{
(*pLexFunction)(FCT_SETTING_CHANGE, (i + 2));
}
}
else {
(*pLexFunction)(FCT_SETTING_CHANGE, 0-(i + 2)); // reset
}
}
COUNTOF(g_pLexArray[iLexer]->Styles[i].szValue));
++i;
}
}
@ -516,17 +490,25 @@ DWORD Style_ExportToFile(const WCHAR* szFile, bool bForceAll)
}
}
WCHAR szTmpStyle[BUFSIZE_STYLE_VALUE];
for (int iLexer = 0; iLexer < COUNTOF(g_pLexArray); ++iLexer)
{
LexFunctionPtr_t const pLexFunction = g_pLexArray[iLexer]->pFctPtr;
if (bForceAll || (((*pLexFunction)(FCT_SETTING_CHANGE, 0) & (((__int64)1) << 1)) != 0LL)) {
if (bForceAll || (StringCchCompareXI(g_pLexArray[iLexer]->szExtensions, g_pLexArray[iLexer]->pszDefExt) != 0))
{
IniSectionSetString(pIniSection, L"FileNameExtensions", g_pLexArray[iLexer]->szExtensions);
}
unsigned i = 0;
while (g_pLexArray[iLexer]->Styles[i].iStyle != -1) {
if (bForceAll || (((*pLexFunction)(FCT_SETTING_CHANGE, 0) & (((__int64)1) << (i + 2))) != 0LL)) {
// normalize
WCHAR szTmpStyle[BUFSIZE_STYLE_VALUE];
while (g_pLexArray[iLexer]->Styles[i].iStyle != -1)
{
// normalize defaults
szTmpStyle[0] = L'\0'; // clear
Style_CopyStyles_IfNotDefined(g_pLexArray[iLexer]->Styles[i].pszDefault, szTmpStyle, COUNTOF(szTmpStyle), true, true);
if (bForceAll || (StringCchCompareXI(g_pLexArray[iLexer]->Styles[i].szValue, szTmpStyle) != 0))
{
// normalize value
szTmpStyle[0] = L'\0'; // clear
Style_CopyStyles_IfNotDefined(g_pLexArray[iLexer]->Styles[i].szValue, szTmpStyle, COUNTOF(szTmpStyle), true, true);
IniSectionSetString(pIniSection, g_pLexArray[iLexer]->Styles[i].pszName, szTmpStyle);
@ -1718,7 +1700,6 @@ void Style_SetDefaultFont(HWND hwnd, bool bGlobalDefault)
PEDITLEXER const pLexer = bGlobalDefault ? GetCurrentStdLexer() : s_pLexCurrent;
PEDITSTYLE const pLexerDefStyle = &(pLexer->Styles[STY_DEFAULT]);
LexFunctionPtr_t const pLexFunction = pLexer->pFctPtr;
StringCchCopyW(newStyle, COUNTOF(newStyle), pLexer->Styles[STY_DEFAULT].szValue);
@ -1730,7 +1711,6 @@ void Style_SetDefaultFont(HWND hwnd, bool bGlobalDefault)
{
// set new styles to current lexer's default text
StringCchCopyW(pLexerDefStyle->szValue, COUNTOF(pLexerDefStyle->szValue), newStyle);
(*pLexFunction)(FCT_SETTING_CHANGE, STY_DEFAULT+2);
Style_ResetCurrentLexer(hwnd);
}
}
@ -2233,13 +2213,12 @@ bool Style_GetIndicatorType(LPWSTR lpszStyle, int cchSize, int* idx)
//
// Style_CopyStyles_IfNotDefined()
//
void Style_CopyStyles_IfNotDefined(LPWSTR lpszStyleSrc, LPWSTR lpszStyleDest, int cchSizeDest, bool bCopyFont, bool bWithEffects)
void Style_CopyStyles_IfNotDefined(LPCWSTR lpszStyleSrc, LPWSTR lpszStyleDest, int cchSizeDest, bool bCopyFont, bool bWithEffects)
{
WCHAR szTmpStyle[BUFSIZE_STYLE_VALUE] = { L'\0' };
int iValue;
COLORREF dColor;
WCHAR tch[BUFSIZE_STYLE_VALUE] = { L'\0' };
WCHAR szTmpStyle[BUFSIZE_STYLE_VALUE] = { L'\0' };
// --------- Font settings ---------
if (bCopyFont)
@ -2251,6 +2230,16 @@ void Style_CopyStyles_IfNotDefined(LPWSTR lpszStyleSrc, LPWSTR lpszStyleDest, in
}
}
// cleartype
if (StrStrI(lpszStyleSrc, L"none") && !StrStrI(lpszStyleDest, L"none"))
StringCchCat(szTmpStyle, COUNTOF(szTmpStyle), L"; none");
else if (StrStrI(lpszStyleSrc, L"standard") && !StrStrI(lpszStyleDest, L"standard"))
StringCchCat(szTmpStyle, COUNTOF(szTmpStyle), L"; standard");
else if (StrStrI(lpszStyleSrc, L"cleartype") && !StrStrI(lpszStyleDest, L"cleartype"))
StringCchCat(szTmpStyle, COUNTOF(szTmpStyle), L"; cleartype");
else if (StrStrI(lpszStyleSrc, L"default") && !StrStrI(lpszStyleDest, L"default"))
StringCchCat(szTmpStyle, COUNTOF(szTmpStyle), L"; default");
// --------- Size ---------
if (!StrStrI(lpszStyleDest, L"size:")) {
if (Style_StrGetSizeStr(lpszStyleSrc, tch, COUNTOF(tch))) {
@ -2362,7 +2351,8 @@ void Style_CopyStyles_IfNotDefined(LPWSTR lpszStyleSrc, LPWSTR lpszStyleDest, in
// -------- indicator type --------
if (!StrStrI(lpszStyleDest, L"indic_")) {
iValue = -1;
if (Style_GetIndicatorType(lpszStyleSrc, 0, &iValue)) {
StringCchCopy(tch, COUNTOF(tch), lpszStyleSrc);
if (Style_GetIndicatorType(tch, 0, &iValue)) {
StringCchCat(szTmpStyle, COUNTOF(szTmpStyle), L"; ");
Style_GetIndicatorType(tch, COUNTOF(tch), &iValue);
StringCchCat(szTmpStyle, COUNTOF(szTmpStyle), tch);
@ -3124,35 +3114,33 @@ void Style_AddLexerToListView(HWND hwnd,PEDITLEXER plex)
//
// Style_CustomizeSchemesDlgProc()
//
static bool _ApplyDialogItemText(HWND hwnd,
PEDITLEXER pCurrentLexer, PEDITSTYLE pCurrentStyle, int iStyleID, bool bIsStyleSelected)
PEDITLEXER pCurrentLexer, PEDITSTYLE pCurrentStyle, int iCurStyleIdx, bool bIsStyleSelected)
{
WCHAR szBuf[max(BUFSIZE_STYLE_VALUE, BUFZIZE_STYLE_EXTENTIONS)];
UNUSED(iCurStyleIdx);
LexFunctionPtr_t const pLexFunction = pCurrentLexer->pFctPtr;
__int64 const mask = (((__int64)1) << (iStyleID + 2)) | (__int64)(!bIsStyleSelected ? 1 : 0);
bool bChgNfy = (((*pLexFunction)(FCT_SETTING_CHANGE, 0) & mask) != 0);
bool bChgNfy = false;
WCHAR szBuf[max(BUFSIZE_STYLE_VALUE, BUFZIZE_STYLE_EXTENTIONS)] = { L'\0' };
GetDlgItemText(hwnd, IDC_STYLEEDIT, szBuf, COUNTOF(szBuf));
// normalize
WCHAR szBufNorm[max(BUFSIZE_STYLE_VALUE, BUFZIZE_STYLE_EXTENTIONS)] = { L'\0' };
Style_CopyStyles_IfNotDefined(szBuf, szBufNorm, COUNTOF(szBufNorm), true, true);
if (StringCchCompareXIW(szBuf, pCurrentStyle->szValue) != 0) {
pCurrentStyle->szValue[0] = L'\0';
Style_CopyStyles_IfNotDefined(szBuf, pCurrentStyle->szValue,
COUNTOF(pCurrentStyle->szValue), true, true);
(*pLexFunction)(FCT_SETTING_CHANGE, (iStyleID + 2));
if (StringCchCompareXI(szBufNorm, pCurrentStyle->szValue) != 0) {
StringCchCopy(pCurrentStyle->szValue, COUNTOF(pCurrentStyle->szValue), szBufNorm);
bChgNfy = true;
}
if (!bIsStyleSelected)
if (!bIsStyleSelected) // must be file extensions
{
if (!GetDlgItemText(hwnd, IDC_STYLEEDIT_ROOT, szBuf, COUNTOF(szBuf)))
{
StringCchCopy(szBuf, COUNTOF(szBuf), pCurrentLexer->pszDefExt);
}
if (StringCchCompareXIW(szBuf, pCurrentLexer->szExtensions) != 0)
if (StringCchCompareXI(szBuf, pCurrentLexer->szExtensions) != 0)
{
StringCchCopyW(pCurrentLexer->szExtensions, COUNTOF(pCurrentLexer->szExtensions), szBuf);
(*pLexFunction)(FCT_SETTING_CHANGE, 1);
StringCchCopy(pCurrentLexer->szExtensions, COUNTOF(pCurrentLexer->szExtensions), szBuf);
bChgNfy = true;
}
}
@ -3164,10 +3152,6 @@ static bool _ApplyDialogItemText(HWND hwnd,
}
//=============================================================================
//
// Style_CustomizeSchemesDlgProc()
//
INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam,LPARAM lParam)
{
static HWND hwndTV;
@ -3178,18 +3162,17 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam
static HBRUSH hbrFore;
static HBRUSH hbrBack;
static bool bIsStyleSelected = false;
static WCHAR* Style_StylesBackup[NUMLEXERS * AVG_NUM_OF_STYLES_PER_LEXER];
static __int64 Style_ChangedBackup[NUMLEXERS];
static WCHAR tchTmpBuffer[max(BUFSIZE_STYLE_VALUE, BUFZIZE_STYLE_EXTENTIONS)] = { L'\0' };
switch(umsg)
{
case WM_INITDIALOG:
{
WCHAR wchText[512] = { L'\0' };
if (Globals.hDlgIcon) { SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)Globals.hDlgIcon); }
GetLngString(IDS_MUI_STYLEEDIT_HELP, wchText, COUNTOF(wchText));
SetDlgItemText(hwnd, IDC_STYLEEDIT_HELP, wchText);
GetLngString(IDS_MUI_STYLEEDIT_HELP, tchTmpBuffer, COUNTOF(tchTmpBuffer));
SetDlgItemText(hwnd, IDC_STYLEEDIT_HELP, tchTmpBuffer);
// Backup Styles
ZeroMemory(&Style_StylesBackup, NUMLEXERS * AVG_NUM_OF_STYLES_PER_LEXER * sizeof(WCHAR*));
@ -3201,8 +3184,6 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam
Style_StylesBackup[cnt++] = StrDup(g_pLexArray[iLexer]->Styles[i].szValue);
++i;
}
LexFunctionPtr_t const pLexFunction = g_pLexArray[iLexer]->pFctPtr;
Style_ChangedBackup[iLexer] = (*pLexFunction)(FCT_SETTING_CHANGE, 0);
}
hwndTV = GetDlgItem(hwnd,IDC_STYLELIST);
@ -3269,15 +3250,14 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam
else
SetDlgPos(hwnd, Settings.CustomSchemesDlgPosX, Settings.CustomSchemesDlgPosY);
WCHAR tchBuf[128] = { L'\0' };
HMENU hmenu = GetSystemMenu(hwnd, false);
GetLngString(IDS_MUI_PREVIEW, tchBuf, COUNTOF(tchBuf));
InsertMenu(hmenu, 0, MF_BYPOSITION | MF_STRING | MF_ENABLED, IDS_MUI_PREVIEW, tchBuf);
GetLngString(IDS_MUI_PREVIEW, tchTmpBuffer, COUNTOF(tchTmpBuffer));
InsertMenu(hmenu, 0, MF_BYPOSITION | MF_STRING | MF_ENABLED, IDS_MUI_PREVIEW, tchTmpBuffer);
InsertMenu(hmenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
GetLngString(IDS_MUI_SAVEPOS, tchBuf, COUNTOF(tchBuf));
InsertMenu(hmenu, 2, MF_BYPOSITION | MF_STRING | MF_ENABLED, IDS_MUI_SAVEPOS, tchBuf);
GetLngString(IDS_MUI_RESETPOS, tchBuf, COUNTOF(tchBuf));
InsertMenu(hmenu, 3, MF_BYPOSITION | MF_STRING | MF_ENABLED, IDS_MUI_RESETPOS, tchBuf);
GetLngString(IDS_MUI_SAVEPOS, tchTmpBuffer, COUNTOF(tchTmpBuffer));
InsertMenu(hmenu, 2, MF_BYPOSITION | MF_STRING | MF_ENABLED, IDS_MUI_SAVEPOS, tchTmpBuffer);
GetLngString(IDS_MUI_RESETPOS, tchTmpBuffer, COUNTOF(tchTmpBuffer));
InsertMenu(hmenu, 3, MF_BYPOSITION | MF_STRING | MF_ENABLED, IDS_MUI_RESETPOS, tchTmpBuffer);
InsertMenu(hmenu, 4, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
}
return true;
@ -3611,15 +3591,14 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam
case IDC_STYLEFONT:
if (pCurrentStyle) {
WCHAR tch[BUFSIZE_STYLE_VALUE] = { L'\0' };
WCHAR lexerName[BUFSIZE_STYLE_VALUE] = { L'\0' };
WCHAR styleName[BUFSIZE_STYLE_VALUE] = { L'\0' };
GetDlgItemText(hwnd, IDC_STYLEEDIT, tch, COUNTOF(tch));
GetDlgItemText(hwnd, IDC_STYLEEDIT, tchTmpBuffer, COUNTOF(tchTmpBuffer));
GetLngString(pCurrentLexer->resID, lexerName, COUNTOF(lexerName));
GetLngString(pCurrentStyle->rid, styleName, COUNTOF(styleName));
if (Style_SelectFont(hwnd, tch, COUNTOF(tch), lexerName, styleName,
if (Style_SelectFont(hwnd, tchTmpBuffer, COUNTOF(tchTmpBuffer), lexerName, styleName,
IsStyleStandardDefault(pCurrentStyle), IsStyleSchemeDefault(pCurrentStyle), false, true)) {
SetDlgItemText(hwnd, IDC_STYLEEDIT, tch);
SetDlgItemText(hwnd, IDC_STYLEEDIT, tchTmpBuffer);
}
}
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)(GetDlgItem(hwnd, IDC_STYLEEDIT)), 1);
@ -3632,12 +3611,7 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam
if (!bIsStyleSelected) {
SetDlgItemText(hwnd, IDC_STYLEEDIT_ROOT, pCurrentLexer->pszDefExt);
}
_ApplyDialogItemText(hwnd, pCurrentLexer, pCurrentStyle, iCurStyleIdx, bIsStyleSelected);
LexFunctionPtr_t const pLexFunction = pCurrentLexer->pFctPtr;
(*pLexFunction)(FCT_SETTING_CHANGE, -(iCurStyleIdx + 2)); // reset
if (!bIsStyleSelected) { (*pLexFunction)(FCT_SETTING_CHANGE, -1); } // reset
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)(GetDlgItem(hwnd, IDC_STYLEEDIT)), 1);
}
break;
@ -3742,27 +3716,20 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd,UINT umsg,WPARAM wParam
else {
_ApplyDialogItemText(hwnd, pCurrentLexer, pCurrentStyle, iCurStyleIdx, bIsStyleSelected);
// Restore Styles
// Restore Styles from Backup
int cnt = 0;
for (int iLexer = 0; iLexer < COUNTOF(g_pLexArray); ++iLexer) {
LexFunctionPtr_t const pLexFunction = g_pLexArray[iLexer]->pFctPtr;
for (int iLexer = 0; iLexer < COUNTOF(g_pLexArray); ++iLexer)
{
StringCchCopy(g_pLexArray[iLexer]->szExtensions, COUNTOF(g_pLexArray[iLexer]->szExtensions), Style_StylesBackup[cnt]);
if ((Style_ChangedBackup[iLexer] & (((__int64)1) << 1)) != 0LL)
(*pLexFunction)(FCT_SETTING_CHANGE, 1);
else
(*pLexFunction)(FCT_SETTING_CHANGE, -1);
++cnt;
int i = 0;
while (g_pLexArray[iLexer]->Styles[i].iStyle != -1) {
StringCchCopy(g_pLexArray[iLexer]->Styles[i].szValue, COUNTOF(g_pLexArray[iLexer]->Styles[i].szValue), Style_StylesBackup[cnt]);
if ((Style_ChangedBackup[iLexer] & (((__int64)1) << (i+2))) != 0LL)
(*pLexFunction)(FCT_SETTING_CHANGE, (i+2));
else
(*pLexFunction)(FCT_SETTING_CHANGE, -(i+2));
while (g_pLexArray[iLexer]->Styles[i].iStyle != -1)
{
// normalize
tchTmpBuffer[0] = L'\0'; // clear
Style_CopyStyles_IfNotDefined(Style_StylesBackup[cnt], tchTmpBuffer, COUNTOF(tchTmpBuffer), true, true);
StringCchCopy(g_pLexArray[iLexer]->Styles[i].szValue, COUNTOF(g_pLexArray[iLexer]->Styles[i].szValue), tchTmpBuffer);
++cnt;
++i;
}

4
src/Styles.h
View File

@ -32,7 +32,7 @@
void Style_Load();
bool Style_Import(HWND hwnd);
bool Style_ImportFromFile(const WCHAR* szFile, bool bDefaultGuard);
bool Style_ImportFromFile(const WCHAR* szFile);
void Style_Save(LPCWCH szFile);
bool Style_Export(HWND hwnd);
DWORD Style_ExportToFile(const WCHAR* szFile, bool bForceAll);
@ -71,7 +71,7 @@ bool Style_StrGetColor(LPCWSTR lpszStyle, COLOR_LAYER layer, COLORREF* rgb);
bool Style_StrGetCase(LPCWSTR lpszStyle,int* i);
bool Style_StrGetAlpha(LPCWSTR lpszStyle,int* i,bool);
bool Style_GetIndicatorType(LPWSTR lpszStyle,int cchSize,int* idx);
void Style_CopyStyles_IfNotDefined(LPWSTR lpszStyleSrc,LPWSTR lpszStyleDest,int cchSizeDest,bool,bool);
void Style_CopyStyles_IfNotDefined(LPCWSTR lpszStyleSrc,LPWSTR lpszStyleDest,int cchSizeDest,bool,bool);
bool Style_SelectFont(HWND hwnd,LPWSTR lpszStyle,int cchStyle,LPCWSTR sLexerName,LPCWSTR sStyleName,bool,bool,bool,bool);
bool Style_SelectColor(HWND hwnd,bool,LPWSTR lpszStyle,int cchStyle,bool);
void Style_SetStyles(HWND hwnd,int iStyle,LPCWSTR lpszStyle,bool);