diff --git a/src/Notepad3.c b/src/Notepad3.c
index df21f1ecd..cc4737db8 100644
--- a/src/Notepad3.c
+++ b/src/Notepad3.c
@@ -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) {
diff --git a/src/StyleLexers/EditLexer.h b/src/StyleLexers/EditLexer.h
index 7426f4aa9..ec3d0fb7a 100644
--- a/src/StyleLexers/EditLexer.h
+++ b/src/StyleLexers/EditLexer.h
@@ -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[];
 
diff --git a/src/StyleLexers/styleLexAHK.c b/src/StyleLexers/styleLexAHK.c
index b4a90171d..66cb84aa7 100644
--- a/src/StyleLexers/styleLexAHK.c
+++ b/src/StyleLexers/styleLexAHK.c
@@ -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 } };
diff --git a/src/StyleLexers/styleLexAHKL.c b/src/StyleLexers/styleLexAHKL.c
index a859024c0..a1f16d195 100644
--- a/src/StyleLexers/styleLexAHKL.c
+++ b/src/StyleLexers/styleLexAHKL.c
@@ -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 } };
diff --git a/src/StyleLexers/styleLexASM.c b/src/StyleLexers/styleLexASM.c
index 453e34601..0125f76fb 100644
--- a/src/StyleLexers/styleLexASM.c
+++ b/src/StyleLexers/styleLexASM.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexAU3.c b/src/StyleLexers/styleLexAU3.c
index 8f74e2498..3f3523ec5 100644
--- a/src/StyleLexers/styleLexAU3.c
+++ b/src/StyleLexers/styleLexAU3.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexAVS.c b/src/StyleLexers/styleLexAVS.c
index dae30e480..aed894f36 100644
--- a/src/StyleLexers/styleLexAVS.c
+++ b/src/StyleLexers/styleLexAVS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexAwk.c b/src/StyleLexers/styleLexAwk.c
index dbce2d0ab..8a2b1f826 100644
--- a/src/StyleLexers/styleLexAwk.c
+++ b/src/StyleLexers/styleLexAwk.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexBASH.c b/src/StyleLexers/styleLexBASH.c
index 8b0b7652b..229f2fd52 100644
--- a/src/StyleLexers/styleLexBASH.c
+++ b/src/StyleLexers/styleLexBASH.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexBAT.c b/src/StyleLexers/styleLexBAT.c
index 1359b9085..8cb1ec7d4 100644
--- a/src/StyleLexers/styleLexBAT.c
+++ b/src/StyleLexers/styleLexBAT.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexCMAKE.c b/src/StyleLexers/styleLexCMAKE.c
index b18e31a1d..dc703a31e 100644
--- a/src/StyleLexers/styleLexCMAKE.c
+++ b/src/StyleLexers/styleLexCMAKE.c
@@ -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 } };
diff --git a/src/StyleLexers/styleLexCOFFEESCRIPT.c b/src/StyleLexers/styleLexCOFFEESCRIPT.c
index 9dda3e05c..3a4dca5a6 100644
--- a/src/StyleLexers/styleLexCOFFEESCRIPT.c
+++ b/src/StyleLexers/styleLexCOFFEESCRIPT.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexCONF.c b/src/StyleLexers/styleLexCONF.c
index 9d311d751..96fce3f8c 100644
--- a/src/StyleLexers/styleLexCONF.c
+++ b/src/StyleLexers/styleLexCONF.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexCPP.c b/src/StyleLexers/styleLexCPP.c
index 02420b2d6..9e38deacd 100644
--- a/src/StyleLexers/styleLexCPP.c
+++ b/src/StyleLexers/styleLexCPP.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexCS.c b/src/StyleLexers/styleLexCS.c
index f4575e738..f28d32914 100644
--- a/src/StyleLexers/styleLexCS.c
+++ b/src/StyleLexers/styleLexCS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexCSS.c b/src/StyleLexers/styleLexCSS.c
index 383dcd496..71daec431 100644
--- a/src/StyleLexers/styleLexCSS.c
+++ b/src/StyleLexers/styleLexCSS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexD.c b/src/StyleLexers/styleLexD.c
index 4072bd823..dbe472a34 100644
--- a/src/StyleLexers/styleLexD.c
+++ b/src/StyleLexers/styleLexD.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexDIFF.c b/src/StyleLexers/styleLexDIFF.c
index ac5dca0b4..abf30c16a 100644
--- a/src/StyleLexers/styleLexDIFF.c
+++ b/src/StyleLexers/styleLexDIFF.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexGo.c b/src/StyleLexers/styleLexGo.c
index e4785765b..1e934d241 100644
--- a/src/StyleLexers/styleLexGo.c
+++ b/src/StyleLexers/styleLexGo.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexHTML.c b/src/StyleLexers/styleLexHTML.c
index af680e4fe..dd991449c 100644
--- a/src/StyleLexers/styleLexHTML.c
+++ b/src/StyleLexers/styleLexHTML.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexINNO.c b/src/StyleLexers/styleLexINNO.c
index f843c9f8a..ad69b6aca 100644
--- a/src/StyleLexers/styleLexINNO.c
+++ b/src/StyleLexers/styleLexINNO.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexJAVA.c b/src/StyleLexers/styleLexJAVA.c
index cc28d5b7c..f92e56222 100644
--- a/src/StyleLexers/styleLexJAVA.c
+++ b/src/StyleLexers/styleLexJAVA.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexJS.c b/src/StyleLexers/styleLexJS.c
index 516391e95..85836f4e1 100644
--- a/src/StyleLexers/styleLexJS.c
+++ b/src/StyleLexers/styleLexJS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexJSON.c b/src/StyleLexers/styleLexJSON.c
index 35fdc92aa..d8a89c485 100644
--- a/src/StyleLexers/styleLexJSON.c
+++ b/src/StyleLexers/styleLexJSON.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexLUA.c b/src/StyleLexers/styleLexLUA.c
index afafad7f1..657b27c2a 100644
--- a/src/StyleLexers/styleLexLUA.c
+++ b/src/StyleLexers/styleLexLUA.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexMAK.c b/src/StyleLexers/styleLexMAK.c
index 01c6dfb50..f41547ef9 100644
--- a/src/StyleLexers/styleLexMAK.c
+++ b/src/StyleLexers/styleLexMAK.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexMARKDOWN.c b/src/StyleLexers/styleLexMARKDOWN.c
index bcdce92fa..c136bc5a8 100644
--- a/src/StyleLexers/styleLexMARKDOWN.c
+++ b/src/StyleLexers/styleLexMARKDOWN.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexMATLAB.c b/src/StyleLexers/styleLexMATLAB.c
index 8f379aa5e..4b322bd2a 100644
--- a/src/StyleLexers/styleLexMATLAB.c
+++ b/src/StyleLexers/styleLexMATLAB.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexNSIS.c b/src/StyleLexers/styleLexNSIS.c
index 1d56e76fb..658b8ca44 100644
--- a/src/StyleLexers/styleLexNSIS.c
+++ b/src/StyleLexers/styleLexNSIS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexNim.c b/src/StyleLexers/styleLexNim.c
index 3c6a5b118..6ce68c7fd 100644
--- a/src/StyleLexers/styleLexNim.c
+++ b/src/StyleLexers/styleLexNim.c
@@ -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 } };
diff --git a/src/StyleLexers/styleLexPAS.c b/src/StyleLexers/styleLexPAS.c
index aed50913b..1ee0dab48 100644
--- a/src/StyleLexers/styleLexPAS.c
+++ b/src/StyleLexers/styleLexPAS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexPL.c b/src/StyleLexers/styleLexPL.c
index 71da00509..dcac35afc 100644
--- a/src/StyleLexers/styleLexPL.c
+++ b/src/StyleLexers/styleLexPL.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexPROPS.c b/src/StyleLexers/styleLexPROPS.c
index 35cb1737b..b56ba7802 100644
--- a/src/StyleLexers/styleLexPROPS.c
+++ b/src/StyleLexers/styleLexPROPS.c
@@ -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 } };
diff --git a/src/StyleLexers/styleLexPS.c b/src/StyleLexers/styleLexPS.c
index 2ff409e3f..273b28719 100644
--- a/src/StyleLexers/styleLexPS.c
+++ b/src/StyleLexers/styleLexPS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexPY.c b/src/StyleLexers/styleLexPY.c
index b82831554..fb7590cc1 100644
--- a/src/StyleLexers/styleLexPY.c
+++ b/src/StyleLexers/styleLexPY.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexR.c b/src/StyleLexers/styleLexR.c
index 4c927b936..a24832d4b 100644
--- a/src/StyleLexers/styleLexR.c
+++ b/src/StyleLexers/styleLexR.c
@@ -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 } };
diff --git a/src/StyleLexers/styleLexRC.c b/src/StyleLexers/styleLexRC.c
index 452d17226..19d8abacb 100644
--- a/src/StyleLexers/styleLexRC.c
+++ b/src/StyleLexers/styleLexRC.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexRUBY.c b/src/StyleLexers/styleLexRUBY.c
index 6f901160f..d31dc04f2 100644
--- a/src/StyleLexers/styleLexRUBY.c
+++ b/src/StyleLexers/styleLexRUBY.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexRegistry.c b/src/StyleLexers/styleLexRegistry.c
index f7f834613..57561b571 100644
--- a/src/StyleLexers/styleLexRegistry.c
+++ b/src/StyleLexers/styleLexRegistry.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexRust.c b/src/StyleLexers/styleLexRust.c
index 175bd0ffe..ee259d9bf 100644
--- a/src/StyleLexers/styleLexRust.c
+++ b/src/StyleLexers/styleLexRust.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexSQL.c b/src/StyleLexers/styleLexSQL.c
index 704849122..ab5a476cf 100644
--- a/src/StyleLexers/styleLexSQL.c
+++ b/src/StyleLexers/styleLexSQL.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexStandard.c b/src/StyleLexers/styleLexStandard.c
index dfdbdd5b0..87d4bf9b1 100644
--- a/src/StyleLexers/styleLexStandard.c
+++ b/src/StyleLexers/styleLexStandard.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexTCL.c b/src/StyleLexers/styleLexTCL.c
index 3618e41a8..520e41096 100644
--- a/src/StyleLexers/styleLexTCL.c
+++ b/src/StyleLexers/styleLexTCL.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexVB.c b/src/StyleLexers/styleLexVB.c
index 89ec45e07..bbc596ad0 100644
--- a/src/StyleLexers/styleLexVB.c
+++ b/src/StyleLexers/styleLexVB.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexVBS.c b/src/StyleLexers/styleLexVBS.c
index d853106d1..0a583c7e6 100644
--- a/src/StyleLexers/styleLexVBS.c
+++ b/src/StyleLexers/styleLexVBS.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexVHDL.c b/src/StyleLexers/styleLexVHDL.c
index add971b8a..62ae6967e 100644
--- a/src/StyleLexers/styleLexVHDL.c
+++ b/src/StyleLexers/styleLexVHDL.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexXML.c b/src/StyleLexers/styleLexXML.c
index f6e03fbf8..0a5d8a3d1 100644
--- a/src/StyleLexers/styleLexXML.c
+++ b/src/StyleLexers/styleLexXML.c
@@ -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"" },
diff --git a/src/StyleLexers/styleLexYAML.c b/src/StyleLexers/styleLexYAML.c
index 1e389bc88..618a32518 100644
--- a/src/StyleLexers/styleLexYAML.c
+++ b/src/StyleLexers/styleLexYAML.c
@@ -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 } };
diff --git a/src/Styles.c b/src/Styles.c
index b3f6edca7..bd77a5b92 100644
--- a/src/Styles.c
+++ b/src/Styles.c
@@ -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;
               }
diff --git a/src/Styles.h b/src/Styles.h
index 6d757af9d..5a08f69c6 100644
--- a/src/Styles.h
+++ b/src/Styles.h
@@ -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);