diff --git a/src/NotepadNext/decorators/HighlightedScrollBar.cpp b/src/NotepadNext/decorators/HighlightedScrollBar.cpp
index 779196859..625984484 100644
--- a/src/NotepadNext/decorators/HighlightedScrollBar.cpp
+++ b/src/NotepadNext/decorators/HighlightedScrollBar.cpp
@@ -32,7 +32,7 @@ const QColor CURSOR_CARET_COLOR = QColor(0, 0, 0, 100);
 HighlightedScrollBarDecorator::HighlightedScrollBarDecorator(ScintillaNext *editor)
     : EditorDecorator(editor), scrollBar(new HighlightedScrollBar(editor, Qt::Vertical, editor))
 {
-    connect(scrollBar, &QScrollBar::valueChanged, editor, &ScintillaEdit::scrollVertical);
+    connect(scrollBar, &QScrollBar::valueChanged, editor, &ScintillaEditBase::scrollVertical);
 
     editor->setVerticalScrollBar(scrollBar);
 }
diff --git a/src/lexilla/README b/src/lexilla/README
index d2a1d566d..8459f0387 100644
--- a/src/lexilla/README
+++ b/src/lexilla/README
@@ -27,12 +27,12 @@ directory conventionally called "lexilla".
 To use GCC, run lexilla/src/makefile:
 	make
 
-To use Clang, run lexilla/test/makefile:
+To use Clang, run lexilla/src/makefile:
 	make CLANG=1
 On macOS, CLANG is set automatically so this can just be
 	make
 
-To use MSVC, run lexilla/test/lexilla.mak:
+To use MSVC, run lexilla/src/lexilla.mak:
 	nmake -f lexilla.mak
 
 To build a debugging version of the library, add DEBUG=1 to the command:
diff --git a/src/lexilla/access/LexillaAccess.cxx b/src/lexilla/access/LexillaAccess.cxx
index 0d77a8bab..4c0c9f240 100644
--- a/src/lexilla/access/LexillaAccess.cxx
+++ b/src/lexilla/access/LexillaAccess.cxx
@@ -30,12 +30,12 @@
 namespace {
 
 #if defined(_WIN32)
-typedef FARPROC Function;
-typedef HMODULE Module;
+using Function = FARPROC;
+using Module = HMODULE;
 constexpr const char *pathSeparator = "\\";
 #else
-typedef void *Function;
-typedef void *Module;
+using Function = void *;
+using Module = void *;
 constexpr const char *pathSeparator = "/";
 #endif
 
@@ -164,9 +164,10 @@ bool Lexilla::Load(std::string_view sharedLibraryPaths) {
 			if (fnLexerCount && fnLexerName) {
 				const int nLexers = fnLexerCount();
 				for (int i = 0; i < nLexers; i++) {
-					char name[100] = "";
+					constexpr size_t lengthName = 200;
+					char name[lengthName]{};
 					fnLexerName(i, name, sizeof(name));
-					lexers.push_back(name);
+					lexers.emplace_back(name);
 				}
 			}
 			CreateLexerFn fnCL = FunctionPointer<CreateLexerFn>(
@@ -268,7 +269,7 @@ std::string Lexilla::NameFromID(int identifier) {
 			}
 		}
 	}
-	return std::string();
+	return {};
 }
 
 std::vector<std::string> Lexilla::LibraryProperties() {
diff --git a/src/lexilla/cppcheck.suppress b/src/lexilla/cppcheck.suppress
index 7ad8796a3..e4f56dba6 100644
--- a/src/lexilla/cppcheck.suppress
+++ b/src/lexilla/cppcheck.suppress
@@ -70,12 +70,14 @@ variableScope:lexilla/lexers/LexCmake.cxx
 knownConditionTrueFalse:lexilla/lexers/LexCmake.cxx
 constParameterReference:lexilla/lexers/LexCmake.cxx
 constParameterReference:lexilla/lexers/LexCOBOL.cxx
+constVariablePointer:lexilla/lexers/LexCOBOL.cxx
 constParameterReference:lexilla/lexers/LexCoffeeScript.cxx
 constParameterPointer:lexilla/lexers/LexCoffeeScript.cxx
 knownConditionTrueFalse:lexilla/lexers/LexCoffeeScript.cxx
 constVariableReference:lexilla/lexers/LexConf.cxx
 constParameterReference:lexilla/lexers/LexCPP.cxx
 variableScope:lexilla/lexers/LexCSS.cxx
+constVariablePointer:lexilla/lexers/LexCSS.cxx
 knownConditionTrueFalse:lexilla/lexers/LexDataflex.cxx
 constParameterReference:lexilla/lexers/LexDataflex.cxx
 variableScope:lexilla/lexers/LexDataflex.cxx
@@ -118,6 +120,7 @@ unreadVariable:lexilla/lexers/LexMatlab.cxx
 variableScope:lexilla/lexers/LexMatlab.cxx
 variableScope:lexilla/lexers/LexMetapost.cxx
 constParameterReference:lexilla/lexers/LexModula.cxx
+duplicateBreak:lexilla/lexers/LexModula.cxx
 variableScope:lexilla/lexers/LexModula.cxx
 constParameterReference:lexilla/lexers/LexMPT.cxx
 variableScope:lexilla/lexers/LexMSSQL.cxx
@@ -140,6 +143,7 @@ constVariableReference:lexilla/lexers/LexPerl.cxx
 knownConditionTrueFalse:lexilla/lexers/LexPerl.cxx
 constParameterReference:lexilla/lexers/LexPLM.cxx
 constParameterReference:lexilla/lexers/LexPO.cxx
+constVariablePointer:lexilla/lexers/LexPOV.cxx
 constParameterReference:lexilla/lexers/LexPython.cxx
 shadowVariable:lexilla/lexers/LexPowerPro.cxx
 knownConditionTrueFalse:lexilla/lexers/LexPowerPro.cxx
@@ -167,7 +171,6 @@ constParameterPointer:lexilla/lexers/LexTCMD.cxx
 invalidscanf:lexilla/lexers/LexTCMD.cxx
 constParameterReference:lexilla/lexers/LexTeX.cxx
 variableScope:lexilla/lexers/LexTeX.cxx
-constVariableReference:lexilla/lexers/LexTroff.cxx
 knownConditionTrueFalse:lexilla/lexers/LexVB.cxx
 constParameterReference:lexilla/lexers/LexVerilog.cxx
 variableScope:lexilla/lexers/LexVerilog.cxx
@@ -188,7 +191,6 @@ constVariableReference:lexilla/lexers/LexX12.cxx
 constParameterPointer:lexilla/lexers/LexX12.cxx
 uselessCallsSubstr:lexilla/lexers/LexX12.cxx
 constParameterReference:lexilla/lexers/LexYAML.cxx
-constParameterPointer:lexilla/lexers/LexYAML.cxx
 knownConditionTrueFalse:lexilla/lexers/LexYAML.cxx
 
 // These are due to Accessor::IndentAmount not declaring the callback as taking a const.
diff --git a/src/lexilla/doc/Lexilla.html b/src/lexilla/doc/Lexilla.html
index f8d4f15da..473a17267 100644
--- a/src/lexilla/doc/Lexilla.html
+++ b/src/lexilla/doc/Lexilla.html
@@ -9,7 +9,7 @@
     <meta name="keywords" content="Scintilla, SciTE, Editing Component, Text Editor" />
     <meta name="Description"
     content="www.scintilla.org is the home of the Scintilla editing component and SciTE text editor application." />
-    <meta name="Date.Modified" content="20250225" />
+    <meta name="Date.Modified" content="20250608" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <style type="text/css">
         .logo {
@@ -51,6 +51,7 @@
      <title>
        Lexilla
      </title>
+    <link rel="canonical" href="https://scintilla.org/Lexilla.html" />
   </head>
   <body bgcolor="#FFFFFF" text="#000000">
     <table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
@@ -61,8 +62,8 @@
           <font color="#FFCC99" size="4"> A library of language lexers for use with Scintilla</font>
         </td>
         <td width="40%" align="right">
-          <font color="#FFCC99" size="3">Release version 5.4.3<br />
-           Site last modified February 25 2025</font>
+          <font color="#FFCC99" size="3">Release version 5.4.5<br />
+           Site last modified June 8 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +78,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.4.5 improves Dart, Makefile, Nix, TOML, and Zig.</li>
+      <li>Version 5.4.4 fixes a problem when building for ARM64 on Windows.</li>
       <li>Version 5.4.3 improves C++, Modula 3, Pascal, Python, and Ruby.</li>
       <li>Version 5.4.2 adds Nix lexer. Improves JavaScript, PHP, Rust, TOML, and Zig.</li>
       <li>Version 5.4.1 adds Dart, troff, and Zig lexers. Improves C++, F#, HTML, and Smalltalk.</li>
-      <li>Version 5.4.0 adds a TOML lexer.</li>
-      <li>Version 5.3.3 improves HTML, JavaScript, Lua, PHP, and XML.</li>
     </ul>
     <ul id="menu">
       <li id="remote1"><a href="https://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
diff --git a/src/lexilla/doc/LexillaDoc.html b/src/lexilla/doc/LexillaDoc.html
index be1b972fe..c77999863 100644
--- a/src/lexilla/doc/LexillaDoc.html
+++ b/src/lexilla/doc/LexillaDoc.html
@@ -10,6 +10,7 @@
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
 
     <title>Lexilla Documentation</title>
+    <link rel="canonical" href="https://scintilla.org/LexillaDoc.html" />
 
     <style type="text/css">
 <!--
diff --git a/src/lexilla/doc/LexillaDownload.html b/src/lexilla/doc/LexillaDownload.html
index d8d0307e8..1af722305 100644
--- a/src/lexilla/doc/LexillaDownload.html
+++ b/src/lexilla/doc/LexillaDownload.html
@@ -26,9 +26,9 @@
     <table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
       <tr>
         <td>
-          <font size="4"> <a href="https://www.scintilla.org/lexilla543.zip">
+          <font size="4"> <a href="https://www.scintilla.org/lexilla545.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/lexilla543.tgz">
+	<a href="https://www.scintilla.org/lexilla545.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@ <h2>
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.4.3
+       Release 5.4.5
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@ <h4>
        The source code package contains all of the source code for Lexilla but no binary
 	executable code and is available in
        <ul>
-       <li><a href="https://www.scintilla.org/lexilla543.zip">zip format</a> (1.4M) commonly used on Windows</li>
-       <li><a href="https://www.scintilla.org/lexilla543.tgz">tgz format</a> (1.0M) commonly used on Linux and compatible operating systems</li>
+       <li><a href="https://www.scintilla.org/lexilla545.zip">zip format</a> (1.4M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/lexilla545.tgz">tgz format</a> (1.0M) commonly used on Linux and compatible operating systems</li>
        </ul>
        Instructions for building on both Windows and Linux are included in the readme file.
     <h4>
diff --git a/src/lexilla/doc/LexillaHistory.html b/src/lexilla/doc/LexillaHistory.html
index be5b34adf..f9531be01 100644
--- a/src/lexilla/doc/LexillaHistory.html
+++ b/src/lexilla/doc/LexillaHistory.html
@@ -590,9 +590,50 @@ <h2>Contributors</h2>
 	<td>Henrik S. Johansen</td>
 	<td>Ekopalypse</td>
 	<td>HoTschir</td>
+	<td>Ahmet Sait</td>
     </tr>
     </table>
     <h2 id="Releases">Releases</h2>
+    <h3>
+       <a href="https://www.scintilla.org/lexilla545.zip">Release 5.4.5</a>
+    </h3>
+    <ul>
+	<li>
+	Released 8 June 2025.
+	</li>
+	<li>
+	Dart: Add error state SCE_DART_STRINGEOL for unterminated string.
+	<a href="https://github.com/ScintillaOrg/lexilla/pull/315">Pull request #315</a>.
+	</li>
+	<li>
+	Makefile: Add a keyword list to makefile lexer to highlight GNU Make directives like 'ifdef' and 'vpath' as
+	SCE_MAKE_PREPROCESSOR since these are similar to NMAKE directives like '!IFDEF'.
+	</li>
+	<li>
+	Nix: Add error state SCE_NIX_STRINGEOL for unterminated string.
+	<a href="https://github.com/ScintillaOrg/lexilla/pull/315">Pull request #315</a>.
+	</li>
+	<li>
+	TOML: Add error state SCE_TOML_STRINGEOL for unterminated string.
+	<a href="https://github.com/ScintillaOrg/lexilla/pull/315">Pull request #315</a>.
+	</li>
+	<li>
+	Zig: Add error state SCE_ZIG_STRINGEOL for unterminated string.
+	<a href="https://github.com/ScintillaOrg/lexilla/pull/315">Pull request #315</a>.
+	</li>
+    </ul>
+    <h3>
+       <a href="https://www.scintilla.org/lexilla544.zip">Release 5.4.4</a>
+    </h3>
+    <ul>
+	<li>
+	Released 2 April 2025.
+	</li>
+	<li>
+	Fix building for ARM64.
+	<a href="https://github.com/ScintillaOrg/lexilla/pull/308">Pull request #308</a>.
+	</li>
+    </ul>
     <h3>
        <a href="https://www.scintilla.org/lexilla543.zip">Release 5.4.3</a>
     </h3>
diff --git a/src/lexilla/include/LexicalStyles.iface b/src/lexilla/include/LexicalStyles.iface
index 025850ed4..8164d8204 100644
--- a/src/lexilla/include/LexicalStyles.iface
+++ b/src/lexilla/include/LexicalStyles.iface
@@ -2349,6 +2349,7 @@ val SCE_TOML_TRIPLE_STRING_SQ=11
 val SCE_TOML_TRIPLE_STRING_DQ=12
 val SCE_TOML_ESCAPECHAR=13
 val SCE_TOML_DATETIME=14
+val SCE_TOML_STRINGEOL=15
 # Lexical states for SCLEX_TROFF
 lex troff=SCLEX_TROFF SCE_TROFF_
 val SCE_TROFF_DEFAULT=0
@@ -2408,6 +2409,7 @@ val SCE_DART_KW_PRIMARY=23
 val SCE_DART_KW_SECONDARY=24
 val SCE_DART_KW_TERTIARY=25
 val SCE_DART_KW_TYPE=26
+val SCE_DART_STRINGEOL=27
 # Lexical states for SCLEX_ZIG
 lex Zig=SCLEX_ZIG SCE_ZIG_
 val SCE_ZIG_DEFAULT=0
@@ -2428,6 +2430,7 @@ val SCE_ZIG_KW_SECONDARY=14
 val SCE_ZIG_KW_TERTIARY=15
 val SCE_ZIG_KW_TYPE=16
 val SCE_ZIG_IDENTIFIER_STRING=17
+val SCE_ZIG_STRINGEOL=18
 # Lexical states for SCLEX_NIX
 lex Nix=SCLEX_NIX SCE_NIX_
 val SCE_NIX_DEFAULT=0
@@ -2446,3 +2449,4 @@ val SCE_NIX_KEYWORD1=12
 val SCE_NIX_KEYWORD2=13
 val SCE_NIX_KEYWORD3=14
 val SCE_NIX_KEYWORD4=15
+val SCE_NIX_STRINGEOL=16
diff --git a/src/lexilla/include/SciLexer.h b/src/lexilla/include/SciLexer.h
index c4e16c089..7bdf69006 100644
--- a/src/lexilla/include/SciLexer.h
+++ b/src/lexilla/include/SciLexer.h
@@ -2095,6 +2095,7 @@
 #define SCE_TOML_TRIPLE_STRING_DQ 12
 #define SCE_TOML_ESCAPECHAR 13
 #define SCE_TOML_DATETIME 14
+#define SCE_TOML_STRINGEOL 15
 #define SCE_TROFF_DEFAULT 0
 #define SCE_TROFF_REQUEST 1
 #define SCE_TROFF_COMMAND 2
@@ -2150,6 +2151,7 @@
 #define SCE_DART_KW_SECONDARY 24
 #define SCE_DART_KW_TERTIARY 25
 #define SCE_DART_KW_TYPE 26
+#define SCE_DART_STRINGEOL 27
 #define SCE_ZIG_DEFAULT 0
 #define SCE_ZIG_COMMENTLINE 1
 #define SCE_ZIG_COMMENTLINEDOC 2
@@ -2168,6 +2170,7 @@
 #define SCE_ZIG_KW_TERTIARY 15
 #define SCE_ZIG_KW_TYPE 16
 #define SCE_ZIG_IDENTIFIER_STRING 17
+#define SCE_ZIG_STRINGEOL 18
 #define SCE_NIX_DEFAULT 0
 #define SCE_NIX_COMMENTLINE 1
 #define SCE_NIX_COMMENTBLOCK 2
@@ -2184,6 +2187,7 @@
 #define SCE_NIX_KEYWORD2 13
 #define SCE_NIX_KEYWORD3 14
 #define SCE_NIX_KEYWORD4 15
+#define SCE_NIX_STRINGEOL 16
 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */
 
 #endif
diff --git a/src/lexilla/lexers/LexAsm.cxx b/src/lexilla/lexers/LexAsm.cxx
index 40bf7b46f..be4b016f6 100644
--- a/src/lexilla/lexers/LexAsm.cxx
+++ b/src/lexilla/lexers/LexAsm.cxx
@@ -12,7 +12,6 @@
 #include <cstdlib>
 #include <cassert>
 #include <cstring>
-#include <cctype>
 #include <cstdio>
 #include <cstdarg>
 
@@ -40,26 +39,19 @@ using namespace Lexilla;
 namespace {
 
 bool IsAWordChar(const int ch) noexcept {
-	return (ch < 0x80) && (isalnum(ch) || ch == '.' ||
-		ch == '_' || ch == '?');
+	return IsAlphaNumeric(ch) || ch == '.' || ch == '_' || ch == '?';
 }
 
 bool IsAWordStart(const int ch) noexcept {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' ||
-		ch == '%' || ch == '@' || ch == '$' || ch == '?');
+	return IsAlphaNumeric(ch) || ch == '_' || ch == '.' ||
+		ch == '%' || ch == '@' || ch == '$' || ch == '?';
 }
 
 bool IsAsmOperator(const int ch) noexcept {
-	if ((ch < 0x80) && (isalnum(ch)))
+	if (IsAlphaNumeric(ch))
 		return false;
 	// '.' left out as it is used to make up numbers
-	if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
-		ch == '(' || ch == ')' || ch == '=' || ch == '^' ||
-		ch == '[' || ch == ']' || ch == '<' || ch == '&' ||
-		ch == '>' || ch == ',' || ch == '|' || ch == '~' ||
-		ch == '%' || ch == ':')
-		return true;
-	return false;
+	return AnyOf(ch, '*', '/', '-', '+', '(', ')', '=', '^', '[', ']', '<', '&', '>', ',', '|', '~', '%', ':');
 }
 
 constexpr bool IsStreamCommentStyle(int style) noexcept {
@@ -71,26 +63,17 @@ constexpr bool IsStreamCommentStyle(int style) noexcept {
 // Options used for LexerAsm
 struct OptionsAsm {
 	std::string delimiter;
-	bool fold;
-	bool foldSyntaxBased;
-	bool foldCommentMultiline;
-	bool foldCommentExplicit;
+	bool fold = false;
+	bool foldSyntaxBased = true;
+	bool foldCommentMultiline = false;
+	bool foldCommentExplicit = false;
 	std::string foldExplicitStart;
 	std::string foldExplicitEnd;
-	bool foldExplicitAnywhere;
-	bool foldCompact;
+	bool foldExplicitAnywhere = false;
+	bool foldCompact = true;
 	std::string commentChar;
-	OptionsAsm() {
-		delimiter = "";
-		fold = false;
-		foldSyntaxBased = true;
-		foldCommentMultiline = false;
-		foldCommentExplicit = false;
-		foldExplicitStart = "";
-		foldExplicitEnd   = "";
-		foldExplicitAnywhere = false;
-		foldCompact = true;
-		commentChar = "";
+	[[nodiscard]] char Delimiter() const noexcept {
+		return delimiter.empty() ? '~' : delimiter[0];
 	}
 };
 
@@ -153,12 +136,11 @@ class LexerAsm : public DefaultLexer {
 	WordList directives4foldend;
 	OptionsAsm options;
 	OptionSetAsm osAsm;
-	int commentChar;
+	char commentChar;
 public:
-	LexerAsm(const char *languageName_, int language_, int commentChar_) : DefaultLexer(languageName_, language_) {
-		commentChar = commentChar_;
-	}
-	virtual ~LexerAsm() {
+	LexerAsm(const char *languageName_, int language_, char commentChar_) :
+		DefaultLexer(languageName_, language_),
+		commentChar(commentChar_) {
 	}
 	void SCI_METHOD Release() override {
 		delete this;
@@ -166,27 +148,27 @@ class LexerAsm : public DefaultLexer {
 	int SCI_METHOD Version() const override {
 		return lvRelease5;
 	}
-	const char * SCI_METHOD PropertyNames() override {
+	const char *SCI_METHOD PropertyNames() override {
 		return osAsm.PropertyNames();
 	}
 	int SCI_METHOD PropertyType(const char *name) override {
 		return osAsm.PropertyType(name);
 	}
-	const char * SCI_METHOD DescribeProperty(const char *name) override {
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
 		return osAsm.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
-	const char * SCI_METHOD PropertyGet(const char *key) override {
+	const char *SCI_METHOD PropertyGet(const char *key) override {
 		return osAsm.PropertyGet(key);
 	}
-	const char * SCI_METHOD DescribeWordListSets() override {
+	const char *SCI_METHOD DescribeWordListSets() override {
 		return osAsm.DescribeWordListSets();
 	}
 	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
 	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
 	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
 
-	void * SCI_METHOD PrivateCall(int, void *) override {
+	void *SCI_METHOD PrivateCall(int, void *) override {
 		return nullptr;
 	}
 
@@ -233,6 +215,8 @@ Sci_Position SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) {
 	case 7:
 		wordListN = &directives4foldend;
 		break;
+	default:
+		break;
 	}
 	Sci_Position firstModification = -1;
 	if (wordListN) {
@@ -255,8 +239,7 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i
 
 	StyleContext sc(startPos, length, initStyle, styler);
 
-	for (; sc.More(); sc.Forward())
-	{
+	for (; sc.More(); sc.Forward()) {
 
 		if (sc.atLineStart) {
 			switch (sc.state) {
@@ -285,16 +268,21 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i
 		}
 
 		// Determine if the current state should terminate.
-		if (sc.state == SCE_ASM_OPERATOR) {
+		switch (sc.state) {
+		case SCE_ASM_OPERATOR:
 			if (!IsAsmOperator(sc.ch)) {
-			    sc.SetState(SCE_ASM_DEFAULT);
+				sc.SetState(SCE_ASM_DEFAULT);
 			}
-		} else if (sc.state == SCE_ASM_NUMBER) {
+			break;
+
+		case SCE_ASM_NUMBER:
 			if (!IsAWordChar(sc.ch)) {
 				sc.SetState(SCE_ASM_DEFAULT);
 			}
-		} else if (sc.state == SCE_ASM_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch) ) {
+			break;
+
+		case SCE_ASM_IDENTIFIER:
+			if (!IsAWordChar(sc.ch)) {
 				char s[100];
 				sc.GetCurrentLowered(s, sizeof(s));
 				bool IsDirective = false;
@@ -315,24 +303,26 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i
 				}
 				sc.SetState(SCE_ASM_DEFAULT);
 				if (IsDirective && !strcmp(s, "comment")) {
-					const char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0];
 					while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd) {
 						sc.ForwardSetState(SCE_ASM_DEFAULT);
 					}
-					if (sc.ch == delimiter) {
+					if (sc.ch == options.Delimiter()) {
 						sc.SetState(SCE_ASM_COMMENTDIRECTIVE);
 					}
 				}
 			}
-		} else if (sc.state == SCE_ASM_COMMENTDIRECTIVE) {
-			const char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0];
-			if (sc.ch == delimiter) {
+			break;
+
+		case SCE_ASM_COMMENTDIRECTIVE:
+			if (sc.ch == options.Delimiter()) {
 				while (!sc.MatchLineEnd()) {
 					sc.Forward();
 				}
 				sc.SetState(SCE_ASM_DEFAULT);
 			}
-		} else if (sc.state == SCE_ASM_STRING) {
+			break;
+
+		case SCE_ASM_STRING:
 			if (sc.ch == '\\') {
 				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
 					sc.Forward();
@@ -343,7 +333,9 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i
 				sc.ChangeState(SCE_ASM_STRINGEOL);
 				sc.ForwardSetState(SCE_ASM_DEFAULT);
 			}
-		} else if (sc.state == SCE_ASM_CHARACTER) {
+			break;
+
+		case SCE_ASM_CHARACTER:
 			if (sc.ch == '\\') {
 				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
 					sc.Forward();
@@ -354,13 +346,17 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i
 				sc.ChangeState(SCE_ASM_STRINGEOL);
 				sc.ForwardSetState(SCE_ASM_DEFAULT);
 			}
+			break;
+
+		default:
+			break;
 		}
 
 		// Determine if a new state should be entered.
 		if (sc.state == SCE_ASM_DEFAULT) {
 			if (sc.ch == commentCharacter) {
 				sc.SetState(SCE_ASM_COMMENT);
-			} else if (IsASCII(sc.ch) && (isdigit(sc.ch) || (sc.ch == '.' && IsASCII(sc.chNext) && isdigit(sc.chNext)))) {
+			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
 				sc.SetState(SCE_ASM_NUMBER);
 			} else if (IsAWordStart(sc.ch)) {
 				sc.SetState(SCE_ASM_IDENTIFIER);
@@ -381,32 +377,32 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "else".
 
-void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos_, Sci_Position length, int initStyle, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
 
 	LexAccessor styler(pAccess);
 
-	const Sci_PositionU endPos = startPos + length;
+	const Sci_Position startPos = static_cast<Sci_Position>(startPos_);
+	const Sci_Position endPos = startPos + length;
 	int visibleChars = 0;
 	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
-		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+		levelCurrent = FoldLevelStart(styler.LevelAt(lineCurrent-1));
 	int levelNext = levelCurrent;
 	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
+	int styleNext = styler.StyleIndexAt(startPos);
 	int style = initStyle;
-	char word[100]{};
-	int wordlen = 0;
+	std::string word;
 	const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty();
-	for (Sci_PositionU i = startPos; i < endPos; i++) {
+	for (Sci_Position i = startPos; i < endPos; i++) {
 		const char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		const int stylePrev = style;
 		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
+		styleNext = styler.StyleIndexAt(i + 1);
 		const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 		if (options.foldCommentMultiline && IsStreamCommentStyle(style)) {
 			if (!IsStreamCommentStyle(stylePrev)) {
@@ -419,10 +415,10 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int
 		if (options.foldCommentExplicit && ((style == SCE_ASM_COMMENT) || options.foldExplicitAnywhere)) {
 			if (userDefinedFoldMarkers) {
 				if (styler.Match(i, options.foldExplicitStart.c_str())) {
- 					levelNext++;
+					levelNext++;
 				} else if (styler.Match(i, options.foldExplicitEnd.c_str())) {
- 					levelNext--;
- 				}
+					levelNext--;
+				}
 			} else {
 				if (ch == ';') {
 					if (chNext == '{') {
@@ -431,41 +427,30 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int
 						levelNext--;
 					}
 				}
- 			}
- 		}
-		if (options.foldSyntaxBased && (style == SCE_ASM_DIRECTIVE)) {
-			word[wordlen++] = MakeLowerCase(ch);
-			if (wordlen == 100) {                   // prevent overflow
-				word[0] = '\0';
-				wordlen = 1;
 			}
+		}
+		if (options.foldSyntaxBased && (style == SCE_ASM_DIRECTIVE)) {
+			word.push_back(MakeLowerCase(ch));
 			if (styleNext != SCE_ASM_DIRECTIVE) {   // reading directive ready
-				word[wordlen] = '\0';
-				wordlen = 0;
 				if (directives4foldstart.InList(word)) {
 					levelNext++;
-				} else if (directives4foldend.InList(word)){
+				} else if (directives4foldend.InList(word)) {
 					levelNext--;
 				}
+				word.clear();
 			}
 		}
 		if (!IsASpace(ch))
 			visibleChars++;
 		if (atEOL || (i == endPos-1)) {
-			const int levelUse = levelCurrent;
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && options.foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
+			const int lev = FoldLevelForCurrentNext(levelCurrent, levelNext) |
+				FoldLevelFlags(levelCurrent, levelNext, visibleChars == 0 && options.foldCompact);
+			styler.SetLevelIfDifferent(lineCurrent, lev);
 			lineCurrent++;
 			levelCurrent = levelNext;
-			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length() - 1))) {
+			if (atEOL && (i == (styler.Length() - 1))) {
 				// There is an empty line at end of file so give it same level and empty
-				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+				styler.SetLevel(lineCurrent, FoldLevelForCurrent(levelCurrent) | SC_FOLDLEVELWHITEFLAG);
 			}
 			visibleChars = 0;
 		}
diff --git a/src/lexilla/lexers/LexBash.cxx b/src/lexilla/lexers/LexBash.cxx
index 836cdcb65..566ce5b63 100644
--- a/src/lexilla/lexers/LexBash.cxx
+++ b/src/lexilla/lexers/LexBash.cxx
@@ -109,7 +109,7 @@ constexpr int translateBashDigit(int ch) noexcept {
 	return BASH_BASE_ERROR;
 }
 
-int getBashNumberBase(char *s) noexcept {
+int getBashNumberBase(const char *s) noexcept {
 	int i = 0;
 	int base = 0;
 	while (*s) {
@@ -164,7 +164,7 @@ bool IsCommentLine(Sci_Position line, LexAccessor &styler) {
 		const char ch = styler[i];
 		if (ch == '#')
 			return true;
-		else if (ch != ' ' && ch != '\t')
+		if (ch != ' ' && ch != '\t')
 			return false;
 	}
 	return false;
@@ -698,7 +698,7 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int
 						identifierStyle = subStyle | insideCommand;
 					}
 					// allow keywords ending in a whitespace, meta character or command delimiter
-					char s2[10];
+					char s2[10]{};
 					s2[0] = static_cast<char>(sc.ch);
 					s2[1] = '\0';
 					const bool keywordEnds = IsASpace(sc.ch) || setMetaCharacter.Contains(sc.ch) || cmdDelimiter.InList(s2);
@@ -1140,7 +1140,7 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int
 				}
 				// handle command delimiters in command Start|Body|Word state, also Test if 'test' or '[]'
 				if (cmdState < CmdState::DoubleBracket) {
-					char s[10];
+					char s[10]{};
 					s[0] = static_cast<char>(sc.ch);
 					if (setBashOperator.Contains(sc.chNext)) {
 						s[1] = static_cast<char>(sc.chNext);
@@ -1268,14 +1268,9 @@ void SCI_METHOD LexerBash::Fold(Sci_PositionU startPos_, Sci_Position length, in
 		}
 
 		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && options.foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
+			const int lev = levelPrev |
+				FoldLevelFlags(levelPrev, levelCurrent, visibleChars == 0 && options.foldCompact, visibleChars > 0);
+			styler.SetLevelIfDifferent(lineCurrent, lev);
 			lineCurrent++;
 			levelPrev = levelCurrent;
 			visibleChars = 0;
diff --git a/src/lexilla/lexers/LexCPP.cxx b/src/lexilla/lexers/LexCPP.cxx
index 7e0ea2ca8..2e94c88bf 100644
--- a/src/lexilla/lexers/LexCPP.cxx
+++ b/src/lexilla/lexers/LexCPP.cxx
@@ -121,7 +121,7 @@ struct BracketPair {
 BracketPair FindBracketPair(Tokens &tokens) {
 	const Tokens::iterator itBracket = std::find(tokens.begin(), tokens.end(), "(");
 	if (itBracket != tokens.end()) {
-		size_t nest = 0;
+		ptrdiff_t nest = 0;
 		for (Tokens::iterator itTok = itBracket; itTok != tokens.end(); ++itTok) {
 			if (*itTok == "(") {
 				nest++;
@@ -1502,7 +1502,7 @@ void SCI_METHOD LexerCPP::Fold(Sci_PositionU startPos, Sci_Position length, int
 	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
-		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+		levelCurrent = FoldLevelStart(styler.LevelAt(lineCurrent-1));
 	Sci_PositionU lineStartNext = styler.LineStart(lineCurrent+1);
 	int levelMinCurrent = levelCurrent;
 	int levelNext = levelCurrent;
@@ -1583,21 +1583,16 @@ void SCI_METHOD LexerCPP::Fold(Sci_PositionU startPos, Sci_Position length, int
 			) {
 				levelUse = levelMinCurrent;
 			}
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && options.foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
+			const int lev = FoldLevelForCurrentNext(levelUse, levelNext) |
+				FoldLevelFlags(levelUse, levelNext, visibleChars == 0 && options.foldCompact);
+			styler.SetLevelIfDifferent(lineCurrent, lev);
 			lineCurrent++;
 			lineStartNext = styler.LineStart(lineCurrent+1);
 			levelCurrent = levelNext;
 			levelMinCurrent = levelCurrent;
 			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
 				// There is an empty line at end of file so give it same level and empty
-				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+				styler.SetLevel(lineCurrent, FoldLevelForCurrent(levelCurrent) | SC_FOLDLEVELWHITEFLAG);
 			}
 			visibleChars = 0;
 			inLineComment = false;
@@ -1825,7 +1820,7 @@ Tokens LexerCPP::Tokenize(const std::string &expr) const {
 			word += *cp;
 			cp++;
 		}
-		tokens.push_back(word);
+		tokens.push_back(std::move(word));
 	}
 	return tokens;
 }
diff --git a/src/lexilla/lexers/LexDart.cxx b/src/lexilla/lexers/LexDart.cxx
index 500c0448d..57b2cfeef 100644
--- a/src/lexilla/lexers/LexDart.cxx
+++ b/src/lexilla/lexers/LexDart.cxx
@@ -204,6 +204,7 @@ LexicalClass lexicalClasses[] = {
 	24, "SCE_DART_KW_SECONDARY", "identifier", "Secondary keywords",
 	25, "SCE_DART_KW_TERTIARY", "identifier", "Tertiary keywords",
 	26, "SCE_DART_KW_TYPE", "identifier", "Global types",
+	27, "SCE_DART_STRINGEOL", "error literal string", "End of line where string is not closed",
 };
 
 class LexerDart : public DefaultLexer {
@@ -342,6 +343,10 @@ void LexerDart::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyl
 	int chPrevNonWhite = 0;
 	EscapeSequence escSeq;
 
+	if (initStyle == SCE_DART_STRINGEOL) {
+		initStyle = SCE_DART_DEFAULT;
+	}
+
 	if (startPos != 0) {
 		// backtrack to the line where interpolation starts
 		BacktrackToStart(styler, DartLineStateMaskInterpolation, startPos, lengthDoc, initStyle);
@@ -457,6 +462,8 @@ void LexerDart::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyl
 		case SCE_DART_TRIPLE_RAWSTRING_DQ:
 			if (sc.atLineStart && !IsTripleString(sc.state)) {
 				sc.SetState(SCE_DART_DEFAULT);
+			} else if (sc.atLineEnd && !IsTripleString(sc.state)) {
+				sc.ChangeState(SCE_DART_STRINGEOL);
 			} else if (sc.ch == '\\' && !IsRaw(sc.state)) {
 				if (escSeq.resetEscapeState(sc.state, sc.chNext)) {
 					sc.SetState(SCE_DART_ESCAPECHAR);
@@ -489,6 +496,12 @@ void LexerDart::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyl
 			}
 			break;
 
+		case SCE_DART_STRINGEOL:
+			if (sc.atLineStart) {
+				sc.SetState(SCE_DART_DEFAULT);
+			}
+			break;
+
 		case SCE_DART_ESCAPECHAR:
 			if (escSeq.atEscapeEnd(sc.ch)) {
 				if (escSeq.brace && sc.ch == '}') {
diff --git a/src/lexilla/lexers/LexEDIFACT.cxx b/src/lexilla/lexers/LexEDIFACT.cxx
index fcd342951..69bb13aee 100644
--- a/src/lexilla/lexers/LexEDIFACT.cxx
+++ b/src/lexilla/lexers/LexEDIFACT.cxx
@@ -168,7 +168,8 @@ void LexerEDIFACT::Lex(Sci_PositionU startPos, Sci_Position length, int, IDocume
 	{
 		posCurrent = ForwardPastWhitespace(pAccess, posCurrent, posFinish);
 		// Mark whitespace as default
-		styler.ColourTo(posCurrent - 1, SCE_EDI_DEFAULT);
+		if (posCurrent > 0)
+			styler.ColourTo(posCurrent - 1, SCE_EDI_DEFAULT);
 		if (posCurrent >= posFinish)
 			break;
 
diff --git a/src/lexilla/lexers/LexLua.cxx b/src/lexilla/lexers/LexLua.cxx
index f8ea1e35e..81c2a8391 100644
--- a/src/lexilla/lexers/LexLua.cxx
+++ b/src/lexilla/lexers/LexLua.cxx
@@ -617,16 +617,9 @@ void LexerLua::Fold(Sci_PositionU startPos_, Sci_Position length, int initStyle,
 		}
 
 		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && foldCompact) {
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			}
-			if ((levelCurrent > levelPrev) && (visibleChars > 0)) {
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			}
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
+			const int lev = levelPrev |
+				FoldLevelFlags(levelPrev, levelCurrent, visibleChars == 0 && foldCompact, visibleChars > 0);
+			styler.SetLevelIfDifferent(lineCurrent, lev);
 			lineCurrent++;
 			levelPrev = levelCurrent;
 			visibleChars = 0;
diff --git a/src/lexilla/lexers/LexMake.cxx b/src/lexilla/lexers/LexMake.cxx
index 488546347..1ccb3b8f3 100644
--- a/src/lexilla/lexers/LexMake.cxx
+++ b/src/lexilla/lexers/LexMake.cxx
@@ -14,6 +14,7 @@
 
 #include <string>
 #include <string_view>
+#include <map>
 
 #include "ILexer.h"
 #include "Scintilla.h"
@@ -25,19 +26,110 @@
 #include "StyleContext.h"
 #include "CharacterSet.h"
 #include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
 
+using namespace Scintilla;
 using namespace Lexilla;
 
-static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+namespace {
+
+// Options used for LexerMakeFile
+struct OptionsMake {
+};
+
+const char *const makeWordListDescription[] = {
+	"Directives",
+	nullptr
+};
+
+struct OptionSetMake : public OptionSet<OptionsMake> {
+	OptionSetMake() {
+		DefineWordListSets(makeWordListDescription);
+	}
+};
+
+const LexicalClass lexicalClasses[] = {
+	// Lexer makefile SCLEX_MAKEFILE SCE_MAKE_
+	0, "SCE_MAKE_DEFAULT", "default", "White space",
+	1, "SCE_MAKE_COMMENT", "comment", "Comment",
+	2, "SCE_MAKE_PREPROCESSOR", "preprocessor", "Preprocessor",
+	3, "SCE_MAKE_IDENTIFIER", "identifier", "Identifiers",
+	4, "SCE_MAKE_OPERATOR", "operator", "Operator",
+	5, "SCE_MAKE_TARGET", "identifier", "Identifiers",
+	9, "SCE_MAKE_IDEOL", "error identifier", "Incomplete identifier reference",
+};
+
+bool AtEOL(Accessor &styler, Sci_PositionU i) {
 	return (styler[i] == '\n') ||
-	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+		((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
 }
 
-static void ColouriseMakeLine(
-	const std::string &lineBuffer,
-    Sci_PositionU startLine,
-    Sci_PositionU endPos,
-    Accessor &styler) {
+class LexerMakeFile : public DefaultLexer {
+	WordList directives;
+	OptionsMake options;
+	OptionSetMake osMake;
+public:
+	LexerMakeFile() :
+		DefaultLexer("makefile", SCLEX_MAKEFILE, lexicalClasses, std::size(lexicalClasses)) {
+	}
+
+	const char *SCI_METHOD PropertyNames() override {
+		return osMake.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osMake.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		return osMake.DescribeProperty(name);
+	}
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char *SCI_METHOD PropertyGet(const char *key) override {
+		return osMake.PropertyGet(key);
+	}
+	const char *SCI_METHOD DescribeWordListSets() override {
+		return osMake.DescribeWordListSets();
+	}
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
+
+	void ColouriseMakeLine(std::string_view lineBuffer,
+		Sci_PositionU startLine, Sci_PositionU endPos, Accessor &styler);
+
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
+
+	static ILexer5 *LexerFactoryMakeFile() {
+		return new LexerMakeFile();
+	}
+};
+
+Sci_Position SCI_METHOD LexerMakeFile::PropertySet(const char *key, const char *val) {
+	if (osMake.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerMakeFile::WordListSet(int n, const char *wl) {
+	WordList *wordListN = nullptr;
+	switch (n) {
+	case 0:
+		wordListN = &directives;
+		break;
+	default:
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN && wordListN->Set(wl)) {
+		firstModification = 0;
+	}
+	return firstModification;
+}
+
+void LexerMakeFile::ColouriseMakeLine(
+	const std::string_view lineBuffer,
+	Sci_PositionU startLine,
+	Sci_PositionU endPos,
+	Accessor &styler) {
 
 	const Sci_PositionU lengthLine = lineBuffer.length();
 	Sci_PositionU i = 0;
@@ -46,9 +138,7 @@ static void ColouriseMakeLine(
 	bool bSpecial = false;
 
 	// check for a tab character in column 0 indicating a command
-	bool bCommand = false;
-	if ((lengthLine > 0) && (lineBuffer[0] == '\t'))
-		bCommand = true;
+	const bool bCommand = StartsWith(lineBuffer, '\t');
 
 	// Skip initial spaces
 	while ((i < lengthLine) && isspacechar(lineBuffer[i])) {
@@ -63,10 +153,22 @@ static void ColouriseMakeLine(
 			styler.ColourTo(endPos, SCE_MAKE_PREPROCESSOR);
 			return;
 		}
+		if (IsUpperOrLowerCase(lineBuffer[i]) &&
+			(lineBuffer.find_first_of(":=") == std::string::npos)) {
+			const std::string_view firstWord(lineBuffer.substr(i));
+			size_t endWord = 0;
+			while ((endWord < firstWord.length()) && IsUpperOrLowerCase(firstWord[endWord])) {
+				endWord++;
+			}
+			if (directives.InList(firstWord.substr(0, endWord))) {
+				styler.ColourTo(startLine + i + endWord - 1, SCE_MAKE_PREPROCESSOR);
+				i += endWord;
+			}
+		}
 	}
 	int varCount = 0;
 	while (i < lengthLine) {
-		if (((i + 1) < lengthLine) && (lineBuffer[i] == '$' && lineBuffer[i + 1] == '(')) {
+		if (lineBuffer.substr(i, 2) == "$(") {
 			styler.ColourTo(startLine + i - 1, state);
 			state = SCE_MAKE_IDENTIFIER;
 			varCount++;
@@ -78,32 +180,22 @@ static void ColouriseMakeLine(
 		}
 
 		// skip identifier and target styling if this is a command line
-		if (!bSpecial && !bCommand) {
-			if (lineBuffer[i] == ':') {
-				if (((i + 1) < lengthLine) && (lineBuffer[i + 1] == '=')) {
-					// it's a ':=', so style as an identifier
-					if (lastNonSpace >= 0)
-						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
-					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
-					styler.ColourTo(startLine + i + 1, SCE_MAKE_OPERATOR);
-				} else {
-					// We should check that no colouring was made since the beginning of the line,
-					// to avoid colouring stuff like /OUT:file
-					if (lastNonSpace >= 0)
-						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_TARGET);
-					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
-					styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
-				}
-				bSpecial = true;	// Only react to the first ':' of the line
-				state = SCE_MAKE_DEFAULT;
-			} else if (lineBuffer[i] == '=') {
-				if (lastNonSpace >= 0)
-					styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
-				styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
-				styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
-				bSpecial = true;	// Only react to the first '=' of the line
-				state = SCE_MAKE_DEFAULT;
+		if (!bSpecial && !bCommand && AnyOf(lineBuffer[i], ':', '=')) {
+			// Three cases:
+			// : target
+			// := immediate assignment
+			// = lazy assignment
+			const bool colon = lineBuffer[i] == ':';
+			const bool immediate = colon && ((i + 1) < lengthLine) && (lineBuffer[i + 1] == '=');
+			const Sci_PositionU lengthOperator = immediate ? 1 : 0;
+			if (lastNonSpace >= 0) {
+				const int attribute = (colon && !immediate) ? SCE_MAKE_TARGET : SCE_MAKE_IDENTIFIER;
+				styler.ColourTo(startLine + lastNonSpace, attribute);
 			}
+			styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
+			styler.ColourTo(startLine + i + lengthOperator, SCE_MAKE_OPERATOR);
+			bSpecial = true;	// Only react to the first ':' or '=' of the line
+			state = SCE_MAKE_DEFAULT;
 		}
 		if (!isspacechar(lineBuffer[i])) {
 			lastNonSpace = i;
@@ -117,7 +209,8 @@ static void ColouriseMakeLine(
 	}
 }
 
-static void ColouriseMakeDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+void LexerMakeFile::Lex(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
+	Accessor styler(pAccess, nullptr);
 	std::string lineBuffer;
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
@@ -134,10 +227,9 @@ static void ColouriseMakeDoc(Sci_PositionU startPos, Sci_Position length, int, W
 	if (!lineBuffer.empty()) {	// Last line does not have ending characters
 		ColouriseMakeLine(lineBuffer, startLine, startPos + length - 1, styler);
 	}
+	styler.Flush();
 }
 
-static const char *const emptyWordListDesc[] = {
-	nullptr
-};
+}
 
-extern const LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc, "makefile", nullptr, emptyWordListDesc);
+extern const LexerModule lmMake(SCLEX_MAKEFILE, LexerMakeFile::LexerFactoryMakeFile, "makefile", makeWordListDescription);
diff --git a/src/lexilla/lexers/LexMaxima.cxx b/src/lexilla/lexers/LexMaxima.cxx
index cd16e4ad2..c0aa36f14 100644
--- a/src/lexilla/lexers/LexMaxima.cxx
+++ b/src/lexilla/lexers/LexMaxima.cxx
@@ -43,10 +43,10 @@ static void ColouriseMaximaDoc(Sci_PositionU startPos, Sci_Position length, int
 
   styler.StartAt(startPos);
 
-  Sci_PositionU lengthDoc = startPos + length;
+  Sci_Position lengthDoc = startPos + length;
   styler.StartSegment(startPos);
 
-  Sci_PositionU i = startPos;
+  Sci_Position i = startPos;
 
   // If we are in the middle of a comment we go back to its start before highlighting
   if(lastStyle == SCE_MAXIMA_COMMENT)
@@ -201,7 +201,7 @@ static void ColouriseMaximaDoc(Sci_PositionU startPos, Sci_Position length, int
 	// All other keywords are functions if they are followed
 	// by an opening parenthesis
 	char nextNonwhitespace = ' ';
-	for (Sci_PositionU o = i + 1; o < lengthDoc; o++)
+	for (Sci_Position o = i + 1; o < lengthDoc; o++)
 	  {
 	    nextNonwhitespace = styler.SafeGetCharAt(o);
 	    if(!IsASCII(nextNonwhitespace) || !isspacechar(nextNonwhitespace))
diff --git a/src/lexilla/lexers/LexNix.cxx b/src/lexilla/lexers/LexNix.cxx
index 63f4293a2..f503094a0 100644
--- a/src/lexilla/lexers/LexNix.cxx
+++ b/src/lexilla/lexers/LexNix.cxx
@@ -150,6 +150,7 @@ LexicalClass lexicalClasses[] = {
 	13, "SCE_NIX_KEYWORD2", "identifier", "Keywords 2",
 	14, "SCE_NIX_KEYWORD3", "identifier", "Keywords 3",
 	15, "SCE_NIX_KEYWORD4", "identifier", "Keywords 4",
+	16, "SCE_NIX_STRINGEOL", "error literal string", "End of line where string is not closed",
 };
 
 class LexerNix : public DefaultLexer {
@@ -266,6 +267,10 @@ void LexerNix::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle
 
 	std::vector<InterpolatingState> interpolatingStack;
 
+	if (initStyle == SCE_NIX_STRINGEOL) {
+		initStyle = SCE_NIX_DEFAULT;
+	}
+
 	if (startPos != 0) {
 		// backtrack to the line where interpolation starts
 		BacktrackToStart(styler, NixLineStateMaskInterpolation, startPos, lengthDoc, initStyle);
@@ -323,6 +328,8 @@ void LexerNix::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle
 		case SCE_NIX_STRING:
 			if (sc.atLineStart) {
 				sc.SetState(SCE_NIX_DEFAULT);
+			} else if (sc.atLineEnd) {
+				sc.ChangeState(SCE_NIX_STRINGEOL);
 			} else if (sc.ch == '\\' && AnyOf(sc.chNext, '"', '\\', 'n', 'r', 't', '$')) {
 				sc.SetState(SCE_NIX_STRING);
 				sc.ChangeState(SCE_NIX_ESCAPECHAR);
@@ -339,6 +346,12 @@ void LexerNix::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle
 			}
 			break;
 
+		case SCE_NIX_STRINGEOL:
+			if (sc.atLineStart) {
+				sc.SetState(SCE_NIX_DEFAULT);
+			}
+			break;
+
 		case SCE_NIX_PATH:
 			if (sc.atLineStart) {
 				sc.SetState(SCE_NIX_DEFAULT);
diff --git a/src/lexilla/lexers/LexPerl.cxx b/src/lexilla/lexers/LexPerl.cxx
index 36c2e3ce0..dcc0342e6 100644
--- a/src/lexilla/lexers/LexPerl.cxx
+++ b/src/lexilla/lexers/LexPerl.cxx
@@ -1742,7 +1742,7 @@ void SCI_METHOD LexerPerl::Fold(Sci_PositionU startPos, Sci_Position length, int
 
 	int levelPrev = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
-		levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
+		levelPrev = FoldLevelStart(styler.LevelAt(lineCurrent - 1));
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	char chPrev = styler.SafeGetCharAt(startPos - 1);
@@ -1875,14 +1875,9 @@ void SCI_METHOD LexerPerl::Fold(Sci_PositionU startPos, Sci_Position length, int
 				levelCurrent = SC_FOLDLEVELBASE + 1;
 				isPackageLine = false;
 			}
-			lev |= levelCurrent << 16;
-			if (visibleChars == 0 && options.foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
+			lev |= levelCurrent << FoldLevelShift;
+			lev |= FoldLevelFlags(levelPrev, levelCurrent, visibleChars == 0 && options.foldCompact, visibleChars > 0);
+			styler.SetLevelIfDifferent(lineCurrent, lev);
 			lineCurrent++;
 			levelPrev = levelCurrent;
 			visibleChars = 0;
@@ -1892,7 +1887,7 @@ void SCI_METHOD LexerPerl::Fold(Sci_PositionU startPos, Sci_Position length, int
 		chPrev = ch;
 	}
 	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	const int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
 	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
 }
 
diff --git a/src/lexilla/lexers/LexPython.cxx b/src/lexilla/lexers/LexPython.cxx
index 19b260400..edaf87daa 100644
--- a/src/lexilla/lexers/LexPython.cxx
+++ b/src/lexilla/lexers/LexPython.cxx
@@ -409,7 +409,6 @@ class LexerPython : public DefaultLexer {
 	explicit LexerPython() :
 		DefaultLexer("python", SCLEX_PYTHON, lexicalClasses, std::size(lexicalClasses)) {
 	}
-	~LexerPython() override = default;
 	void SCI_METHOD Release() override {
 		delete this;
 	}
@@ -534,11 +533,7 @@ void LexerPython::ProcessLineEnd(StyleContext &sc, std::vector<SingleFStringExpS
 	}
 
 	if (!fstringStateStack.empty()) {
-		std::pair<Sci_Position, std::vector<SingleFStringExpState> > val;
-		val.first = sc.currentLine;
-		val.second = fstringStateStack;
-
-		ftripleStateAtEol.insert(val);
+		ftripleStateAtEol.insert({sc.currentLine, fstringStateStack});
 	}
 
 	if ((sc.state == SCE_P_DEFAULT)
diff --git a/src/lexilla/lexers/LexRaku.cxx b/src/lexilla/lexers/LexRaku.cxx
index 902bbd5bb..f066f5ebd 100644
--- a/src/lexilla/lexers/LexRaku.cxx
+++ b/src/lexilla/lexers/LexRaku.cxx
@@ -1424,7 +1424,7 @@ void SCI_METHOD LexerRaku::Lex(Sci_PositionU startPos, Sci_Position length, int
 				}
 				const int state = sc.state;
 				sc.Forward();
-				char ch_delim = 0;
+				int ch_delim = 0;
 				if (setSpecialVar.Contains(sc.ch)
 						&& !setWord.Contains(sc.chNext)) {	// Process Special Var
 					ch_delim = -1;
@@ -1532,7 +1532,7 @@ void SCI_METHOD LexerRaku::Fold(Sci_PositionU startPos, Sci_Position length, int
 
 	// init char and style variables
 	char chNext = styler[startPos];
-	int stylePrev = styler.StyleAt(startPos - 1);
+	int stylePrev = startPos > 0 ? styler.StyleAt(startPos - 1) : 0;
 	int styleNext = styler.StyleAt(startPos);
 	int styleNextStartLine = styler.StyleAt(lineStartNext);
 	int visibleChars = 0;
diff --git a/src/lexilla/lexers/LexRuby.cxx b/src/lexilla/lexers/LexRuby.cxx
index 54bc2ffde..47d5e3564 100644
--- a/src/lexilla/lexers/LexRuby.cxx
+++ b/src/lexilla/lexers/LexRuby.cxx
@@ -489,7 +489,7 @@ void InterpolateVariable(LexAccessor &styler, int state, Sci_Position &i, char &
     styler.ColourTo(pos, SCE_RB_OPERATOR);
     state = SCE_RB_GLOBAL;
     pos += 2;
-    unsigned len = 0;
+    int len = 0;
     if (chNext == '$') {
         if (chNext2 == '-') {
             ++pos;
diff --git a/src/lexilla/lexers/LexSQL.cxx b/src/lexilla/lexers/LexSQL.cxx
index 6494c726b..22507debe 100644
--- a/src/lexilla/lexers/LexSQL.cxx
+++ b/src/lexilla/lexers/LexSQL.cxx
@@ -671,7 +671,7 @@ void SCI_METHOD LexerSQL::Fold(Sci_PositionU startPos, Sci_Position length, int
 		}
 		lineCurrent = styler.GetLine(startPos);
 		if (lineCurrent > 0)
-			levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
+			levelCurrent = FoldLevelStart(styler.LevelAt(lineCurrent - 1));
 	}
 	// And because folding ends at ';', keep going until we find one
 	// Otherwise if create ... view ... as is split over multiple
@@ -947,15 +947,9 @@ void SCI_METHOD LexerSQL::Fold(Sci_PositionU startPos, Sci_Position length, int
 			}
 		}
 		if (atEOL) {
-			const int levelUse = levelCurrent;
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && options.foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
+			const int lev = FoldLevelForCurrentNext(levelCurrent, levelNext) |
+				FoldLevelFlags(levelCurrent, levelNext, visibleChars == 0 && options.foldCompact);
+			styler.SetLevelIfDifferent(lineCurrent, lev);
 			lineCurrent++;
 			levelCurrent = levelNext;
 			visibleChars = 0;
diff --git a/src/lexilla/lexers/LexTOML.cxx b/src/lexilla/lexers/LexTOML.cxx
index ee17fe13f..968c18428 100644
--- a/src/lexilla/lexers/LexTOML.cxx
+++ b/src/lexilla/lexers/LexTOML.cxx
@@ -163,6 +163,10 @@ void ColouriseTOMLDoc(Sci_PositionU startPos, Sci_Position lengthDoc, int initSt
 	TOMLKeyState keyState = TOMLKeyState::Unquoted;
 	EscapeSequence escSeq;
 
+	if (initStyle == SCE_TOML_STRINGEOL) {
+		initStyle = SCE_TOML_DEFAULT;
+	}
+
 	StyleContext sc(startPos, lengthDoc, initStyle, styler);
 	if (sc.currentLine > 0) {
 		const int lineState = styler.GetLineState(sc.currentLine - 1);
@@ -274,6 +278,8 @@ void ColouriseTOMLDoc(Sci_PositionU startPos, Sci_Position lengthDoc, int initSt
 		case SCE_TOML_TRIPLE_STRING_DQ:
 			if (sc.atLineStart && !IsTripleString(sc.state)) {
 				sc.SetState(SCE_TOML_DEFAULT);
+			} else if (sc.atLineEnd && !IsTripleString(sc.state)) {
+				sc.ChangeState(SCE_TOML_STRINGEOL);
 			} else if (sc.ch == '\\' && IsDoubleQuoted(sc.state)) {
 				if (escSeq.resetEscapeState(sc.state, sc.chNext)) {
 					sc.SetState(SCE_TOML_ESCAPECHAR);
@@ -293,6 +299,12 @@ void ColouriseTOMLDoc(Sci_PositionU startPos, Sci_Position lengthDoc, int initSt
 			}
 			break;
 
+		case SCE_TOML_STRINGEOL:
+			if (sc.atLineStart) {
+				sc.SetState(SCE_TOML_DEFAULT);
+			}
+			break;
+
 		case SCE_TOML_ESCAPECHAR:
 			if (escSeq.atEscapeEnd(sc.ch)) {
 				sc.SetState(escSeq.outerState);
diff --git a/src/lexilla/lexers/LexYAML.cxx b/src/lexilla/lexers/LexYAML.cxx
index fa758ac90..516697002 100644
--- a/src/lexilla/lexers/LexYAML.cxx
+++ b/src/lexilla/lexers/LexYAML.cxx
@@ -48,11 +48,11 @@ constexpr bool IsWhiteSpaceOrEOL(char ch) noexcept {
 	return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
 }
 
-unsigned int SpaceCount(char* lineBuffer) noexcept {
+unsigned int SpaceCount(const char* lineBuffer) noexcept {
 	if (lineBuffer == nullptr)
 		return 0;
 
-	char* headBuffer = lineBuffer;
+	const char* headBuffer = lineBuffer;
 
 	while (*headBuffer == ' ')
 		headBuffer++;
@@ -60,10 +60,10 @@ unsigned int SpaceCount(char* lineBuffer) noexcept {
 	return static_cast<unsigned int>(headBuffer - lineBuffer);
 }
 
-bool KeywordAtChar(const char* lineBuffer, char* startComment, const WordList &keywords) noexcept {
+bool KeywordAtChar(const char* lineBuffer, const char* startComment, const WordList &keywords) noexcept {
 	if (lineBuffer == nullptr || startComment <= lineBuffer)
 		return false;
-	char* endValue = startComment - 1;
+	const char* endValue = startComment - 1;
 	while (endValue >= lineBuffer && *endValue == ' ')
 		endValue--;
 	Sci_PositionU len = static_cast<Sci_PositionU>(endValue - lineBuffer) + 1;
diff --git a/src/lexilla/lexers/LexZig.cxx b/src/lexilla/lexers/LexZig.cxx
index a2e146847..4ca809055 100644
--- a/src/lexilla/lexers/LexZig.cxx
+++ b/src/lexilla/lexers/LexZig.cxx
@@ -163,6 +163,7 @@ LexicalClass lexicalClasses[] = {
 	15, "SCE_ZIG_KW_TERTIARY", "identifier", "Tertiary keywords",
 	16, "SCE_ZIG_KW_TYPE", "identifier", "Global types",
 	17, "SCE_ZIG_IDENTIFIER_STRING", "identifier", "Identifier using @\"\" syntax",
+	18, "SCE_ZIG_STRINGEOL", "error literal string", "End of line where string is not closed",
 };
 
 class LexerZig : public DefaultLexer {
@@ -262,6 +263,10 @@ void LexerZig::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle
 	int lineState = 0;
 	EscapeSequence escSeq;
 
+	if (initStyle == SCE_ZIG_STRINGEOL) {
+		initStyle = SCE_ZIG_DEFAULT;
+	}
+
 	StyleContext sc(startPos, lengthDoc, initStyle, styler);
 
 	while (sc.More()) {
@@ -311,6 +316,8 @@ void LexerZig::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle
 		case SCE_ZIG_IDENTIFIER_STRING:
 			if (sc.atLineStart) {
 				sc.SetState(SCE_ZIG_DEFAULT);
+			} else if (sc.atLineEnd && sc.state != SCE_ZIG_MULTISTRING) {
+				sc.ChangeState(SCE_ZIG_STRINGEOL);
 			} else if (sc.ch == '\\' && sc.state != SCE_ZIG_MULTISTRING) {
 				escSeq.resetEscapeState(sc.state, sc.chNext);
 				sc.SetState(SCE_ZIG_ESCAPECHAR);
@@ -326,6 +333,12 @@ void LexerZig::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle
 			}
 			break;
 
+		case SCE_ZIG_STRINGEOL:
+			if (sc.atLineStart) {
+				sc.SetState(SCE_ZIG_DEFAULT);
+			}
+			break;
+
 		case SCE_ZIG_ESCAPECHAR:
 			if (escSeq.atEscapeEnd(sc.ch)) {
 				if (escSeq.brace && sc.ch == '}') {
diff --git a/src/lexilla/lexlib/CharacterSet.cxx b/src/lexilla/lexlib/CharacterSet.cxx
index 619776db2..065a4a481 100644
--- a/src/lexilla/lexlib/CharacterSet.cxx
+++ b/src/lexilla/lexlib/CharacterSet.cxx
@@ -58,9 +58,8 @@ int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept {
 	}
 	if (len == 0)
 		return 0;
-	else
-		// Either *a or *b is nul
-		return *a - *b;
+	// Either *a or *b is nul
+	return *a - *b;
 }
 
 }
diff --git a/src/lexilla/lexlib/CharacterSet.h b/src/lexilla/lexlib/CharacterSet.h
index 3b1f4890e..62c674d8d 100644
--- a/src/lexilla/lexlib/CharacterSet.h
+++ b/src/lexilla/lexlib/CharacterSet.h
@@ -190,6 +190,10 @@ int CompareCaseInsensitive(const char *a, const char *b) noexcept;
 bool EqualCaseInsensitive(std::string_view a, std::string_view b) noexcept;
 int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept;
 
+constexpr bool StartsWith(std::string_view s, char start) noexcept {
+	return !s.empty() && (s.front() == start);
+}
+
 }
 
 #endif
diff --git a/src/lexilla/lexlib/DefaultLexer.cxx b/src/lexilla/lexlib/DefaultLexer.cxx
index d84062d9a..a654f3648 100644
--- a/src/lexilla/lexlib/DefaultLexer.cxx
+++ b/src/lexilla/lexlib/DefaultLexer.cxx
@@ -139,3 +139,6 @@ int SCI_METHOD DefaultLexer::GetIdentifier() {
 	return language;
 }
 
+const char *SCI_METHOD DefaultLexer::PropertyGet(const char * /* key */) {
+	return nullptr;
+}
diff --git a/src/lexilla/lexlib/DefaultLexer.h b/src/lexilla/lexlib/DefaultLexer.h
index 9db3f4d88..c1d1319dd 100644
--- a/src/lexilla/lexlib/DefaultLexer.h
+++ b/src/lexilla/lexlib/DefaultLexer.h
@@ -50,6 +50,7 @@ class DefaultLexer : public Scintilla::ILexer5 {
 	// ILexer5 methods
 	const char * SCI_METHOD GetName() override;
 	int SCI_METHOD GetIdentifier() override;
+	const char *SCI_METHOD PropertyGet(const char *key) override;
 };
 
 }
diff --git a/src/lexilla/lexlib/LexAccessor.cxx b/src/lexilla/lexlib/LexAccessor.cxx
index f8d1ccacb..fee072712 100644
--- a/src/lexilla/lexlib/LexAccessor.cxx
+++ b/src/lexilla/lexlib/LexAccessor.cxx
@@ -11,6 +11,7 @@
 #include <algorithm>
 
 #include "ILexer.h"
+#include "Scintilla.h"
 
 #include "LexAccessor.h"
 #include "CharacterSet.h"
@@ -73,4 +74,21 @@ std::string LexAccessor::GetRangeLowered(Sci_PositionU startPos_, Sci_PositionU
 	return s;
 }
 
+void LexAccessor::SetLevelIfDifferent(Sci_Position line, int level) {
+	if (level != pAccess->GetLevel(line)) {
+		pAccess->SetLevel(line, level);
+	}
+}
+
+int FoldLevelFlags(int levelLine, int levelNext, bool white, bool headerPermitted) noexcept {
+	int flags = 0;
+	if (white) {
+		flags |= SC_FOLDLEVELWHITEFLAG;
+	}
+	if ((levelLine < levelNext) && (headerPermitted)) {
+		flags |= SC_FOLDLEVELHEADERFLAG;
+	}
+	return flags;
+}
+
 }
diff --git a/src/lexilla/lexlib/LexAccessor.h b/src/lexilla/lexlib/LexAccessor.h
index 73fed173a..2d97b64a4 100644
--- a/src/lexilla/lexlib/LexAccessor.h
+++ b/src/lexilla/lexlib/LexAccessor.h
@@ -205,6 +205,8 @@ class LexAccessor {
 	void SetLevel(Sci_Position line, int level) {
 		pAccess->SetLevel(line, level);
 	}
+	// Avoids some overhead when level same as before 
+	void SetLevelIfDifferent(Sci_Position line, int level);
 	void IndicatorFill(Sci_Position start, Sci_Position end, int indicator, int value) {
 		pAccess->DecorationSetCurrentIndicator(indicator);
 		pAccess->DecorationFillRange(start, value, end - start);
@@ -222,6 +224,21 @@ struct LexicalClass {
 	const char *description;
 };
 
+// Fold level setting
+
+constexpr int FoldLevelShift = 16;
+constexpr int FoldLevelStart(int levelPrevious) noexcept {
+	return levelPrevious >> FoldLevelShift;
+}
+constexpr int FoldLevelForCurrentNext(int levelCurrent, int levelNext) noexcept {
+	return levelCurrent | levelNext << FoldLevelShift;
+}
+// Where lexer uses current/next but only has one value, commonly at end of range
+constexpr int FoldLevelForCurrent(int levelCurrent) noexcept {
+	return FoldLevelForCurrentNext(levelCurrent, levelCurrent);
+}
+int FoldLevelFlags(int levelLine, int levelNext, bool white, bool headerPermitted=true) noexcept;
+
 }
 
 #endif
diff --git a/src/lexilla/lexlib/SparseState.h b/src/lexilla/lexlib/SparseState.h
index ff0a5954f..412c4e57d 100644
--- a/src/lexilla/lexlib/SparseState.h
+++ b/src/lexilla/lexlib/SparseState.h
@@ -43,7 +43,7 @@ class SparseState {
 	void Set(Sci_Position position, T value) {
 		Delete(position);
 		if (states.empty() || (value != states[states.size()-1].value)) {
-			states.push_back(State(position, value));
+			states.emplace_back(position, value);
 		}
 	}
 	T ValueAt(Sci_Position position) {
diff --git a/src/lexilla/lexlib/WordList.cxx b/src/lexilla/lexlib/WordList.cxx
index b66479fd7..06885f0e7 100644
--- a/src/lexilla/lexlib/WordList.cxx
+++ b/src/lexilla/lexlib/WordList.cxx
@@ -191,8 +191,29 @@ bool WordList::InList(const char *s) const noexcept {
 
 /** convenience overload so can easily call with std::string.
  */
-bool WordList::InList(const std::string &s) const noexcept {
-	return InList(s.c_str());
+
+bool WordList::InList(std::string_view sv) const noexcept {
+	if (!words || sv.empty())
+		return false;
+	const char first = sv[0];
+	const unsigned char firstChar = first;
+	if (int j = starts[firstChar]; j >= 0) {
+		const std::string_view after = sv.substr(1);
+		for (; words[j][0] == first; j++) {
+			if (std::string_view(words[j] + 1) == after) {
+				return true;
+			}
+		}
+	}
+	if (int j = starts[static_cast<unsigned int>('^')]; j >= 0) {
+		for (; words[j][0] == '^';j++) {
+			// Use rfind with 0 position to act like C++20 starts_with for C++17
+			if (sv.rfind(words[j] + 1, 0) == 0) {
+				return true;
+			}
+		}
+	}
+	return false;
 }
 
 /** similar to InList, but word s can be a substring of keyword.
diff --git a/src/lexilla/lexlib/WordList.h b/src/lexilla/lexlib/WordList.h
index e4213f091..ca5151716 100644
--- a/src/lexilla/lexlib/WordList.h
+++ b/src/lexilla/lexlib/WordList.h
@@ -33,7 +33,7 @@ class WordList {
 	void Clear() noexcept;
 	bool Set(const char *s, bool lowerCase=false);
 	bool InList(const char *s) const noexcept;
-	bool InList(const std::string &s) const noexcept;
+	bool InList(std::string_view sv) const noexcept;
 	bool InListAbbreviated(const char *s, const char marker) const noexcept;
 	bool InListAbridged(const char *s, const char marker) const noexcept;
 	const char *WordAt(int n) const noexcept;
diff --git a/src/lexilla/src/Lexilla/Info.plist b/src/lexilla/src/Lexilla/Info.plist
index a1d0470fc..050be461a 100644
--- a/src/lexilla/src/Lexilla/Info.plist
+++ b/src/lexilla/src/Lexilla/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>5.4.3</string>
+	<string>5.4.5</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
diff --git a/src/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj b/src/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
index 9f612513f..730957734 100644
--- a/src/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
+++ b/src/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
@@ -876,7 +876,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 5.4.3;
+				CURRENT_PROJECT_VERSION = 5.4.5;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -904,7 +904,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 5.4.3;
+				CURRENT_PROJECT_VERSION = 5.4.5;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
diff --git a/src/lexilla/src/LexillaVersion.rc b/src/lexilla/src/LexillaVersion.rc
index 14864f191..e6c6773cc 100644
--- a/src/lexilla/src/LexillaVersion.rc
+++ b/src/lexilla/src/LexillaVersion.rc
@@ -4,8 +4,8 @@
 
 #include <windows.h>
 
-#define VERSION_LEXILLA "5.4.3"
-#define VERSION_WORDS 5, 4, 3, 0
+#define VERSION_LEXILLA "5.4.5"
+#define VERSION_WORDS 5, 4, 5, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
diff --git a/src/lexilla/src/deps.mak b/src/lexilla/src/deps.mak
index 38d54455c..c093e3b21 100644
--- a/src/lexilla/src/deps.mak
+++ b/src/lexilla/src/deps.mak
@@ -41,6 +41,7 @@ $(DIR_O)/LexAccessor.o: \
 	../lexlib/LexAccessor.cxx \
 	../../scintilla/include/ILexer.h \
 	../../scintilla/include/Sci_Position.h \
+	../../scintilla/include/Scintilla.h \
 	../lexlib/LexAccessor.h \
 	../lexlib/CharacterSet.h
 $(DIR_O)/LexerBase.o: \
@@ -897,7 +898,9 @@ $(DIR_O)/LexMake.o: \
 	../lexlib/Accessor.h \
 	../lexlib/StyleContext.h \
 	../lexlib/CharacterSet.h \
-	../lexlib/LexerModule.h
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
 $(DIR_O)/LexMarkdown.o: \
 	../lexers/LexMarkdown.cxx \
 	../../scintilla/include/ILexer.h \
diff --git a/src/lexilla/src/lexilla.mak b/src/lexilla/src/lexilla.mak
index ec5c250f7..e0fb05e1b 100644
--- a/src/lexilla/src/lexilla.mak
+++ b/src/lexilla/src/lexilla.mak
@@ -15,7 +15,7 @@
 
 .SUFFIXES: .cxx
 
-DIR_O=.
+DIR_O=obj
 DIR_BIN=..\bin
 
 LEXILLA=$(DIR_BIN)\lexilla.dll
@@ -23,6 +23,10 @@ LIBLEXILLA=$(DIR_BIN)\liblexilla.lib
 
 LD=link
 
+!IF "$(PLATFORM:64=)" == "arm"
+ARM64=1
+!ENDIF
+
 !IFDEF SUPPORT_XP
 ADD_DEFINE=-D_USING_V110_SDK71_
 # Different subsystems for 32-bit and 64-bit Windows XP so detect based on Platform
@@ -33,10 +37,11 @@ SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.02
 SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.01
 !ENDIF
 !ELSE
-CETCOMPAT=-CETCOMPAT
 !IFDEF ARM64
 ADD_DEFINE=-D_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1
 SUBSYSTEM=-SUBSYSTEM:WINDOWS,10.00
+!ELSE
+CETCOMPAT=-CETCOMPAT
 !ENDIF
 !ENDIF
 
@@ -68,7 +73,10 @@ SCINTILLA_INCLUDE = ../../scintilla/include
 INCLUDEDIRS=-I../include -I$(SCINTILLA_INCLUDE) -I../lexlib
 CXXFLAGS=$(CXXFLAGS) $(INCLUDEDIRS)
 
-all:	$(SCINTILLA_INCLUDE) $(LEXILLA) $(LIBLEXILLA)
+all:	$(SCINTILLA_INCLUDE) $(DIR_O) $(LEXILLA) $(LIBLEXILLA)
+
+$(DIR_O):
+	mkdir "$(DIR_O)" 2>NUL || cd .
 
 clean:
 	-del /q $(DIR_O)\*.obj $(DIR_O)\*.o $(DIR_O)\*.pdb \
diff --git a/src/lexilla/src/nmdeps.mak b/src/lexilla/src/nmdeps.mak
index 02cb58b76..2bbb6a473 100644
--- a/src/lexilla/src/nmdeps.mak
+++ b/src/lexilla/src/nmdeps.mak
@@ -41,6 +41,7 @@ $(DIR_O)/LexAccessor.obj: \
 	../lexlib/LexAccessor.cxx \
 	../../scintilla/include/ILexer.h \
 	../../scintilla/include/Sci_Position.h \
+	../../scintilla/include/Scintilla.h \
 	../lexlib/LexAccessor.h \
 	../lexlib/CharacterSet.h
 $(DIR_O)/LexerBase.obj: \
@@ -897,7 +898,9 @@ $(DIR_O)/LexMake.obj: \
 	../lexlib/Accessor.h \
 	../lexlib/StyleContext.h \
 	../lexlib/CharacterSet.h \
-	../lexlib/LexerModule.h
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
 $(DIR_O)/LexMarkdown.obj: \
 	../lexers/LexMarkdown.cxx \
 	../../scintilla/include/ILexer.h \
diff --git a/src/lexilla/test/examples/asm/AllStyles.asm b/src/lexilla/test/examples/asm/AllStyles.asm
index 251666228..62eaba1ca 100644
--- a/src/lexilla/test/examples/asm/AllStyles.asm
+++ b/src/lexilla/test/examples/asm/AllStyles.asm
@@ -49,4 +49,9 @@ movq
  comment ~ A multiple-line
  comment directive~
 
+; test for folding from segment to ends
+data segment
+hw db "HW!"
+data ends
+
 ;end
diff --git a/src/lexilla/test/examples/asm/AllStyles.asm.folded b/src/lexilla/test/examples/asm/AllStyles.asm.folded
index 6fe027cf8..be3f430e0 100644
--- a/src/lexilla/test/examples/asm/AllStyles.asm.folded
+++ b/src/lexilla/test/examples/asm/AllStyles.asm.folded
@@ -1,53 +1,58 @@
- 0 400   0   ; Enumerate all styles: 0 to 15 except for 11(comment block) which is not yet implemented.
- 0 400   0   ; This is not a viable source file, it just illustrates the different states in isolation.
- 0 400   0   
- 0 400   0   ; comment=1
- 0 400   0   ; Comment
- 0 400   0   
- 0 400   0   ; whitespace=0
- 0 400   0   	; w
- 0 400   0   
- 0 400   0   ; number=2
- 0 400   0   11
- 0 400   0   
- 0 400   0   ; string=3
- 0 400   0   "String"
- 0 400   0   
- 0 400   0   ; operator=4
- 0 400   0   +
- 0 400   0   
- 0 400   0   ; identifier=5
- 0 400   0   identifier
- 0 400   0   
- 0 400   0   ; CPU instruction=6
- 0 400   0   add
- 0 400   0   
- 0 400   0   ; math Instruction=7
- 0 400   0   fadd
- 0 400   0   
- 0 400   0   ; register=8
- 0 400   0   ECX
- 0 400   0   
- 0 400   0   ; directive=9
- 0 400   0   section
- 0 400   0   
- 0 400   0   ; directive operand=10
- 0 400   0   rel
- 0 400   0   
- 0 400   0   ; comment block=11 is for future expansion
- 0 400   0   
- 0 400   0   ; character=12
- 0 400   0   'character'
- 0 400   0   
- 0 400   0   ; string EOL=13
- 0 400   0   "no line end
- 0 400   0   
- 0 400   0   ; extended instruction=14
- 0 400   0   movq
- 0 400   0   
- 0 400   0   ; comment directive=15
- 0 400   0    comment ~ A multiple-line
- 0 400   0    comment directive~
- 0 400   0   
- 0 400   0   ;end
- 0 400   0   
\ No newline at end of file
+ 0 400 400   ; Enumerate all styles: 0 to 15 except for 11(comment block) which is not yet implemented.
+ 0 400 400   ; This is not a viable source file, it just illustrates the different states in isolation.
+ 1 400 400   
+ 0 400 400   ; comment=1
+ 0 400 400   ; Comment
+ 1 400 400   
+ 0 400 400   ; whitespace=0
+ 0 400 400   	; w
+ 1 400 400   
+ 0 400 400   ; number=2
+ 0 400 400   11
+ 1 400 400   
+ 0 400 400   ; string=3
+ 0 400 400   "String"
+ 1 400 400   
+ 0 400 400   ; operator=4
+ 0 400 400   +
+ 1 400 400   
+ 0 400 400   ; identifier=5
+ 0 400 400   identifier
+ 1 400 400   
+ 0 400 400   ; CPU instruction=6
+ 0 400 400   add
+ 1 400 400   
+ 0 400 400   ; math Instruction=7
+ 0 400 400   fadd
+ 1 400 400   
+ 0 400 400   ; register=8
+ 0 400 400   ECX
+ 1 400 400   
+ 0 400 400   ; directive=9
+ 0 400 400   section
+ 1 400 400   
+ 0 400 400   ; directive operand=10
+ 0 400 400   rel
+ 1 400 400   
+ 0 400 400   ; comment block=11 is for future expansion
+ 1 400 400   
+ 0 400 400   ; character=12
+ 0 400 400   'character'
+ 1 400 400   
+ 0 400 400   ; string EOL=13
+ 0 400 400   "no line end
+ 1 400 400   
+ 0 400 400   ; extended instruction=14
+ 0 400 400   movq
+ 1 400 400   
+ 0 400 400   ; comment directive=15
+ 0 400 400    comment ~ A multiple-line
+ 0 400 400    comment directive~
+ 1 400 400   
+ 0 400 400   ; test for folding from segment to ends
+ 2 400 401 + data segment
+ 0 401 401 | hw db "HW!"
+ 0 401 400 | data ends
+ 1 400 400   
+ 0 400 400   ;end
+ 1 400 400   
\ No newline at end of file
diff --git a/src/lexilla/test/examples/asm/AllStyles.asm.styled b/src/lexilla/test/examples/asm/AllStyles.asm.styled
index 74d82cb5d..30525b09c 100644
--- a/src/lexilla/test/examples/asm/AllStyles.asm.styled
+++ b/src/lexilla/test/examples/asm/AllStyles.asm.styled
@@ -49,4 +49,9 @@
 {0} {9}comment{0} {15}~ A multiple-line
  comment directive~{0}
 
+{1}; test for folding from segment to ends
+{5}data{0} {9}segment{0}
+{5}hw{0} {9}db{0} {3}"HW!"{0}
+{5}data{0} {9}ends{0}
+
 {1};end
diff --git a/src/lexilla/test/examples/asm/SciTE.properties b/src/lexilla/test/examples/asm/SciTE.properties
index 8acf144e4..8c8ba2cbd 100644
--- a/src/lexilla/test/examples/asm/SciTE.properties
+++ b/src/lexilla/test/examples/asm/SciTE.properties
@@ -3,7 +3,10 @@ lexer.*.asm=asm
 keywords.*.asm=add sub xor mov lea call
 keywords2.*.asm=fadd
 keywords3.*.asm=rsp rax rcx rdx r8 r9 ecx
-keywords4.*.asm=db section alignb resq resqdb global extern equ .bss .text .data start comment
+keywords4.*.asm=db section segment ends alignb resq resqdb global extern equ .bss .text .data start comment
 keywords5.*.asm=qword rel
 keywords6.*.asm=movd movq 
+keywords7.*.asm=segment
+keywords8.*.asm=ends
 
+fold=1
diff --git a/src/lexilla/test/examples/dart/AllStyles.dart b/src/lexilla/test/examples/dart/AllStyles.dart
index b0f3fae07..cecbc246e 100644
--- a/src/lexilla/test/examples/dart/AllStyles.dart
+++ b/src/lexilla/test/examples/dart/AllStyles.dart
@@ -332,3 +332,8 @@ var s3 = """multi-line
 ${x}
 strings
 """;
+
+var s1 = 'Unterminated string;
+var s2 = "Unterminated string;
+var s3 = r'Unterminated raw string;
+var s4 = r'Unterminated raw string;
diff --git a/src/lexilla/test/examples/dart/AllStyles.dart.folded b/src/lexilla/test/examples/dart/AllStyles.dart.folded
index ff083ceff..feaa53ff8 100644
--- a/src/lexilla/test/examples/dart/AllStyles.dart.folded
+++ b/src/lexilla/test/examples/dart/AllStyles.dart.folded
@@ -332,4 +332,9 @@
  0 401 401 | ${x}
  0 401 401 | strings
  0 401 400 | """;
+ 0 400 400   
+ 0 400 400   var s1 = 'Unterminated string;
+ 0 400 400   var s2 = "Unterminated string;
+ 0 400 400   var s3 = r'Unterminated raw string;
+ 0 400 400   var s4 = r'Unterminated raw string;
  0 400   0   
\ No newline at end of file
diff --git a/src/lexilla/test/examples/dart/AllStyles.dart.styled b/src/lexilla/test/examples/dart/AllStyles.dart.styled
index 183b8c313..66300a7e0 100644
--- a/src/lexilla/test/examples/dart/AllStyles.dart.styled
+++ b/src/lexilla/test/examples/dart/AllStyles.dart.styled
@@ -332,3 +332,8 @@ strings
 {17}${{14}x{17}}{8}
 strings
 """{16};{0}
+
+{23}var{0} {14}s1{0} {16}={0} {27}'Unterminated string;
+{23}var{0} {14}s2{0} {16}={0} {27}"Unterminated string;
+{23}var{0} {14}s3{0} {16}={0} {27}r'Unterminated raw string;
+{23}var{0} {14}s4{0} {16}={0} {27}r'Unterminated raw string;
diff --git a/src/lexilla/test/examples/nix/AllStyles.nix b/src/lexilla/test/examples/nix/AllStyles.nix
index e2e69d9c0..d35a6db75 100644
--- a/src/lexilla/test/examples/nix/AllStyles.nix
+++ b/src/lexilla/test/examples/nix/AllStyles.nix
@@ -347,3 +347,6 @@ stdenv.mkDerivation rec {
     '';
 
 }
+
+message = "unterminated string;
+message2 = "unterminated string;
diff --git a/src/lexilla/test/examples/nix/AllStyles.nix.folded b/src/lexilla/test/examples/nix/AllStyles.nix.folded
index 6be9a3acd..34304ae6e 100644
--- a/src/lexilla/test/examples/nix/AllStyles.nix.folded
+++ b/src/lexilla/test/examples/nix/AllStyles.nix.folded
@@ -347,4 +347,7 @@
  0 402 401 |     '';
  0 401 401 | 
  0 401 400 | }
+ 0 400 400   
+ 0 400 400   message = "unterminated string;
+ 0 400 400   message2 = "unterminated string;
  0 400   0   
\ No newline at end of file
diff --git a/src/lexilla/test/examples/nix/AllStyles.nix.styled b/src/lexilla/test/examples/nix/AllStyles.nix.styled
index 32813d0eb..a0ea73f33 100644
--- a/src/lexilla/test/examples/nix/AllStyles.nix.styled
+++ b/src/lexilla/test/examples/nix/AllStyles.nix.styled
@@ -347,3 +347,6 @@ string
     ''{7};{0}
 
 {7}}{0}
+
+{10}message{0} {7}={0} {16}"unterminated string;
+{10}message2{0} {7}={0} {16}"unterminated string;
diff --git a/src/lexilla/test/examples/toml/AllStyles.toml b/src/lexilla/test/examples/toml/AllStyles.toml
index bb37dd7c3..999e3ddf8 100644
--- a/src/lexilla/test/examples/toml/AllStyles.toml
+++ b/src/lexilla/test/examples/toml/AllStyles.toml
@@ -189,3 +189,5 @@ points = [ { x = 1, y = 2, z = 3 },
 ~~~~ = true       # invalid character in key
 invalid           # invalid, missing value
 key = identifier  # also invalid, identifier must be one of true, false, inf, nan
+key = "unterminated string
+key = 'other unterminated string
diff --git a/src/lexilla/test/examples/toml/AllStyles.toml.folded b/src/lexilla/test/examples/toml/AllStyles.toml.folded
index 6a5495990..23be2fa96 100644
--- a/src/lexilla/test/examples/toml/AllStyles.toml.folded
+++ b/src/lexilla/test/examples/toml/AllStyles.toml.folded
@@ -189,4 +189,6 @@
  0 401   0 | ~~~~ = true       # invalid character in key
  0 401   0 | invalid           # invalid, missing value
  0 401   0 | key = identifier  # also invalid, identifier must be one of true, false, inf, nan
+ 0 401   0 | key = "unterminated string
+ 0 401   0 | key = 'other unterminated string
  0 401   0 | 
\ No newline at end of file
diff --git a/src/lexilla/test/examples/toml/AllStyles.toml.styled b/src/lexilla/test/examples/toml/AllStyles.toml.styled
index 5e6788c86..88a9eb809 100644
--- a/src/lexilla/test/examples/toml/AllStyles.toml.styled
+++ b/src/lexilla/test/examples/toml/AllStyles.toml.styled
@@ -189,3 +189,5 @@ trimmed in raw strings.
 {7}~~~~ = true       {1}# invalid character in key
 {6}invalid{0}           {1}# invalid, missing value
 {6}key{0} {8}={0} {2}identifier{0}  {1}# also invalid, identifier must be one of true, false, inf, nan
+{6}key{0} {8}={0} {15}"unterminated string
+{6}key{0} {8}={0} {15}'other unterminated string
diff --git a/src/lexilla/test/examples/zig/AllStyles.zig b/src/lexilla/test/examples/zig/AllStyles.zig
index 046853475..1cc21886e 100644
--- a/src/lexilla/test/examples/zig/AllStyles.zig
+++ b/src/lexilla/test/examples/zig/AllStyles.zig
@@ -288,3 +288,7 @@ const Color = enum {
     @"really red",
 };
 const color: Color = .@"really red";
+
+const s1 = "Unterminated string
+const s2 = 'Unterminated character
+const s3 = @"Unterminated identifier string
diff --git a/src/lexilla/test/examples/zig/AllStyles.zig.folded b/src/lexilla/test/examples/zig/AllStyles.zig.folded
index 30bff04a3..c8ee5eb98 100644
--- a/src/lexilla/test/examples/zig/AllStyles.zig.folded
+++ b/src/lexilla/test/examples/zig/AllStyles.zig.folded
@@ -288,4 +288,8 @@
  0 401 401 |     @"really red",
  0 401 400 | };
  0 400 400   const color: Color = .@"really red";
+ 0 400 400   
+ 0 400 400   const s1 = "Unterminated string
+ 0 400 400   const s2 = 'Unterminated character
+ 0 400 400   const s3 = @"Unterminated identifier string
  0 400   0   
\ No newline at end of file
diff --git a/src/lexilla/test/examples/zig/AllStyles.zig.styled b/src/lexilla/test/examples/zig/AllStyles.zig.styled
index 853f3c13b..db78630ea 100644
--- a/src/lexilla/test/examples/zig/AllStyles.zig.styled
+++ b/src/lexilla/test/examples/zig/AllStyles.zig.styled
@@ -288,3 +288,7 @@
     {17}@"really red"{5},{0}
 {5}};{0}
 {13}const{0} {10}color{5}:{0} {10}Color{0} {5}={0} {5}.{17}@"really red"{5};{0}
+
+{13}const{0} {10}s1{0} {5}={0} {18}"Unterminated string
+{13}const{0} {10}s2{0} {5}={0} {18}'Unterminated character
+{13}const{0} {10}s3{0} {5}={0} {18}@"Unterminated identifier string
diff --git a/src/lexilla/test/testlexers.mak b/src/lexilla/test/testlexers.mak
index 1b51a6b70..0a3bf5d11 100644
--- a/src/lexilla/test/testlexers.mak
+++ b/src/lexilla/test/testlexers.mak
@@ -17,7 +17,7 @@ DEBUG_OPTIONS = -Zi -DEBUG -Od -MTd -DDEBUG $(STATIC_FLAG)
 DEBUG_OPTIONS = -O2 -MT -DNDEBUG $(STATIC_FLAG) -GL
 !ENDIF
 
-CXXFLAGS = /EHsc /std:c++latest $(DEBUG_OPTIONS) $(INCLUDEDIRS)
+CXXFLAGS = /EHsc /std:c++20 $(DEBUG_OPTIONS) $(INCLUDEDIRS)
 
 OBJS = TestLexers.obj TestDocument.obj LexillaAccess.obj
 
diff --git a/src/lexilla/test/unit/testWordList.cxx b/src/lexilla/test/unit/testWordList.cxx
index 2df7f190a..0b5dacbaf 100644
--- a/src/lexilla/test/unit/testWordList.cxx
+++ b/src/lexilla/test/unit/testWordList.cxx
@@ -44,6 +44,24 @@ TEST_CASE("WordList") {
 		REQUIRE(!wl.InList(sClass));
 	}
 
+	SECTION("StringViewInList") {
+		wl.Set("else struct i ^gtk");
+		std::string_view svStruct = "struct";
+		REQUIRE(wl.InList(svStruct));
+		std::string_view svClass = "class";
+		REQUIRE(!wl.InList(svClass));
+
+		// Test single characters
+		std::string_view svI = "i";
+		REQUIRE(wl.InList(svI));
+		std::string_view svA = "a";
+		REQUIRE(!wl.InList(svA));
+
+		// Test prefix
+		std::string_view svPrefix = "gtk_prefix";
+		REQUIRE(wl.InList(svPrefix));
+	}
+
 	SECTION("InListUnicode") {
 		// "cheese" in English
 		// "kase" ('k', 'a with diaeresis', 's', 'e') in German
diff --git a/src/lexilla/version.txt b/src/lexilla/version.txt
index 878b70634..e953fd4ef 100644
--- a/src/lexilla/version.txt
+++ b/src/lexilla/version.txt
@@ -1 +1 @@
-543
\ No newline at end of file
+545
\ No newline at end of file
diff --git a/src/scintilla/.hg_archival.txt b/src/scintilla/.hg_archival.txt
index 34cebc815..d47b918f4 100644
--- a/src/scintilla/.hg_archival.txt
+++ b/src/scintilla/.hg_archival.txt
@@ -1,6 +1,6 @@
 repo: bdf8c3ef2fb01ea24578e726337888e706d10b92
-node: 944510e552c73fb3df41af45f452420fc9193ede
+node: e2e6e7769dc1712dcc4af0a74778d5523711e666
 branch: default
-latesttag: rel-5-5-5
+latesttag: rel-5-5-7
 latesttagdistance: 1
 changessincelatesttag: 1
diff --git a/src/scintilla/.hgtags b/src/scintilla/.hgtags
index 7035cc12b..d465345dd 100644
--- a/src/scintilla/.hgtags
+++ b/src/scintilla/.hgtags
@@ -214,3 +214,5 @@ c171b756efc76359f0795ca0a1bfb7eb16d4c04b rel-5-4-3
 7bc37e9e9de31baf3725e083ee1b937e54856856 rel-5-5-3
 56bc6f0e611a5f46529ff4d2f47ddb1b922d743e rel-5-5-4
 5cb9af9b3103ffa3c8c4e3c15887191486de260f rel-5-5-5
+68ddcf0a91ee2763cfc148925917bf609b355948 rel-5-5-6
+ba0e2f317940a65f8f16325cbe4234fd75a6d47b rel-5-5-7
diff --git a/src/scintilla/call/ScintillaCall.cxx b/src/scintilla/call/ScintillaCall.cxx
index 57b050805..d1d4012b2 100644
--- a/src/scintilla/call/ScintillaCall.cxx
+++ b/src/scintilla/call/ScintillaCall.cxx
@@ -1115,6 +1115,14 @@ int ScintillaCall::AutoCGetStyle() {
 	return static_cast<int>(Call(Message::AutoCGetStyle));
 }
 
+void ScintillaCall::AutoCSetImageScale(int scalePercent) {
+	Call(Message::AutoCSetImageScale, scalePercent);
+}
+
+int ScintillaCall::AutoCGetImageScale() {
+	return static_cast<int>(Call(Message::AutoCGetImageScale));
+}
+
 void ScintillaCall::SetIndent(int indentSize) {
 	Call(Message::SetIndent, indentSize);
 }
@@ -1367,6 +1375,10 @@ void ScintillaCall::LineScroll(Position columns, Line lines) {
 	Call(Message::LineScroll, columns, lines);
 }
 
+void ScintillaCall::ScrollVertical(Line docLine, Line subLine) {
+	Call(Message::ScrollVertical, docLine, subLine);
+}
+
 void ScintillaCall::ScrollCaret() {
 	Call(Message::ScrollCaret);
 }
@@ -2819,8 +2831,8 @@ int ScintillaCall::ExtraDescent() {
 	return static_cast<int>(Call(Message::GetExtraDescent));
 }
 
-int ScintillaCall::MarkerSymbolDefined(int markerNumber) {
-	return static_cast<int>(Call(Message::MarkerSymbolDefined, markerNumber));
+MarkerSymbol ScintillaCall::MarkerSymbolDefined(int markerNumber) {
+	return static_cast<Scintilla::MarkerSymbol>(Call(Message::MarkerSymbolDefined, markerNumber));
 }
 
 void ScintillaCall::MarginSetText(Line line, const char *text) {
diff --git a/src/scintilla/cocoa/Scintilla/Info.plist b/src/scintilla/cocoa/Scintilla/Info.plist
index d78450e75..f5ce998da 100644
--- a/src/scintilla/cocoa/Scintilla/Info.plist
+++ b/src/scintilla/cocoa/Scintilla/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>5.5.5</string>
+	<string>5.5.7</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
diff --git a/src/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj b/src/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
index 1edacf787..00b77029b 100644
--- a/src/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
+++ b/src/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
@@ -586,7 +586,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 5.5.5;
+				CURRENT_PROJECT_VERSION = 5.5.7;
 				DEAD_CODE_STRIPPING = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
@@ -650,7 +650,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 5.5.5;
+				CURRENT_PROJECT_VERSION = 5.5.7;
 				DEAD_CODE_STRIPPING = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_NS_ASSERTIONS = NO;
@@ -682,7 +682,7 @@
 				CODE_SIGN_IDENTITY = "-";
 				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 5.5.5;
+				CURRENT_PROJECT_VERSION = 5.5.7;
 				DEAD_CODE_STRIPPING = YES;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
@@ -717,7 +717,7 @@
 				CODE_SIGN_IDENTITY = "-";
 				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 5.5.5;
+				CURRENT_PROJECT_VERSION = 5.5.7;
 				DEAD_CODE_STRIPPING = YES;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
diff --git a/src/scintilla/cocoa/ScintillaCocoa.mm b/src/scintilla/cocoa/ScintillaCocoa.mm
index b1e242cc9..8a9af4058 100644
--- a/src/scintilla/cocoa/ScintillaCocoa.mm
+++ b/src/scintilla/cocoa/ScintillaCocoa.mm
@@ -1951,6 +1951,7 @@ - (void) pasteboard: (NSPasteboard *) pasteboard item: (NSPasteboardItem *) item
  * Modifies the vertical scroll position to make the current top line show up as such.
  */
 void ScintillaCocoa::SetVerticalScrollPos() {
+	Editor::SetVerticalScrollPos();
 	NSScrollView *scrollView = ScrollContainer();
 	if (scrollView) {
 		NSClipView *clipView = scrollView.contentView;
diff --git a/src/scintilla/doc/ScintillaDoc.html b/src/scintilla/doc/ScintillaDoc.html
index e36c2059d..a2af4f64f 100644
--- a/src/scintilla/doc/ScintillaDoc.html
+++ b/src/scintilla/doc/ScintillaDoc.html
@@ -130,7 +130,7 @@
 
     <h1>Scintilla Documentation</h1>
 
-    <p>Last edited 12 February 2025 NH</p>
+    <p>Last edited 29 May 2025 NH</p>
 
     <p style="background:#90F0C0">Scintilla 5 has moved the lexers from Scintilla into a new
     <a href="Lexilla.html">Lexilla</a> project.<br />
@@ -151,6 +151,8 @@ <h1>Scintilla Documentation</h1>
     discussion of folding</a>.<br />
      <a class="jump" href="https://github.com/geany/geany/files/5204338/Scintilla-var.aq-Tutorial.pdf">
      Beginner's Guide to lexing and folding</a>.<br />
+     <a class="jump" href="https://www.youtube.com/watch?v=M07iGUA07rY">
+     Video on writing a lexer with wxStyledTextCtrl</a>.<br />
      The <a class="jump" href="SciCoding.html">coding style</a> used in Scintilla and SciTE is
     worth following if you want to contribute code to Scintilla but is not compulsory.</p>
 
@@ -1324,6 +1326,35 @@ <h2 id="MultipleSelectionAndVirtualSpace">Multiple Selection and Virtual Space</
      This is most commonly desired in conjunction with virtual space but is an independent
      setting so works without virtual space.</p>
 
+    <table class="standard" summary="Virtual space options">
+      <tbody valign="top">
+        <tr>
+          <th align="left"><code>SCVS_NONE</code></th>
+          <td>0</td>
+          <td>The default: no virtual space.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SCVS_RECTANGULARSELECTION</code></th>
+          <td>1</td>
+          <td>Virtual space is enabled for rectangular selections.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SCVS_USERACCESSIBLE</code></th>
+          <td>2</td>
+          <td>Virtual space is enabled for user actions such as right arrow key or clicking beyond line end.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SCVS_NOWRAPLINESTART</code></th>
+          <td>4</td>
+          <td>Left arrow does not wrap to the previous line.</td>
+        </tr>
+
+      </tbody>
+    </table>
+
     <p>
     <b id="SCI_SETRECTANGULARSELECTIONMODIFIER">SCI_SETRECTANGULARSELECTIONMODIFIER(int modifier)</b><br />
     <b id="SCI_GETRECTANGULARSELECTIONMODIFIER">SCI_GETRECTANGULARSELECTIONMODIFIER &rarr; int</b><br />
@@ -2054,6 +2085,14 @@ <h2 id="UndoAndRedo">Undo and Redo</h2>
           <td>Restore selection for each undo and redo.</td>
         </tr>
 
+        <tr>
+          <th align="left"><code>SC_UNDO_SELECTION_HISTORY_SCROLL</code></th>
+
+          <td>2</td>
+
+          <td>Restore vertical scroll position. Has no effect without <code>SC_UNDO_SELECTION_HISTORY_ENABLED</code>.</td>
+        </tr>
+
       </tbody>
     </table>
 
@@ -2358,6 +2397,7 @@ <h2 id="ScrollingAndAutomaticScrolling">Scrolling and automatic scrolling</h2>
      <a class="message" href="#SCI_GETFIRSTVISIBLELINE">SCI_GETFIRSTVISIBLELINE &rarr; line</a><br />
      <a class="message" href="#SCI_SETXOFFSET">SCI_SETXOFFSET(int xOffset)</a><br />
      <a class="message" href="#SCI_GETXOFFSET">SCI_GETXOFFSET &rarr; int</a><br />
+     <a class="message" href="#SCI_SCROLLVERTICAL">SCI_SCROLLVERTICAL(line docLine, line subLine)</a><br />
      <a class="message" href="#SCI_LINESCROLL">SCI_LINESCROLL(position columns, line lines)</a><br />
      <a class="message" href="#SCI_SCROLLCARET">SCI_SCROLLCARET</a><br />
      <a class="message" href="#SCI_SCROLLRANGE">SCI_SCROLLRANGE(position secondary, position primary)</a><br />
@@ -2391,6 +2431,26 @@ <h2 id="ScrollingAndAutomaticScrolling">Scrolling and automatic scrolling</h2>
     view. A value of 0 is the normal position with the first text column visible at the left of the
     view.</p>
 
+    <p><b id="SCI_SCROLLVERTICAL">SCI_SCROLLVERTICAL(line docLine, line subLine)</b><br />
+     Sets the vertical scroll position to be the display line for the
+     <code class="parameter">subLine</code> of the <code class="parameter">docLine</code>, similar to<br>
+     <code>SCI_SETFIRSTVISIBLELINE(SCI_VISIBLEFROMDOCLINE(docLine) + subLine)</code>.</p>
+
+     <p>The <code class="parameter">subLine</code> is capped to the maximum number of sublines
+     for that document line which may change because of styling and wrapping. It is ignored when line
+     wrapping is off.</p>
+
+     <p>If line wrapping is on, then that
+     <code class="parameter">docLine</code>/<code class="parameter">subLine</code>
+     is remembered and reapplied as lines are wrapped.
+     This ensures that when wrapping is completed, which may take some time, the line at the top of the view is that
+     requested by the application and the view range is stable during the wrapping process.
+     It is forgotten once the document is fully wrapped or the user
+     performs scrolling manually such as by dragging the scroll bar.</p>
+
+     <p>This method is a good way for applications to restore the user's positional context when re-selecting a
+     document as it is robust to changes in window width and styles.</p>
+
     <p><b id="SCI_LINESCROLL">SCI_LINESCROLL(position columns, line lines)</b><br />
      This will attempt to scroll the display by the number of columns and lines that you specify.
     Positive line values increase the line number at the top of the screen (i.e. they move the text
@@ -3583,117 +3643,140 @@ <h2 id="StyleDefinition">Style definition</h2>
 <table class="standard" summary="Character Sets supported"><tbody>
   <tr>
     <th>Character Set</th>
+    <th>Value</th>
     <th>Windows</th>
     <th>GTK</th>
     <th>Cocoa</th></tr></tbody>
   <tbody>
-  <tr>
-    <td><code>SC_CHARSET_ANSI</code></td>
+  <tr class="section">
+    <th align="left"><code>SC_CHARSET_ANSI</code></th>
+    <td>0</td>
     <td>&check;</td>
     <td>&check;</td>
     <td>&check; (8859-1)</td></tr>
    <tr>
-    <td><code>SC_CHARSET_ARABIC</code></td>
+    <th align="left"><code>SC_CHARSET_ARABIC</code></th>
+    <td>178</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_BALTIC</code></td>
+    <th align="left"><code>SC_CHARSET_BALTIC</code></th>
+    <td>186</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_CHINESEBIG5</code></td>
+    <th align="left"><code>SC_CHARSET_CHINESEBIG5</code></th>
+    <td>136</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_DEFAULT</code></td>
+    <th align="left"><code>SC_CHARSET_DEFAULT</code></th>
+    <td>1</td>
     <td>&check;</td>
     <td>&check; (8859-1)</td>
     <td>&check; (8859-1)</td></tr>
    <tr>
-    <td><code>SC_CHARSET_EASTEUROPE</code></td>
+    <th align="left"><code>SC_CHARSET_EASTEUROPE</code></th>
+    <td>238</td>
     <td>&check;</td>
     <td>&check;</td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_GB2312</code></td>
+    <th align="left"><code>SC_CHARSET_GB2312</code></th>
+    <td>134</td>
     <td>&check;</td>
     <td>&check;</td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_GREEK</code></td>
+    <th align="left"><code>SC_CHARSET_GREEK</code></th>
+    <td>161</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_HANGUL</code></td>
+    <th align="left"><code>SC_CHARSET_HANGUL</code></th>
+    <td>129</td>
     <td>&check;</td>
     <td>&check;</td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_HEBREW</code></td>
+    <th align="left"><code>SC_CHARSET_HEBREW</code></th>
+    <td>177</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_JOHAB</code></td>
+    <th align="left"><code>SC_CHARSET_JOHAB</code></th>
+    <td>130</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_MAC</code></td>
+    <th align="left"><code>SC_CHARSET_MAC</code></th>
+    <td>77</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_OEM</code></td>
+    <th align="left"><code>SC_CHARSET_OEM</code></th>
+    <td>255</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_RUSSIAN</code></td>
+    <th align="left"><code>SC_CHARSET_RUSSIAN</code></th>
+    <td>204</td>
     <td>&check; (cp1251)</td>
     <td>&check; (koi8-r)</td>
     <td>&check; (cp1251)</td></tr>
    <tr>
-    <td><code>SC_CHARSET_SHIFTJIS</code></td>
+    <th align="left"><code>SC_CHARSET_SHIFTJIS</code></th>
+    <td>128</td>
     <td>&check;</td>
     <td>&check;</td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_SYMBOL</code></td>
+    <th align="left"><code>SC_CHARSET_SYMBOL</code></th>
+    <td>2</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_THAI</code></td>
+    <th align="left"><code>SC_CHARSET_THAI</code></th>
+    <td>222</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_TURKISH</code></td>
+    <th align="left"><code>SC_CHARSET_TURKISH</code></th>
+    <td>162</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_VIETNAMESE</code></td>
+    <th align="left"><code>SC_CHARSET_VIETNAMESE</code></th>
+    <td>163</td>
     <td>&check;</td>
     <td></td>
     <td>&check;</td></tr>
    <tr>
-    <td><code>SC_CHARSET_OEM866</code></td>
+    <th align="left"><code>SC_CHARSET_OEM866</code></th>
+    <td>866</td>
     <td></td>
     <td>&check; (cp866)</td>
     <td></td></tr>
    <tr>
-    <td><code>SC_CHARSET_CYRILLIC</code></td>
+    <th align="left"><code>SC_CHARSET_CYRILLIC</code></th>
+    <td>1251</td>
     <td></td>
     <td>&check; (cp1251)</td>
     <td>&check; (cp1251)</td></tr>
    <tr>
-    <td><code>SC_CHARSET_8859_15</code></td>
+    <th align="left"><code>SC_CHARSET_8859_15</code></th>
+    <td>1000</td>
     <td></td>
     <td>&check;</td>
     <td>&check;</td></tr>
@@ -4516,8 +4599,8 @@ <h2 id="Margins">Margins</h2>
     <p>Using a margin number outside the valid range has no
     effect. By default, margin 0 is set to display line numbers, but is given a width of 0, so it
     is hidden. Margin 1 is set to display non-folding symbols and is given a width of 16 pixels, so
-    it is visible. Margin 2 is set to display the folding symbols, but is given a width of 0, so it
-    is hidden. Of course, you can set the margins to be whatever you wish.</p>
+    it is visible. Margin 2 is a symbol margin that is given a width of 0, so it is hidden.
+    Of course, you can set the margins to be whatever you wish.</p>
 
     <p>Styled text margins used to show revision and blame information:</p>
     <p><img src="styledmargin.png" alt="Styled text margins used to show revision and blame information" /></p>
@@ -4960,6 +5043,8 @@ <h2 id="EndOfLineAnnotations">End of Line Annotations</h2>
     </table>
 
     <p>Different shapes available for EOL annotations.
+    Different shapes depend on drawing API so <code>SC_TECHNOLOGY_DEFAULT</code> on Win32
+    only draws a rectangle.
     Only one shape can currently be used for the whole document - this illustration was produced by trickery.</p>
     <p><img src="StadiumVariants.png" alt="Different shapes available for EOL annotations" /></p>
 
@@ -5196,7 +5281,7 @@ <h2 id="OtherSettings">Other settings</h2>
        </tr>
       </tbody>
     </table>
-    <p></p>
+    <br />
 
     <table class="standard" summary="IME interaction">
       <caption>IME interaction support</caption>
@@ -6450,6 +6535,8 @@ <h2 id="Autocompletion">Autocompletion</h2>
      <a class="message" href="#SCI_AUTOCGETMAXWIDTH">SCI_AUTOCGETMAXWIDTH &rarr; int</a><br />
      <a class="message" href="#SCI_AUTOCSETSTYLE">SCI_AUTOCSETSTYLE(int style)</a><br />
      <a class="message" href="#SCI_AUTOCGETSTYLE">SCI_AUTOCGETSTYLE &rarr; int</a><br />
+     <a class="message" href="#SCI_AUTOCSETIMAGESCALE">SCI_AUTOCSETIMAGESCALE(int scale)</a><br />
+     <a class="message" href="#SCI_AUTOCGETIMAGESCALE">SCI_AUTOCGETIMAGESCALE &rarr; int</a><br />
      <a class="element" href="#SC_ELEMENT_LIST">SC_ELEMENT_LIST : colouralpha</a><br />
      <a class="element" href="#SC_ELEMENT_LIST_BACK">SC_ELEMENT_LIST_BACK : colouralpha</a><br />
      <a class="element" href="#SC_ELEMENT_LIST_SELECTED">SC_ELEMENT_LIST_SELECTED : colouralpha</a><br />
@@ -6681,6 +6768,16 @@ <h2 id="Autocompletion">Autocompletion</h2>
       result as the argument to <code>SCI_AUTOCSETSTYLE</code> and <code>SCI_STYLESETFONT</code> and others.
     </p>
 
+    <p>
+      <b id="SCI_AUTOCSETIMAGESCALE">SCI_AUTOCSETIMAGESCALE(int scalePercent)</b><br />
+      <b id="SCI_AUTOCGETIMAGESCALE">SCI_AUTOCGETIMAGESCALE &rarr; int</b><br />
+
+      Get or set the scale factor in percent for <em>all</em> autocompletion list images. This is useful on macOS with
+      a retina display where each display unit is 2 pixels: use a factor of 200 so that each image pixel is displayed using a screen pixel.
+      The default scale, 100, will stretch each image pixel to cover 4 screen pixels on a retina display.
+    </p>
+    <p>This is currently only implemented for the Qt and GTK platforms.</p>
+
     <p>
      <b id="SC_ELEMENT_LIST">SC_ELEMENT_LIST : colouralpha</b><br />
      <b id="SC_ELEMENT_LIST_BACK">SC_ELEMENT_LIST_BACK : colouralpha</b><br />
@@ -9043,21 +9140,24 @@ <h2 id="Notifications">Notifications</h2>
 	Sci_Position position;
 	/* SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_MARGINCLICK, */
 	/* SCN_MARGINRIGHTCLICK, SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, */
-	/* SCN_CALLTIPCLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
-	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
-	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTION, SCN_AUTOCSELECTIONCHANGE */
+	/* SCN_CALLTIPCLICK, */
+	/* SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, SCN_HOTSPOTRELEASECLICK, */
+	/* SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
+	/* SCN_USERLISTSELECTION, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
+	/* SCN_AUTOCSELECTIONCHANGE */
 
 	int ch;
-	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETE, SCN_AUTOCSELECTION, */
+	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
 	/* SCN_USERLISTSELECTION */
 	int modifiers;
 	/* SCN_KEY, SCN_DOUBLECLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
 	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
+	/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
 
 	int modificationType;	/* SCN_MODIFIED */
 	const char *text;
-	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION, SCN_URIDROPPED, */
-	/* SCN_AUTOCSELECTIONCHANGE */
+	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_URIDROPPED, */
+	/* SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, SCN_AUTOCSELECTIONCHANGE */
 
 	Sci_Position length;		/* SCN_MODIFIED */
 	Sci_Position linesAdded;	/* SCN_MODIFIED */
diff --git a/src/scintilla/doc/ScintillaDownload.html b/src/scintilla/doc/ScintillaDownload.html
index cebfd5cca..8d142b0ff 100644
--- a/src/scintilla/doc/ScintillaDownload.html
+++ b/src/scintilla/doc/ScintillaDownload.html
@@ -26,9 +26,9 @@
     <table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
       <tr>
         <td>
-          <font size="4"> <a href="https://www.scintilla.org/scintilla555.zip">
+          <font size="4"> <a href="https://www.scintilla.org/scintilla557.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/scintilla555.tgz">
+	<a href="https://www.scintilla.org/scintilla557.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@ <h2>
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.5.5
+       Release 5.5.7
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@ <h4>
        The source code package contains all of the source code for Scintilla but no binary
 	executable code and is available in
        <ul>
-       <li><a href="https://www.scintilla.org/scintilla555.zip">zip format</a> (1.8M) commonly used on Windows</li>
-       <li><a href="https://www.scintilla.org/scintilla555.tgz">tgz format</a> (1.7M) commonly used on Linux and compatible operating systems</li>
+       <li><a href="https://www.scintilla.org/scintilla557.zip">zip format</a> (1.8M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/scintilla557.tgz">tgz format</a> (1.7M) commonly used on Linux and compatible operating systems</li>
        </ul>
        Instructions for building on both Windows and Linux are included in the readme file.
     <h4>
diff --git a/src/scintilla/doc/ScintillaHistory.html b/src/scintilla/doc/ScintillaHistory.html
index 8a861a82f..5f0901b7a 100644
--- a/src/scintilla/doc/ScintillaHistory.html
+++ b/src/scintilla/doc/ScintillaHistory.html
@@ -585,9 +585,99 @@ <h2>Contributors</h2>
 	<td>Martijn Laan</td>
       </tr><tr>
 	<td>Pawel Z Wronek</td>
+	<td>Joachim Mairboeck</td>
+	<td>Gianluca Vaccari</td>
+	<td>8day</td>
+      </tr><tr>
+	<td>Ahmet Sait</td>
     </tr>
     </table>
     <h2 id="Releases">Releases</h2>
+    <h3>
+       <a href="https://www.scintilla.org/scintilla557.zip">Release 5.5.7</a>
+    </h3>
+    <ul>
+	<li>
+	Released 8 June 2025.
+	</li>
+	<li>
+	Add SCI_SCROLLVERTICAL method to restore view position and maintain it while performing line wrapping.
+	</li>
+	<li>
+	Add SC_UNDO_SELECTION_HISTORY_SCROLL flag to SCI_SETUNDOSELECTIONHISTORY which controls
+	whether undo and redo restore vertical scroll position.
+	</li>
+	<li>
+	Tweak SC_MARK_BAR to be slightly wider by using next higher whole pixel instead of next lower for margin width / 3.
+	</li>
+	<li>
+	Scale images in autocompletion lists with SCI_AUTOCSETIMAGESCALE to match high DPI screens.
+	Initially only on GTK and Qt.
+	</li>
+	<li>
+	Fix wrapping bug for UTF-8 where \r\n could wrap between the characters.
+	<a href="https://github.com/notepad-plus-plus/notepad-plus-plus/pull/16373">Notepad++ Pull Request #16373</a>.
+	</li>
+	<li>
+	Fix crash during painting when scroll bars changed.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2481/">Bug #2481</a>.
+	</li>
+	<li>
+	On GTK, reset vertical scroll bar synchronously in SCI_SETDOCPOINTER to fix bug where
+	scroll position not restored in non-wrap mode.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2416/">Bug #2416</a>.
+	</li>
+	<li>
+	On GTK, fix IME problem when tentative composition interfered with delete surrounding.
+	<a href="https://sourceforge.net/p/scintilla/feature-requests/1476/">Feature #1476</a>.
+	</li>
+	<li>
+	On GTK, update IME cursor position inside retrieve surrounding to better position candidate window.
+	<a href="https://sourceforge.net/p/scintilla/feature-requests/1488/">Feature #1488</a>.
+	</li>
+    </ul>
+    <h3>
+       <a href="https://www.scintilla.org/scintilla556.zip">Release 5.5.6</a>
+    </h3>
+    <ul>
+	<li>
+	Released 2 April 2025.
+	</li>
+	<li>
+	Disallow changing case of protected text.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2463/">Bug #2463</a>.
+	</li>
+	<li>
+	Return enumeration type from MarkerSymbolDefined to match MarkerDefine.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2469/">Bug #2469</a>.
+	</li>
+	<li>
+	On Win32, use DirectWrite for autocompletion lists when DirectWrite chosen for document text.
+	</li>
+	<li>
+	On Win32, optimize case-insensitive DBCS search to be around 5 times faster
+	by using 64K memory to cache folding data for each DBCS code page used.
+	</li>
+	<li>
+	On Win32, fix a crash with bidirectional text.
+	</li>
+	<li>
+	When using Visual C++ through nmake, fix building for ARM64.
+	<a href="https://sourceforge.net/p/scintilla/feature-requests/1546/">Feature #1546</a>.
+	</li>
+	<li>
+	On Qt, draw clipped UTF-8 text correctly.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2464/">Bug #2464</a>.
+	</li>
+	<li>
+	On Qt, avoid a dwell start when the mouse is moved outside the Scintilla widget.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2466/">Bug #2466</a>.
+	</li>
+	<li>
+	On Qt, autoCompleteSelection converts from local encoding when not in Unicode mode.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2465/">Bug #2465</a>.
+	</li>
+    </ul>
     <h3>
        <a href="https://www.scintilla.org/scintilla555.zip">Release 5.5.5</a>
     </h3>
diff --git a/src/scintilla/doc/ScintillaUsage.html b/src/scintilla/doc/ScintillaUsage.html
index 47db0be28..3025a0c01 100644
--- a/src/scintilla/doc/ScintillaUsage.html
+++ b/src/scintilla/doc/ScintillaUsage.html
@@ -10,6 +10,7 @@
     <title>
       Scintilla Usage Notes
     </title>
+    <link rel="canonical" href="https://scintilla.org/ScintillaUsage.html" />
 <style type="text/css">
 SPAN {
     font-family: Verdana, Arial, Helvetica;
diff --git a/src/scintilla/doc/index.html b/src/scintilla/doc/index.html
index f635836d4..aed89ac40 100644
--- a/src/scintilla/doc/index.html
+++ b/src/scintilla/doc/index.html
@@ -9,7 +9,7 @@
     <meta name="keywords" content="Scintilla, SciTE, Editing Component, Text Editor" />
     <meta name="Description"
     content="www.scintilla.org is the home of the Scintilla editing component and SciTE text editor application." />
-    <meta name="Date.Modified" content="20250225" />
+    <meta name="Date.Modified" content="20250608" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <style type="text/css">
         .logo {
@@ -61,8 +61,8 @@
           GTK, and macOS</font>
         </td>
         <td width="40%" align="right">
-          <font color="#FFCC99" size="3"> Release version 5.5.5<br />
-           Site last modified February 25 2025</font>
+          <font color="#FFCC99" size="3"> Release version 5.5.7<br />
+           Site last modified June 8 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +77,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.5.7 can prevent storing scroll position in undo selection history and adds a wrap-aware SCI_SCROLLVERTICAL API.</li>
+      <li>Version 5.5.6 improves DBCS and autocompletion drawing on Win32 and improves dwell, encoding and text clipping on Qt.</li>
       <li>Version 5.5.5 can remember selection with undo and redo. Update to use DirectWrite 1.1.</li>
       <li>Version 5.5.4 fixes wrapping of removed lines and edge cases for moving lines. On GTK, middle click can be repeated with one value.</li>
       <li>Version 5.5.3 fixes horizontal scrolling with a touchpad on Win32.</li>
-      <li>Version 5.5.2 adds multiple selection copy with separator, a font stretch setting, and access to whether an undo sequence is active.</li>
-      <li>Version 5.5.1 adds SCI_CUTALLOWLINE and fixes a Win32 bug that caused the cursor to flicker.</li>
     </ul>
     <ul id="menu">
       <li id="remote1"><a href="https://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
diff --git a/src/scintilla/gtk/PlatGTK.cxx b/src/scintilla/gtk/PlatGTK.cxx
index 67b7f7052..c7bcbb772 100644
--- a/src/scintilla/gtk/PlatGTK.cxx
+++ b/src/scintilla/gtk/PlatGTK.cxx
@@ -27,6 +27,9 @@
 #if defined(GDK_WINDOWING_WAYLAND)
 #include <gdk/gdkwayland.h>
 #endif
+#if GTK_CHECK_VERSION(3, 10, 0)
+#include <cairo/cairo-gobject.h>
+#endif
 
 #include "ScintillaTypes.h"
 #include "ScintillaMessages.h"
@@ -1432,6 +1435,7 @@ class ListBoxX : public ListBox {
 #if GTK_CHECK_VERSION(3,0,0)
 	std::unique_ptr<GtkCssProvider, GObjectReleaser> cssProvider;
 #endif
+	float imageScale;
 public:
 	IListBoxDelegate *delegate;
 
@@ -1439,7 +1443,7 @@ class ListBoxX : public ListBox {
 		pixhash(nullptr), pixbuf_renderer(nullptr),
 		renderer(nullptr),
 		desiredVisibleRows(5), maxItemCharacters(0),
-		aveCharWidth(1),
+		aveCharWidth(1), imageScale(1.0),
 		delegate(nullptr) {
 	}
 	// Deleted so ListBoxX objects can not be copied.
@@ -1673,7 +1677,13 @@ void ListBoxX::Create(Window &parent, int, Point, int, bool, Technology) {
 
 	/* Tree and its model */
 	GtkListStore *store =
-		gtk_list_store_new(N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING);
+		gtk_list_store_new(N_COLUMNS,
+#if GTK_CHECK_VERSION(3, 10, 0)
+		CAIRO_GOBJECT_TYPE_SURFACE,
+#else
+		GDK_TYPE_PIXBUF,
+#endif
+		G_TYPE_STRING);
 
 	list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 	g_signal_connect(G_OBJECT(list), "style-set", G_CALLBACK(StyleSet), nullptr);
@@ -1701,7 +1711,13 @@ void ListBoxX::Create(Window &parent, int, Point, int, bool, Technology) {
 	gtk_cell_renderer_set_fixed_size(pixbuf_renderer, 0, -1);
 	gtk_tree_view_column_pack_start(column, pixbuf_renderer, FALSE);
 	gtk_tree_view_column_add_attribute(column, pixbuf_renderer,
-					   "pixbuf", PIXBUF_COLUMN);
+#if GTK_CHECK_VERSION(3, 10, 0)
+					   "surface",
+#else
+					   "pixbuf",
+#endif
+					   PIXBUF_COLUMN);
+
 
 	renderer = gtk_cell_renderer_text_new();
 	gtk_cell_renderer_text_set_fixed_height_from_font(GTK_CELL_RENDERER_TEXT(renderer), 1);
@@ -1915,11 +1931,20 @@ void ListBoxX::Append(char *s, int type) {
 		if (nullptr == list_image->pixbuf)
 			init_pixmap(list_image);
 		if (list_image->pixbuf) {
+#if GTK_CHECK_VERSION(3, 10, 0)
+			cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(list_image->pixbuf, imageScale, nullptr);
+			gtk_list_store_set(GTK_LIST_STORE(store), &iter,
+					   PIXBUF_COLUMN, surface,
+					   TEXT_COLUMN, s, -1);
+
+			const gint pixbuf_width = gdk_pixbuf_get_width(list_image->pixbuf) / imageScale;
+#else
 			gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 					   PIXBUF_COLUMN, list_image->pixbuf,
 					   TEXT_COLUMN, s, -1);
 
 			const gint pixbuf_width = gdk_pixbuf_get_width(list_image->pixbuf);
+#endif
 			gint renderer_height, renderer_width;
 			gtk_cell_renderer_get_fixed_size(pixbuf_renderer,
 							 &renderer_width, &renderer_height);
@@ -2125,7 +2150,8 @@ void ListBoxX::SetList(const char *listText, char separator, char typesep) {
 	}
 }
 
-void ListBoxX::SetOptions(ListOptions) {
+void ListBoxX::SetOptions(ListOptions options_) {
+	imageScale = options_.imageScale;
 }
 
 Menu::Menu() noexcept : mid(nullptr) {}
diff --git a/src/scintilla/gtk/ScintillaGTK.cxx b/src/scintilla/gtk/ScintillaGTK.cxx
index 38e0d0376..686a8c13f 100644
--- a/src/scintilla/gtk/ScintillaGTK.cxx
+++ b/src/scintilla/gtk/ScintillaGTK.cxx
@@ -1102,6 +1102,7 @@ void ScintillaGTK::ScrollText(Sci::Line linesToMove) {
 }
 
 void ScintillaGTK::SetVerticalScrollPos() {
+	Editor::SetVerticalScrollPos();
 	DwellEnd(true);
 	gtk_adjustment_set_value(GTK_ADJUSTMENT(adjustmentv), static_cast<gdouble>(topLine));
 }
@@ -2375,29 +2376,6 @@ bool ScintillaGTK::KoreanIME() {
 	return lastNonCommonScript == G_UNICODE_SCRIPT_HANGUL;
 }
 
-void ScintillaGTK::MoveImeCarets(Sci::Position pos) {
-	// Move carets relatively by bytes
-	for (size_t r=0; r<sel.Count(); r++) {
-		const Sci::Position positionInsert = sel.Range(r).Start().Position();
-		sel.Range(r) = SelectionRange(positionInsert + pos);
-	}
-}
-
-void ScintillaGTK::DrawImeIndicator(int indicator, Sci::Position len) {
-	// Emulate the visual style of IME characters with indicators.
-	// Draw an indicator on the character before caret by the character bytes of len
-	// so it should be called after InsertCharacter().
-	// It does not affect caret positions.
-	if (indicator < 8 || indicator > INDICATOR_MAX) {
-		return;
-	}
-	pdoc->DecorationSetCurrentIndicator(indicator);
-	for (size_t r=0; r<sel.Count(); r++) {
-		const Sci::Position positionInsert = sel.Range(r).Start().Position();
-		pdoc->DecorationFillRange(positionInsert - len, 1, len);
-	}
-}
-
 namespace {
 
 std::vector<int> MapImeIndicators(PangoAttrList *attrs, const char *u8Str) {
@@ -2624,24 +2602,16 @@ bool ScintillaGTK::RetrieveSurroundingThis(GtkIMContext *context) {
 		const Sci::Position startByte = pdoc->LineStart(line);
 		const Sci::Position endByte = pdoc->LineEnd(line);
 
-		std::string utf8Text;
-		gint cursorIndex; // index of the cursor inside utf8Text, in bytes
-		const char *charSetBuffer;
+		std::string utf8Text = UTF8FromEncoded(RangeText(startByte, endByte));
+		gint cursorIndex = UTF8FromEncoded(RangeText(startByte, pos)).length();
 
-		if (IsUnicodeMode() || ! *(charSetBuffer = CharacterSetID())) {
-			utf8Text = RangeText(startByte, endByte);
-			cursorIndex = pos - startByte;
+		if (pdoc->TentativeActive()) {
+			// Prepare one line feed with no preedit under PreeditChangedInlineThis();
 		} else {
-			// Need to convert
-			std::string tmpbuf = RangeText(startByte, pos);
-			utf8Text = ConvertText(&tmpbuf[0], tmpbuf.length(), "UTF-8", charSetBuffer, false);
-			cursorIndex = utf8Text.length();
-			if (endByte > pos) {
-				tmpbuf = RangeText(pos, endByte);
-				utf8Text += ConvertText(&tmpbuf[0], tmpbuf.length(), "UTF-8", charSetBuffer, false);
-			}
+			// reconvert key triggers CandidateBox to show up
+			// when quick phrase input on fcitx (or maybe accented input on mac)
+			SetCandidateWindowPos();
 		}
-
 		gtk_im_context_set_surrounding(context, &utf8Text[0], utf8Text.length(), cursorIndex);
 
 		return true;
@@ -2657,6 +2627,10 @@ gboolean ScintillaGTK::RetrieveSurrounding(GtkIMContext *context, ScintillaGTK *
 
 bool ScintillaGTK::DeleteSurroundingThis(GtkIMContext *, gint characterOffset, gint characterCount) {
 	try {
+		if (pdoc->TentativeActive()) {
+			// First remove composition text so that correct surrounding text is deleted.
+			pdoc->TentativeUndo();
+		}
 		const Sci::Position startByte = pdoc->GetRelativePosition(CurrentPosition(), characterOffset);
 		if (startByte == INVALID_POSITION)
 			return false;
@@ -3120,6 +3094,8 @@ void ScintillaGTK::SetDocPointer(Document *document) {
 
 	Editor::SetDocPointer(document);
 
+	ChangeScrollBars();
+
 	if (sciAccessible) {
 		// the accessible needs have the old Document, but also the new one active
 		sciAccessible->ChangeDocument(oldDoc, pdoc);
diff --git a/src/scintilla/gtk/ScintillaGTK.h b/src/scintilla/gtk/ScintillaGTK.h
index 126072856..5f73d8174 100644
--- a/src/scintilla/gtk/ScintillaGTK.h
+++ b/src/scintilla/gtk/ScintillaGTK.h
@@ -243,8 +243,6 @@ class ScintillaGTK : public ScintillaBase {
 	bool DeleteSurroundingThis(GtkIMContext *context, gint characterOffset, gint characterCount);
 	static gboolean DeleteSurrounding(GtkIMContext *context, gint characterOffset, gint characterCount,
 					  ScintillaGTK *sciThis);
-	void MoveImeCarets(Sci::Position pos);
-	void DrawImeIndicator(int indicator, Sci::Position len);
 	void SetCandidateWindowPos();
 
 	static void StyleSetText(GtkWidget *widget, GtkStyle *previous, void *);
diff --git a/src/scintilla/include/Scintilla.h b/src/scintilla/include/Scintilla.h
index c976af1ea..f7afa4f50 100644
--- a/src/scintilla/include/Scintilla.h
+++ b/src/scintilla/include/Scintilla.h
@@ -475,6 +475,8 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP
 #define SCI_AUTOCGETMAXHEIGHT 2211
 #define SCI_AUTOCSETSTYLE 2109
 #define SCI_AUTOCGETSTYLE 2120
+#define SCI_AUTOCSETIMAGESCALE 2815
+#define SCI_AUTOCGETIMAGESCALE 2816
 #define SCI_SETINDENT 2122
 #define SCI_GETINDENT 2123
 #define SCI_SETUSETABS 2124
@@ -534,6 +536,7 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP
 #define SCI_GETCHANGEHISTORY 2781
 #define SC_UNDO_SELECTION_HISTORY_DISABLED 0
 #define SC_UNDO_SELECTION_HISTORY_ENABLED 1
+#define SC_UNDO_SELECTION_HISTORY_SCROLL 2
 #define SCI_SETUNDOSELECTIONHISTORY 2782
 #define SCI_GETUNDOSELECTIONHISTORY 2783
 #define SCI_SETSELECTIONSERIALIZED 2784
@@ -558,6 +561,7 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP
 #define SCI_LINEFROMPOSITION 2166
 #define SCI_POSITIONFROMLINE 2167
 #define SCI_LINESCROLL 2168
+#define SCI_SCROLLVERTICAL 2817
 #define SCI_SCROLLCARET 2169
 #define SCI_SCROLLRANGE 2569
 #define SCI_REPLACESEL 2170
@@ -1419,10 +1423,12 @@ struct SCNotification {
 	Sci_NotifyHeader nmhdr;
 	Sci_Position position;
 	/* SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_MARGINCLICK, */
-	/* SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, SCN_CALLTIPCLICK, */
+	/* SCN_MARGINRIGHTCLICK, SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, */
+	/* SCN_CALLTIPCLICK, */
 	/* SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, SCN_HOTSPOTRELEASECLICK, */
 	/* SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
-	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTION */
+	/* SCN_USERLISTSELECTION, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
+	/* SCN_AUTOCSELECTIONCHANGE */
 
 	int ch;
 	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
@@ -1430,10 +1436,12 @@ struct SCNotification {
 	int modifiers;
 	/* SCN_KEY, SCN_DOUBLECLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
 	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
+	/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
 
 	int modificationType;	/* SCN_MODIFIED */
 	const char *text;
-	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION, SCN_URIDROPPED */
+	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_URIDROPPED, */
+	/* SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, SCN_AUTOCSELECTIONCHANGE */
 
 	Sci_Position length;		/* SCN_MODIFIED */
 	Sci_Position linesAdded;	/* SCN_MODIFIED */
@@ -1443,15 +1451,15 @@ struct SCNotification {
 	Sci_Position line;		/* SCN_MODIFIED */
 	int foldLevelNow;	/* SCN_MODIFIED */
 	int foldLevelPrev;	/* SCN_MODIFIED */
-	int margin;		/* SCN_MARGINCLICK */
-	int listType;	/* SCN_USERLISTSELECTION */
+	int margin;		/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
+	int listType;	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTIONCHANGE */
 	int x;			/* SCN_DWELLSTART, SCN_DWELLEND */
 	int y;		/* SCN_DWELLSTART, SCN_DWELLEND */
 	int token;		/* SCN_MODIFIED with SC_MOD_CONTAINER */
 	Sci_Position annotationLinesAdded;	/* SCN_MODIFIED with SC_MOD_CHANGEANNOTATION */
 	int updated;	/* SCN_UPDATEUI */
 	int listCompletionMethod;
-	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION, */
+	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION */
 	int characterSource;	/* SCN_CHARADDED */
 };
 
diff --git a/src/scintilla/include/Scintilla.iface b/src/scintilla/include/Scintilla.iface
index f32148b69..9ba834aed 100644
--- a/src/scintilla/include/Scintilla.iface
+++ b/src/scintilla/include/Scintilla.iface
@@ -1174,6 +1174,12 @@ set void AutoCSetStyle=2109(int style,)
 # Get the style number used for auto-completion and user lists fonts.
 get int AutoCGetStyle=2120(,)
 
+# Set the scale factor in percent for auto-completion list images.
+set void AutoCSetImageScale=2815(int scalePercent,)
+
+# Get the scale factor in percent for auto-completion list images.
+get int AutoCGetImageScale=2816(,)
+
 # Set the number of spaces used for one level of indentation.
 set void SetIndent=2122(int indentSize,)
 
@@ -1337,6 +1343,7 @@ get ChangeHistoryOption GetChangeHistory=2781(,)
 enu UndoSelectionHistoryOption=SC_UNDO_SELECTION_HISTORY_
 val SC_UNDO_SELECTION_HISTORY_DISABLED=0
 val SC_UNDO_SELECTION_HISTORY_ENABLED=1
+val SC_UNDO_SELECTION_HISTORY_SCROLL=2
 
 # Enable or disable undo selection history.
 set void SetUndoSelectionHistory=2782(UndoSelectionHistoryOption undoSelectionHistory,)
@@ -1415,6 +1422,9 @@ fun position PositionFromLine=2167(line line,)
 # Scroll horizontally and vertically.
 fun void LineScroll=2168(position columns, line lines)
 
+# Scroll vertically with allowance for wrapping.
+fun void ScrollVertical=2817(line docLine, line subLine)
+
 # Ensure the caret is visible.
 fun void ScrollCaret=2169(,)
 
@@ -1565,7 +1575,7 @@ fun void CallTipCancel=2201(,)
 fun bool CallTipActive=2202(,)
 
 # Retrieve the position where the caret was before displaying the call tip.
-fun position CallTipPosStart=2203(,)
+get position CallTipPosStart=2203(,)
 
 # Set the start position in order to change when backspacing removes the calltip.
 set void CallTipSetPosStart=2214(position posStart,)
@@ -2755,7 +2765,7 @@ set void SetExtraDescent=2527(int extraDescent,)
 get int GetExtraDescent=2528(,)
 
 # Which symbol was defined for markerNumber with MarkerDefine
-fun int MarkerSymbolDefined=2529(int markerNumber,)
+fun MarkerSymbol MarkerSymbolDefined=2529(int markerNumber,)
 
 # Set the text in the text margin for a line
 set void MarginSetText=2530(line line, string text)
diff --git a/src/scintilla/include/ScintillaCall.h b/src/scintilla/include/ScintillaCall.h
index 345d15612..7a98c7e3d 100644
--- a/src/scintilla/include/ScintillaCall.h
+++ b/src/scintilla/include/ScintillaCall.h
@@ -324,6 +324,8 @@ class ScintillaCall {
 	int AutoCGetMaxHeight();
 	void AutoCSetStyle(int style);
 	int AutoCGetStyle();
+	void AutoCSetImageScale(int scalePercent);
+	int AutoCGetImageScale();
 	void SetIndent(int indentSize);
 	int Indent();
 	void SetUseTabs(bool useTabs);
@@ -387,6 +389,7 @@ class ScintillaCall {
 	Line LineFromPosition(Position pos);
 	Position PositionFromLine(Line line);
 	void LineScroll(Position columns, Line lines);
+	void ScrollVertical(Line docLine, Line subLine);
 	void ScrollCaret();
 	void ScrollRange(Position secondary, Position primary);
 	void ReplaceSel(const char *text);
@@ -750,7 +753,7 @@ class ScintillaCall {
 	int ExtraAscent();
 	void SetExtraDescent(int extraDescent);
 	int ExtraDescent();
-	int MarkerSymbolDefined(int markerNumber);
+	Scintilla::MarkerSymbol MarkerSymbolDefined(int markerNumber);
 	void MarginSetText(Line line, const char *text);
 	int MarginGetText(Line line, char *text);
 	std::string MarginGetText(Line line);
diff --git a/src/scintilla/include/ScintillaMessages.h b/src/scintilla/include/ScintillaMessages.h
index d7ec27c39..6a33f5c6d 100644
--- a/src/scintilla/include/ScintillaMessages.h
+++ b/src/scintilla/include/ScintillaMessages.h
@@ -249,6 +249,8 @@ enum class Message {
 	AutoCGetMaxHeight = 2211,
 	AutoCSetStyle = 2109,
 	AutoCGetStyle = 2120,
+	AutoCSetImageScale = 2815,
+	AutoCGetImageScale = 2816,
 	SetIndent = 2122,
 	GetIndent = 2123,
 	SetUseTabs = 2124,
@@ -309,6 +311,7 @@ enum class Message {
 	LineFromPosition = 2166,
 	PositionFromLine = 2167,
 	LineScroll = 2168,
+	ScrollVertical = 2817,
 	ScrollCaret = 2169,
 	ScrollRange = 2569,
 	ReplaceSel = 2170,
diff --git a/src/scintilla/include/ScintillaStructures.h b/src/scintilla/include/ScintillaStructures.h
index 4d13a4367..336ad58ff 100644
--- a/src/scintilla/include/ScintillaStructures.h
+++ b/src/scintilla/include/ScintillaStructures.h
@@ -88,10 +88,12 @@ struct NotificationData {
 	NotifyHeader nmhdr;
 	Position position;
 	/* SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_MARGINCLICK, */
-	/* SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, SCN_CALLTIPCLICK, */
+	/* SCN_MARGINRIGHTCLICK, SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, */
+	/* SCN_CALLTIPCLICK, */
 	/* SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, SCN_HOTSPOTRELEASECLICK, */
 	/* SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
-	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTION */
+	/* SCN_USERLISTSELECTION, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
+	/* SCN_AUTOCSELECTIONCHANGE */
 
 	int ch;
 	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
@@ -99,10 +101,12 @@ struct NotificationData {
 	KeyMod modifiers;
 	/* SCN_KEY, SCN_DOUBLECLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
 	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
+	/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
 
 	ModificationFlags modificationType;	/* SCN_MODIFIED */
 	const char *text;
-	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION, SCN_URIDROPPED */
+	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_URIDROPPED, */
+	/* SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, SCN_AUTOCSELECTIONCHANGE */
 
 	Position length;		/* SCN_MODIFIED */
 	Position linesAdded;	/* SCN_MODIFIED */
@@ -112,15 +116,15 @@ struct NotificationData {
 	Position line;		/* SCN_MODIFIED */
 	FoldLevel foldLevelNow;	/* SCN_MODIFIED */
 	FoldLevel foldLevelPrev;	/* SCN_MODIFIED */
-	int margin;		/* SCN_MARGINCLICK */
-	int listType;	/* SCN_USERLISTSELECTION */
+	int margin;		/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
+	int listType;	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTIONCHANGE */
 	int x;			/* SCN_DWELLSTART, SCN_DWELLEND */
 	int y;		/* SCN_DWELLSTART, SCN_DWELLEND */
 	int token;		/* SCN_MODIFIED with SC_MOD_CONTAINER */
 	Position annotationLinesAdded;	/* SCN_MODIFIED with SC_MOD_CHANGEANNOTATION */
 	Update updated;	/* SCN_UPDATEUI */
 	CompletionMethods listCompletionMethod;
-	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION, */
+	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION */
 	CharacterSource characterSource;	/* SCN_CHARADDED */
 };
 
diff --git a/src/scintilla/include/ScintillaTypes.h b/src/scintilla/include/ScintillaTypes.h
index 71e2be398..0991a1480 100644
--- a/src/scintilla/include/ScintillaTypes.h
+++ b/src/scintilla/include/ScintillaTypes.h
@@ -302,6 +302,7 @@ enum class ChangeHistoryOption {
 enum class UndoSelectionHistoryOption {
 	Disabled = 0,
 	Enabled = 1,
+	Scroll = 2,
 };
 
 enum class FoldLevel {
diff --git a/src/scintilla/qt/ScintillaEdit/ScintillaEdit.cpp b/src/scintilla/qt/ScintillaEdit/ScintillaEdit.cpp
index 30a5a74b3..3fbf20a72 100644
--- a/src/scintilla/qt/ScintillaEdit/ScintillaEdit.cpp
+++ b/src/scintilla/qt/ScintillaEdit/ScintillaEdit.cpp
@@ -1008,6 +1008,14 @@ sptr_t ScintillaEdit::autoCStyle() const {
     return send(SCI_AUTOCGETSTYLE, 0, 0);
 }
 
+void ScintillaEdit::autoCSetImageScale(sptr_t scalePercent) {
+    send(SCI_AUTOCSETIMAGESCALE, scalePercent, 0);
+}
+
+sptr_t ScintillaEdit::autoCImageScale() const {
+    return send(SCI_AUTOCGETIMAGESCALE, 0, 0);
+}
+
 void ScintillaEdit::setIndent(sptr_t indentSize) {
     send(SCI_SETINDENT, indentSize, 0);
 }
@@ -1224,6 +1232,10 @@ void ScintillaEdit::lineScroll(sptr_t columns, sptr_t lines) {
     send(SCI_LINESCROLL, columns, lines);
 }
 
+void ScintillaEdit::scrollVertical(sptr_t docLine, sptr_t subLine) {
+    send(SCI_SCROLLVERTICAL, docLine, subLine);
+}
+
 void ScintillaEdit::scrollCaret() {
     send(SCI_SCROLLCARET, 0, 0);
 }
@@ -1400,7 +1412,7 @@ bool ScintillaEdit::callTipActive() {
     return send(SCI_CALLTIPACTIVE, 0, 0);
 }
 
-sptr_t ScintillaEdit::callTipPosStart() {
+sptr_t ScintillaEdit::callTipPosStart() const {
     return send(SCI_CALLTIPPOSSTART, 0, 0);
 }
 
diff --git a/src/scintilla/qt/ScintillaEdit/ScintillaEdit.h b/src/scintilla/qt/ScintillaEdit/ScintillaEdit.h
index c4f920e47..4d9a3260f 100644
--- a/src/scintilla/qt/ScintillaEdit/ScintillaEdit.h
+++ b/src/scintilla/qt/ScintillaEdit/ScintillaEdit.h
@@ -290,6 +290,8 @@ class EXPORT_IMPORT_API ScintillaEdit : public ScintillaEditBase {
 	sptr_t autoCMaxHeight() const;
 	void autoCSetStyle(sptr_t style);
 	sptr_t autoCStyle() const;
+	void autoCSetImageScale(sptr_t scalePercent);
+	sptr_t autoCImageScale() const;
 	void setIndent(sptr_t indentSize);
 	sptr_t indent() const;
 	void setUseTabs(bool useTabs);
@@ -344,6 +346,7 @@ class EXPORT_IMPORT_API ScintillaEdit : public ScintillaEditBase {
 	sptr_t lineFromPosition(sptr_t pos);
 	sptr_t positionFromLine(sptr_t line);
 	void lineScroll(sptr_t columns, sptr_t lines);
+	void scrollVertical(sptr_t docLine, sptr_t subLine);
 	void scrollCaret();
 	void scrollRange(sptr_t secondary, sptr_t primary);
 	void replaceSel(const char * text);
@@ -388,7 +391,7 @@ class EXPORT_IMPORT_API ScintillaEdit : public ScintillaEditBase {
 	void callTipShow(sptr_t pos, const char * definition);
 	void callTipCancel();
 	bool callTipActive();
-	sptr_t callTipPosStart();
+	sptr_t callTipPosStart() const;
 	void callTipSetPosStart(sptr_t posStart);
 	void callTipSetHlt(sptr_t highlightStart, sptr_t highlightEnd);
 	void callTipSetBack(sptr_t back);
diff --git a/src/scintilla/qt/ScintillaEdit/ScintillaEdit.pro b/src/scintilla/qt/ScintillaEdit/ScintillaEdit.pro
index ae70678b9..ebfc65ebe 100644
--- a/src/scintilla/qt/ScintillaEdit/ScintillaEdit.pro
+++ b/src/scintilla/qt/ScintillaEdit/ScintillaEdit.pro
@@ -13,7 +13,7 @@ TEMPLATE = lib
 CONFIG += lib_bundle
 CONFIG += c++1z
 
-VERSION = 5.5.5
+VERSION = 5.5.7
 
 SOURCES += \
     ScintillaEdit.cpp \
diff --git a/src/scintilla/qt/ScintillaEditBase/PlatQt.cpp b/src/scintilla/qt/ScintillaEditBase/PlatQt.cpp
index 83e78a631..38aec01a0 100644
--- a/src/scintilla/qt/ScintillaEditBase/PlatQt.cpp
+++ b/src/scintilla/qt/ScintillaEditBase/PlatQt.cpp
@@ -40,6 +40,7 @@
 #include <QTextLayout>
 #include <QTextLine>
 #include <QLibrary>
+#include <QtMath>
 
 using namespace Scintilla;
 
@@ -667,7 +668,7 @@ void SurfaceImpl::DrawTextClippedUTF8(PRectangle rc,
 				  ColourRGBA back)
 {
 	SetClip(rc);
-	DrawTextNoClip(rc, font, ybase, text, fore, back);
+	DrawTextNoClipUTF8(rc, font, ybase, text, fore, back);
 	PopClip();
 }
 
@@ -994,6 +995,7 @@ class ListBoxImpl : public ListBox {
 	bool unicodeMode{false};
 	int visibleRows{5};
 	QMap<int,QPixmap> images;
+	float imageScale{1.0};
 };
 ListBoxImpl::ListBoxImpl() noexcept = default;
 
@@ -1034,10 +1036,11 @@ void ListBoxImpl::Create(Window &parent,
 	int maxIconWidth = 0;
 	int maxIconHeight = 0;
 	foreach (QPixmap im, images) {
-		if (maxIconWidth < im.width())
-			maxIconWidth = im.width();
-		if (maxIconHeight < im.height())
-			maxIconHeight = im.height();
+		im.setDevicePixelRatio(imageScale);
+		if (maxIconWidth < im.width() / im.devicePixelRatio())
+			maxIconWidth = im.width() / im.devicePixelRatio();
+		if (maxIconHeight < im.height() / im.devicePixelRatio())
+			maxIconHeight = im.height() / im.devicePixelRatio();
 	}
 	list->setIconSize(QSize(maxIconWidth, maxIconHeight));
 
@@ -1085,8 +1088,8 @@ int ListBoxImpl::CaretFromEdge()
 	ListWidget *list = GetWidget();
 	int maxIconWidth = 0;
 	foreach (QPixmap im, images) {
-		if (maxIconWidth < im.width())
-			maxIconWidth = im.width();
+		if (maxIconWidth < im.width() / im.devicePixelRatio())
+			maxIconWidth = im.width() / im.devicePixelRatio();
 	}
 
 	int extra;
@@ -1165,9 +1168,9 @@ void ListBoxImpl::RegisterQPixmapImage(int type, const QPixmap& pm)
 	ListWidget *list = GetWidget();
 	if (list) {
 		QSize iconSize = list->iconSize();
-		if (pm.width() > iconSize.width() || pm.height() > iconSize.height())
-			list->setIconSize(QSize(qMax(pm.width(), iconSize.width()),
-						 qMax(pm.height(), iconSize.height())));
+		if (pm.width() / pm.devicePixelRatio() > iconSize.width() || pm.height() / pm.devicePixelRatio() > iconSize.height())
+			list->setIconSize(QSize(qMax(qFloor(pm.width() / pm.devicePixelRatio()), iconSize.width()),
+						 qMax(qFloor(pm.height() / pm.devicePixelRatio()), iconSize.height())));
 	}
 
 }
@@ -1226,8 +1229,9 @@ void ListBoxImpl::SetList(const char *list, char separator, char typesep)
 		Append(startword, numword?atoi(numword + 1):-1);
 	}
 }
-void ListBoxImpl::SetOptions(ListOptions)
+void ListBoxImpl::SetOptions(ListOptions options_)
 {
+	imageScale = options_.imageScale;
 }
 ListWidget *ListBoxImpl::GetWidget() const noexcept
 {
diff --git a/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp b/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
index 9cd131d42..187da9dbe 100644
--- a/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
+++ b/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
@@ -21,11 +21,6 @@
 #include <QScrollBar>
 #include <QTextFormat>
 
-constexpr int IndicatorInput = static_cast<int>(Scintilla::IndicatorNumbers::Ime);
-constexpr int IndicatorTarget = IndicatorInput + 1;
-constexpr int IndicatorConverted = IndicatorInput + 2;
-constexpr int IndicatorUnknown = IndicatorInput + 3;
-
 // Q_WS_MAC and Q_WS_X11 aren't defined in Qt5
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
 #ifdef Q_OS_MAC
@@ -373,6 +368,12 @@ void ScintillaEditBase::mouseMoveEvent(QMouseEvent *event)
 	sqt->ButtonMoveWithModifiers(pos, TimeOfEvent(time), modifiers);
 }
 
+void ScintillaEditBase::leaveEvent(QEvent *event)
+{
+	QWidget::leaveEvent(event);
+	sqt->MouseLeave();
+}
+
 void ScintillaEditBase::contextMenuEvent(QContextMenuEvent *event)
 {
 	const Point pos = PointFromQPoint(event->globalPos());
@@ -452,31 +453,6 @@ bool ScintillaEditBase::IsHangul(const QChar qchar)
 				HangulJamoExtendedA || HangulJamoExtendedB;
 }
 
-void ScintillaEditBase::MoveImeCarets(Scintilla::Position offset)
-{
-	// Move carets relatively by bytes
-	for (size_t r=0; r < sqt->sel.Count(); r++) {
-		const Sci::Position positionInsert = sqt->sel.Range(r).Start().Position();
-		sqt->sel.Range(r) = SelectionRange(positionInsert + offset);
- 	}
-}
-
-void ScintillaEditBase::DrawImeIndicator(int indicator, int len)
-{
-	// Emulate the visual style of IME characters with indicators.
-	// Draw an indicator on the character before caret by the character bytes of len
-	// so it should be called after InsertCharacter().
-	// It does not affect caret positions.
-	if (indicator < INDICATOR_CONTAINER || indicator > INDICATOR_MAX) {
-		return;
-	}
-	sqt->pdoc->DecorationSetCurrentIndicator(indicator);
-	for (size_t r=0; r< sqt-> sel.Count(); r++) {
-		const Sci::Position positionInsert = sqt->sel.Range(r).Start().Position();
-		sqt->pdoc->DecorationFillRange(positionInsert - len, 1, len);
-	}
-}
-
 namespace {
 
 int GetImeCaretPos(QInputMethodEvent *event)
@@ -607,7 +583,7 @@ void ScintillaEditBase::inputMethodEvent(QInputMethodEvent *event)
 
 			sqt->InsertCharacter(std::string_view(oneChar.data(), oneCharLen), CharacterSource::TentativeInput);
 
-			DrawImeIndicator(imeIndicator[i], oneCharLen);
+			sqt->DrawImeIndicator(imeIndicator[i], oneCharLen);
 			i += ucWidth;
 		}
 
@@ -616,13 +592,13 @@ void ScintillaEditBase::inputMethodEvent(QInputMethodEvent *event)
 		const int imeEndToImeCaretU16 = imeCaretPos - preeditStrLen;
 		const Sci::Position imeCaretPosDoc = sqt->pdoc->GetRelativePositionUTF16(sqt->CurrentPosition(), imeEndToImeCaretU16);
 
-		MoveImeCarets(- sqt->CurrentPosition() + imeCaretPosDoc);
+		sqt->MoveImeCarets(- sqt->CurrentPosition() + imeCaretPosDoc);
 
 		if (IsHangul(preeditStr.at(0))) {
 #ifndef Q_OS_WIN
 			if (imeCaretPos > 0) {
 				int oneCharBefore = sqt->pdoc->GetRelativePosition(sqt->CurrentPosition(), -1);
-				MoveImeCarets(- sqt->CurrentPosition() + oneCharBefore);
+				sqt->MoveImeCarets(- sqt->CurrentPosition() + oneCharBefore);
 			}
 #endif
 			sqt->view.imeCaretBlockOverride = true;
@@ -810,7 +786,7 @@ void ScintillaEditBase::notifyParent(NotificationData scn)
 			break;
 
 		case Notification::AutoCSelection:
-			emit autoCompleteSelection(scn.lParam, QString::fromUtf8(scn.text));
+			emit autoCompleteSelection(scn.lParam, sqt->IsUnicodeMode() ? QString::fromUtf8(scn.text) : QString::fromLocal8Bit(scn.text));
 			break;
 
 		case Notification::AutoCCancelled:
diff --git a/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.h b/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.h
index ba2d6ea9d..5ad750b6e 100644
--- a/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.h
+++ b/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.h
@@ -141,6 +141,7 @@ public slots:
 	void mouseReleaseEvent(QMouseEvent *event) override;
 	void mouseDoubleClickEvent(QMouseEvent *event) override;
 	void mouseMoveEvent(QMouseEvent *event) override;
+	void leaveEvent(QEvent *event) override;
 	void contextMenuEvent(QContextMenuEvent *event) override;
 	void dragEnterEvent(QDragEnterEvent *event) override;
 	void dragLeaveEvent(QDragLeaveEvent *event) override;
@@ -161,8 +162,6 @@ public slots:
 	int wheelDelta;
 
 	static bool IsHangul(const QChar qchar);
-	void MoveImeCarets(Scintilla::Position offset);
-	void DrawImeIndicator(int indicator, int len);
 	static Scintilla::KeyMod ModifiersOfKeyboard();
 };
 
diff --git a/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro b/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
index bd28b896d..17c350f12 100644
--- a/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
+++ b/src/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
@@ -13,7 +13,7 @@ TEMPLATE = lib
 CONFIG += lib_bundle
 CONFIG += c++1z
 
-VERSION = 5.5.5
+VERSION = 5.5.7
 
 SOURCES += \
     PlatQt.cpp \
diff --git a/src/scintilla/qt/ScintillaEditBase/ScintillaQt.cpp b/src/scintilla/qt/ScintillaEditBase/ScintillaQt.cpp
index 88789979a..d5e6eb7b0 100644
--- a/src/scintilla/qt/ScintillaEditBase/ScintillaQt.cpp
+++ b/src/scintilla/qt/ScintillaEditBase/ScintillaQt.cpp
@@ -280,6 +280,7 @@ void ScintillaQt::ScrollText(Sci::Line linesToMove)
 
 void ScintillaQt::SetVerticalScrollPos()
 {
+	Editor::SetVerticalScrollPos();
 	scrollArea->verticalScrollBar()->setValue(topLine);
 	emit verticalScrolled(topLine);
 }
diff --git a/src/scintilla/scripts/HeaderOrder.txt b/src/scintilla/scripts/HeaderOrder.txt
index 7274299b5..12cd90726 100644
--- a/src/scintilla/scripts/HeaderOrder.txt
+++ b/src/scintilla/scripts/HeaderOrder.txt
@@ -2,6 +2,8 @@
 // All platform headers should be included before Scintilla headers
 // and each of these groups are then divided into directory groups.
 
+// Qt platform layer not handled as it doesn't define a strong ordering of headers.
+
 // Base of the repository relative to this file
 
 //base:..
@@ -16,8 +18,6 @@
 //source:cocoa/*.mm
 //source:cocoa/*.h
 //source:test/unit/*.cxx
-//source:lexilla/src/*.cxx
-//source:lexilla/test/*.cxx
 
 // C standard library
 #include <stddef.h>
@@ -71,6 +71,7 @@
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkwayland.h>
 #include <gtk/gtk-a11y.h>
+#include <cairo/cairo-gobject.h>
 
 // Windows headers
 #include <windows.h>
@@ -158,6 +159,9 @@
 // win32
 #include "WinTypes.h"
 #include "PlatWin.h"
+#include "ListBox.h"
+#include "SurfaceGDI.h"
+#include "SurfaceD2D.h"
 #include "HanjaDic.h"
 #include "ScintillaWin.h"
 
diff --git a/src/scintilla/src/AutoComplete.cxx b/src/scintilla/src/AutoComplete.cxx
index 2487d3042..058550d62 100644
--- a/src/scintilla/src/AutoComplete.cxx
+++ b/src/scintilla/src/AutoComplete.cxx
@@ -41,6 +41,7 @@ AutoComplete::AutoComplete() :
 	ignoreCase(false),
 	chooseSingle(false),
 	options(AutoCompleteOption::Normal),
+	imageScale(1.0),
 	posStart(0),
 	startLen(0),
 	cancelAtStartPos(true),
diff --git a/src/scintilla/src/AutoComplete.h b/src/scintilla/src/AutoComplete.h
index 378232a84..b1233332c 100644
--- a/src/scintilla/src/AutoComplete.h
+++ b/src/scintilla/src/AutoComplete.h
@@ -25,6 +25,7 @@ class AutoComplete {
 	bool ignoreCase;
 	bool chooseSingle;
 	AutoCompleteOption options;
+	float imageScale;
 	std::unique_ptr<ListBox> lb;
 	Sci::Position posStart;
 	Sci::Position startLen;
diff --git a/src/scintilla/src/CallTip.cxx b/src/scintilla/src/CallTip.cxx
index d35bec4ec..2be23e898 100644
--- a/src/scintilla/src/CallTip.cxx
+++ b/src/scintilla/src/CallTip.cxx
@@ -95,9 +95,8 @@ int CallTip::NextTabPos(int x) const noexcept {
 		x -= insetX;                // position relative to text
 		x = (x + tabSize) / tabSize;  // tab "number"
 		return tabSize*x + insetX;  // position of next tab
-	} else {
-		return x + 1;                 // arbitrary
 	}
+	return x + 1;                 // arbitrary
 }
 
 namespace {
diff --git a/src/scintilla/src/CaseConvert.cxx b/src/scintilla/src/CaseConvert.cxx
index 752fd54e0..560bc8c70 100644
--- a/src/scintilla/src/CaseConvert.cxx
+++ b/src/scintilla/src/CaseConvert.cxx
@@ -605,7 +605,7 @@ class CaseConverter final : public ICaseConverter {
 			return character < other.character;
 		}
 	};
-	typedef std::vector<CharacterConversion> CharacterToConversion;
+	using CharacterToConversion = std::vector<CharacterConversion>;
 	CharacterToConversion characterToConversion;
 	// The parallel arrays
 	std::vector<int> characters;
@@ -613,7 +613,7 @@ class CaseConverter final : public ICaseConverter {
 
 public:
 	CaseConverter() noexcept = default;
-	bool Initialised() const noexcept {
+	[[nodiscard]] bool Initialised() const noexcept {
 		return !characters.empty();
 	}
 	void Add(int character, std::string_view conversion_) {
@@ -787,7 +787,7 @@ size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixe
 
 std::string CaseConvertString(const std::string &s, CaseConversion conversion) {
 	std::string retMapped(s.length() * maxExpansionCaseConversion, 0);
-	const size_t lenMapped = CaseConvertString(&retMapped[0], retMapped.length(), s.c_str(), s.length(),
+	const size_t lenMapped = CaseConvertString(retMapped.data(), retMapped.length(), s.c_str(), s.length(),
 		conversion);
 	retMapped.resize(lenMapped);
 	return retMapped;
diff --git a/src/scintilla/src/CharacterCategoryMap.cxx b/src/scintilla/src/CharacterCategoryMap.cxx
index 5bf6394ba..20fa7c480 100644
--- a/src/scintilla/src/CharacterCategoryMap.cxx
+++ b/src/scintilla/src/CharacterCategoryMap.cxx
@@ -4072,6 +4072,10 @@ namespace {
 
 enum class OtherID { oidNone, oidStart, oidContinue };
 
+// Silence 'magic' number warning as these character values are not used in multiple places.
+
+// NOLINTBEGIN(*-magic-numbers)
+
 // Some characters are treated as valid for identifiers even
 // though most characters from their category are not.
 // Values copied from http://www.unicode.org/Public/9.0.0/ucd/PropList.txt
@@ -4161,6 +4165,8 @@ bool OmitXidContinue(int character) noexcept {
 	}
 }
 
+// NOLINTEND(*-magic-numbers)
+
 }
 
 // UAX #31 defines ID_Start as
diff --git a/src/scintilla/src/ContractionState.cxx b/src/scintilla/src/ContractionState.cxx
index b36e1ebd8..8f0f795e2 100644
--- a/src/scintilla/src/ContractionState.cxx
+++ b/src/scintilla/src/ContractionState.cxx
@@ -65,6 +65,7 @@ class ContractionState final : public IContractionState {
 	Sci::Line LinesInDoc() const noexcept override;
 	Sci::Line LinesDisplayed() const noexcept override;
 	Sci::Line DisplayFromDoc(Sci::Line lineDoc) const noexcept override;
+	Sci::Line DisplayFromDocSub(Sci::Line lineDoc, Sci::Line lineSub) const noexcept override;
 	Sci::Line DisplayLastFromDoc(Sci::Line lineDoc) const noexcept override;
 	Sci::Line DocFromDisplay(Sci::Line lineDisplay) const noexcept override;
 
@@ -183,6 +184,12 @@ Sci::Line ContractionState<LINE>::DisplayFromDoc(Sci::Line lineDoc) const noexce
 	}
 }
 
+template <typename LINE>
+Sci::Line ContractionState<LINE>::DisplayFromDocSub(Sci::Line lineDoc, Sci::Line lineSub) const noexcept {
+	return DisplayFromDoc(lineDoc) +
+		std::min(lineSub, static_cast<Sci::Line>(GetHeight(lineDoc) - 1));
+}
+
 template <typename LINE>
 Sci::Line ContractionState<LINE>::DisplayLastFromDoc(Sci::Line lineDoc) const noexcept {
 	return DisplayFromDoc(lineDoc) + GetHeight(lineDoc) - 1;
diff --git a/src/scintilla/src/ContractionState.h b/src/scintilla/src/ContractionState.h
index ae753f8d1..a144364d0 100644
--- a/src/scintilla/src/ContractionState.h
+++ b/src/scintilla/src/ContractionState.h
@@ -21,6 +21,7 @@ class IContractionState {
 	virtual Sci::Line LinesInDoc() const noexcept=0;
 	virtual Sci::Line LinesDisplayed() const noexcept=0;
 	virtual Sci::Line DisplayFromDoc(Sci::Line lineDoc) const noexcept=0;
+	virtual Sci::Line DisplayFromDocSub(Sci::Line lineDoc, Sci::Line lineSub) const noexcept=0;
 	virtual Sci::Line DisplayLastFromDoc(Sci::Line lineDoc) const noexcept=0;
 	virtual Sci::Line DocFromDisplay(Sci::Line lineDisplay) const noexcept=0;
 
diff --git a/src/scintilla/src/DBCS.cxx b/src/scintilla/src/DBCS.cxx
index e3ae3d75f..f53b8e9ed 100644
--- a/src/scintilla/src/DBCS.cxx
+++ b/src/scintilla/src/DBCS.cxx
@@ -5,43 +5,89 @@
 // Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
+#include <cstdint>
+
+#include <array>
+#include <map>
+
 #include "DBCS.h"
 
 using namespace Scintilla::Internal;
 
 namespace Scintilla::Internal {
 
+// Silence 'magic' number use since the set of DBCS lead and trail bytes differ
+// between encodings and would require many constant declarations that would just
+// obscure the behaviour.
+
+// NOLINTBEGIN(*-magic-numbers)
+
 bool DBCSIsLeadByte(int codePage, char ch) noexcept {
 	// Byte ranges found in Wikipedia articles with relevant search strings in each case
 	const unsigned char uch = ch;
 	switch (codePage) {
-	case 932:
+	case cp932:
 		// Shift_jis
 		return ((uch >= 0x81) && (uch <= 0x9F)) ||
 			((uch >= 0xE0) && (uch <= 0xFC));
 		// Lead bytes F0 to FC may be a Microsoft addition.
-	case 936:
+	case cp936:
 		// GBK
 		return (uch >= 0x81) && (uch <= 0xFE);
-	case 949:
+	case cp949:
 		// Korean Wansung KS C-5601-1987
 		return (uch >= 0x81) && (uch <= 0xFE);
-	case 950:
+	case cp950:
 		// Big5
 		return (uch >= 0x81) && (uch <= 0xFE);
-	case 1361:
+	case cp1361:
 		// Korean Johab KS C-5601-1992
 		return
 			((uch >= 0x84) && (uch <= 0xD3)) ||
 			((uch >= 0xD8) && (uch <= 0xDE)) ||
 			((uch >= 0xE0) && (uch <= 0xF9));
+	default:
+		break;
+	}
+	return false;
+}
+
+bool DBCSIsTrailByte(int codePage, char ch) noexcept {
+	const unsigned char trail = ch;
+	switch (codePage) {
+	case cp932:
+		// Shift_jis
+		return (trail != 0x7F) &&
+			((trail >= 0x40) && (trail <= 0xFC));
+	case cp936:
+		// GBK
+		return (trail != 0x7F) &&
+			((trail >= 0x40) && (trail <= 0xFE));
+	case cp949:
+		// Korean Wansung KS C-5601-1987
+		return
+			((trail >= 0x41) && (trail <= 0x5A)) ||
+			((trail >= 0x61) && (trail <= 0x7A)) ||
+			((trail >= 0x81) && (trail <= 0xFE));
+	case cp950:
+		// Big5
+		return
+			((trail >= 0x40) && (trail <= 0x7E)) ||
+			((trail >= 0xA1) && (trail <= 0xFE));
+	case cp1361:
+		// Korean Johab KS C-5601-1992
+		return
+			((trail >= 0x31) && (trail <= 0x7E)) ||
+			((trail >= 0x81) && (trail <= 0xFE));
+	default:
+		break;
 	}
 	return false;
 }
 
 bool IsDBCSValidSingleByte(int codePage, int ch) noexcept {
 	switch (codePage) {
-	case 932:
+	case cp932:
 		return ch == 0x80
 			|| (ch >= 0xA0 && ch <= 0xDF)
 			|| (ch >= 0xFD);
@@ -51,4 +97,27 @@ bool IsDBCSValidSingleByte(int codePage, int ch) noexcept {
 	}
 }
 
+// NOLINTEND(*-magic-numbers)
+
+using CodePageToFoldMap = std::map<int, FoldMap>;
+CodePageToFoldMap cpToFoldMap;
+
+bool DBCSHasFoldMap(int codePage) {
+	const CodePageToFoldMap::const_iterator it = cpToFoldMap.find(codePage);
+	return it != cpToFoldMap.end();
+}
+
+void DBCSSetFoldMap(int codePage, const FoldMap &foldMap) {
+	cpToFoldMap[codePage] = foldMap;
+}
+
+FoldMap *DBCSGetMutableFoldMap(int codePage) {
+	// Constructs if needed
+	return &cpToFoldMap[codePage];
+}
+
+const FoldMap *DBCSGetFoldMap(int codePage) {
+	return &cpToFoldMap[codePage];
+}
+
 }
diff --git a/src/scintilla/src/DBCS.h b/src/scintilla/src/DBCS.h
index ceeb75929..96d282446 100644
--- a/src/scintilla/src/DBCS.h
+++ b/src/scintilla/src/DBCS.h
@@ -10,17 +10,42 @@
 
 namespace Scintilla::Internal {
 
+constexpr int cp932 = 932;
+constexpr int cp936 = 936;
+constexpr int cp949 = 949;
+constexpr int cp950 = 950;
+constexpr int cp1361 = 1361;
+
 constexpr bool IsDBCSCodePage(int codePage) noexcept {
-	return codePage == 932
-	       || codePage == 936
-	       || codePage == 949
-	       || codePage == 950
-	       || codePage == 1361;
+	return codePage == cp932
+	       || codePage == cp936
+	       || codePage == cp949
+	       || codePage == cp950
+	       || codePage == cp1361;
 }
 
 bool DBCSIsLeadByte(int codePage, char ch) noexcept;
+bool DBCSIsTrailByte(int codePage, char ch) noexcept;
 bool IsDBCSValidSingleByte(int codePage, int ch) noexcept;
 
+// Calculate a number from a DBCS byte pair that can be used to index into an array or map.
+// Should only be called with genuine DBCS character pairs which means that ch1 has top bit set.
+constexpr uint16_t DBCSIndex(char ch1, char ch2) noexcept {
+	const unsigned char uch1 = ch1 & 0x7F;
+	const unsigned char uch2 = ch2;
+	return (uch1 << 8) | uch2;
+}
+
+struct DBCSPair {
+	char chars[2];
+};
+using FoldMap = std::array<DBCSPair, 0x8000>;
+
+bool DBCSHasFoldMap(int codePage);
+void DBCSSetFoldMap(int codePage, const FoldMap &foldMap);
+FoldMap *DBCSGetMutableFoldMap(int codePage);
+const FoldMap *DBCSGetFoldMap(int codePage);
+
 }
 
 #endif
diff --git a/src/scintilla/src/Document.cxx b/src/scintilla/src/Document.cxx
index 8fc76e426..c79c5002b 100644
--- a/src/scintilla/src/Document.cxx
+++ b/src/scintilla/src/Document.cxx
@@ -120,7 +120,7 @@ void ActionDuration::AddSample(size_t numberActions, double durationOfActions) n
 	// Most recent value contributes 25% to smoothed value.
 	constexpr double alpha = 0.25;
 
-	const double durationOne = durationOfActions / numberActions;
+	const double durationOne = durationOfActions / static_cast<double>(numberActions);
 	duration = std::clamp(alpha * durationOne + (1.0 - alpha) * duration,
 		minDuration, maxDuration);
 }
@@ -260,8 +260,7 @@ LineAnnotation *Document::EOLAnnotations() const noexcept {
 LineEndType Document::LineEndTypesSupported() const {
 	if ((CpUtf8 == dbcsCodePage) && pli)
 		return pli->LineEndTypesSupported();
-	else
-		return LineEndType::Default;
+	return LineEndType::Default;
 }
 
 bool Document::SetDBCSCodePage(int dbcsCodePage_) {
@@ -272,9 +271,8 @@ bool Document::SetDBCSCodePage(int dbcsCodePage_) {
 		cb.SetUTF8Substance(CpUtf8 == dbcsCodePage);
 		ModifiedAt(0);	// Need to restyle whole document
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
 bool Document::SetLineEndTypesAllowed(LineEndType lineEndBitSet_) {
@@ -285,12 +283,9 @@ bool Document::SetLineEndTypesAllowed(LineEndType lineEndBitSet_) {
 			ModifiedAt(0);
 			cb.SetLineEndTypes(lineEndBitSetActive);
 			return true;
-		} else {
-			return false;
 		}
-	} else {
-		return false;
 	}
+	return false;
 }
 
 void Document::SetSavePoint() {
@@ -453,9 +448,8 @@ int Document::AddMark(Sci::Line line, int markerNum) {
 		const DocModification mh(ModificationFlags::ChangeMarker, LineStart(line), 0, 0, nullptr, line);
 		NotifyModified(mh);
 		return prev;
-	} else {
-		return -1;
 	}
+	return -1;
 }
 
 void Document::AddMarkSet(Sci::Line line, int valueSet) {
@@ -620,23 +614,26 @@ void Document::ClearLevels() {
 	Levels()->ClearLevels();
 }
 
-static bool IsSubordinate(FoldLevel levelStart, FoldLevel levelTry) noexcept {
+namespace {
+
+constexpr bool IsSubordinate(FoldLevel levelStart, FoldLevel levelTry) noexcept {
 	if (LevelIsWhitespace(levelTry))
 		return true;
-	else
-		return LevelNumber(levelStart) < LevelNumber(levelTry);
+	return LevelNumber(levelStart) < LevelNumber(levelTry);
+}
+
 }
 
 Sci::Line Document::GetLastChild(Sci::Line lineParent, std::optional<FoldLevel> level, Sci::Line lastLine) {
 	const FoldLevel levelStart = LevelNumberPart(level ? *level : GetFoldLevel(lineParent));
-	const Sci::Line maxLine = LinesTotal();
-	const Sci::Line lookLastLine = (lastLine != -1) ? std::min(LinesTotal() - 1, lastLine) : -1;
+	const Sci::Line maxLine = LinesTotal() - 1;
+	const Sci::Line lookLastLine = (lastLine != -1) ? std::min(maxLine, lastLine) : maxLine;
 	Sci::Line lineMaxSubord = lineParent;
-	while (lineMaxSubord < maxLine - 1) {
+	while (lineMaxSubord < maxLine) {
 		EnsureStyledTo(LineStart(lineMaxSubord + 2));
 		if (!IsSubordinate(levelStart, GetFoldLevel(lineMaxSubord + 1)))
 			break;
-		if ((lookLastLine != -1) && (lineMaxSubord >= lookLastLine) && !LevelIsWhitespace(GetFoldLevel(lineMaxSubord)))
+		if ((lineMaxSubord >= lookLastLine) && !LevelIsWhitespace(GetFoldLevel(lineMaxSubord)))
 			break;
 		lineMaxSubord++;
 	}
@@ -760,15 +757,13 @@ int Document::LenChar(Sci::Position pos) const noexcept {
 		if (utf8status & UTF8MaskInvalid) {
 			// Treat as invalid and use up just one byte
 			return 1;
-		} else {
-			return utf8status & UTF8MaskWidth;
 		}
+		return utf8status & UTF8MaskWidth;
+	}
+	if (IsDBCSLeadByteNoExcept(leadByte) && IsDBCSTrailByteNoExcept(cb.CharAt(pos + 1))) {
+		return 2;
 	} else {
-		if (IsDBCSLeadByteNoExcept(leadByte) && IsDBCSTrailByteNoExcept(cb.CharAt(pos + 1))) {
-			return 2;
-		} else {
-			return 1;
-		}
+		return 1;
 	}
 }
 
@@ -782,21 +777,20 @@ bool Document::InGoodUTF8(Sci::Position pos, Sci::Position &start, Sci::Position
 	const int widthCharBytes = UTF8BytesOfLead[leadByte];
 	if (widthCharBytes == 1) {
 		return false;
-	} else {
-		const int trailBytes = widthCharBytes - 1;
-		const Sci::Position len = pos - start;
-		if (len > trailBytes)
-			// pos too far from lead
-			return false;
-		unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
-		for (Sci::Position b=1; b<widthCharBytes && ((start+b) < cb.Length()); b++)
-			charBytes[b] = cb.CharAt(start+b);
-		const int utf8status = UTF8Classify(charBytes, widthCharBytes);
-		if (utf8status & UTF8MaskInvalid)
-			return false;
-		end = start + widthCharBytes;
-		return true;
 	}
+	const int trailBytes = widthCharBytes - 1;
+	const Sci::Position len = pos - start;
+	if (len > trailBytes)
+		// pos too far from lead
+		return false;
+	unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
+	for (Sci::Position b=1; b<widthCharBytes && ((start+b) < cb.Length()); b++)
+		charBytes[b] = cb.CharAt(start+b);
+	const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+	if (utf8status & UTF8MaskInvalid)
+		return false;
+	end = start + widthCharBytes;
+	return true;
 }
 
 // Normalise a position so that it is not part way through a multi-byte character.
@@ -955,10 +949,9 @@ bool Document::NextCharacter(Sci::Position &pos, int moveDir) const noexcept {
 	Sci::Position posNext = NextPosition(pos, moveDir);
 	if (posNext == pos) {
 		return false;
-	} else {
-		pos = posNext;
-		return true;
 	}
+	pos = posNext;
+	return true;
 }
 
 CharacterExtracted Document::CharacterAfter(Sci::Position position) const noexcept {
@@ -1106,6 +1099,12 @@ bool SCI_METHOD Document::IsDBCSLeadByte(char ch) const {
 	return IsDBCSLeadByteNoExcept(ch);
 }
 
+// Silence 'magic' number use since the set of DBCS lead and trail bytes differ
+// between encodings and would require many constant declarations that would just
+// obscure the behaviour.
+
+// NOLINTBEGIN(*-magic-numbers)
+
 bool Document::IsDBCSLeadByteNoExcept(char ch) const noexcept {
 	// Used inside core Scintilla
 	// Byte ranges found in Wikipedia articles with relevant search strings in each case
@@ -1189,6 +1188,8 @@ unsigned char Document::DBCSMinTrailByte() const noexcept {
 	}
 }
 
+// NOLINTEND(*-magic-numbers)
+
 int Document::DBCSDrawBytes(std::string_view text) const noexcept {
 	if (text.length() <= 1) {
 		return static_cast<int>(text.length());
@@ -1215,7 +1216,8 @@ void DiscardEndFragment(std::string_view &text) noexcept {
 			text.remove_suffix(1);
 		} else if (UTF8IsTrailByte(text.back())) {
 			// go back to the start of last character.
-			const size_t maxTrail = std::max<size_t>(UTF8MaxBytes - 1, text.length());
+			constexpr int UTF8MaxTrail = UTF8MaxBytes - 1;
+			const size_t maxTrail = std::max<size_t>(UTF8MaxTrail, text.length());
 			size_t trail = 1;
 			while (trail < maxTrail && UTF8IsTrailByte(text[text.length() - trail])) {
 				trail++;
@@ -1229,8 +1231,8 @@ void DiscardEndFragment(std::string_view &text) noexcept {
 }
 
 constexpr bool IsBaseOfGrapheme(CharacterCategory cc) {
-	// \p{L}\p{N}\p{P}\p{Sm}\p{Sc}\p{So}\p{Zs}
 	switch (cc) {
+		// \p{L}\p{N}\p{P}\p{Sm}\p{Sc}\p{So}\p{Zs}
 	case ccLu:
 	case ccLl:
 	case ccLt:
@@ -1250,12 +1252,16 @@ constexpr bool IsBaseOfGrapheme(CharacterCategory cc) {
 	case ccSc:
 	case ccSo:
 	case ccZs:
+		// Control
+	case ccCc:
+	case ccCs:
+	case ccCo:
 		return true;
 	default:
 		// ccMn, ccMc, ccMe,
 		// ccSk,
 		// ccZl, ccZp,
-		// ccCc, ccCf, ccCs, ccCo, ccCn
+		// ccCf, ccCn
 		return false;
 	}
 }
@@ -1276,17 +1282,38 @@ CharacterExtracted LastCharacter(std::string_view text) noexcept {
 		static_cast<unsigned int>(utf8status & UTF8MaskWidth) };
 }
 
+constexpr Sci::Position NextTab(Sci::Position pos, Sci::Position tabSize) noexcept {
+	return ((pos / tabSize) + 1) * tabSize;
+}
+
+std::string CreateIndentation(Sci::Position indent, int tabSize, bool insertSpaces) {
+	std::string indentation;
+	if (!insertSpaces) {
+		while (indent >= tabSize) {
+			indentation += '\t';
+			indent -= tabSize;
+		}
+	}
+	while (indent > 0) {
+		indentation += ' ';
+		indent--;
+	}
+	return indentation;
+}
+
 }
 
 bool Scintilla::Internal::DiscardLastCombinedCharacter(std::string_view &text) noexcept {
 	// Handle the simple common case where a base character may be followed by
 	// accents and similar marks by discarding until start of base character.
-	// 
+	//
 	// From Grapheme_Cluster_Boundaries
 	// combining character sequence = ccs-base? ccs-extend+
 	// ccs-base := [\p{L}\p{N}\p{P}\p{S}\p{Zs}]
 	// ccs-extend := [\p{M}\p{Join_Control}]
 	// Modified to move Sk (Symbol Modifier) from ccs-base to ccs-extend to preserve modified emoji
+	// May break before and after Control which is defined as most of ccC? but not some of ccCf and ccCn
+	// so treat ccCc, ccCs, ccCo as base for now.
 
 	std::string_view truncated = text;
 	while (truncated.length() > UTF8MaxBytes) {
@@ -1377,10 +1404,9 @@ size_t Document::SafeSegment(std::string_view text) const noexcept {
 EncodingFamily Document::CodePageFamily() const noexcept {
 	if (CpUtf8 == dbcsCodePage)
 		return EncodingFamily::unicode;
-	else if (dbcsCodePage)
+	if (dbcsCodePage)
 		return EncodingFamily::dbcs;
-	else
-		return EncodingFamily::eightBit;
+	return EncodingFamily::eightBit;
 }
 
 void Document::ModifiedAt(Sci::Position pos) noexcept {
@@ -1420,37 +1446,36 @@ bool Document::DeleteChars(Sci::Position pos, Sci::Position len) {
 	CheckReadOnly();
 	if (enteredModification != 0) {
 		return false;
-	} else {
-		enteredModification++;
-		if (!cb.IsReadOnly()) {
-			if (cb.IsCollectingUndo() && cb.CanRedo()) {
-				// Abandoning some undo actions so truncate any later selections
-				TruncateUndoComments(cb.UndoCurrent());
-			}
-			NotifyModified(
-			    DocModification(
-			        ModificationFlags::BeforeDelete | ModificationFlags::User,
-			        pos, len,
-				0, nullptr));
-			const Sci::Line prevLinesTotal = LinesTotal();
-			const bool startSavePoint = cb.IsSavePoint();
-			bool startSequence = false;
-			const char *text = cb.DeleteChars(pos, len, startSequence);
-			if (startSavePoint && cb.IsCollectingUndo())
-				NotifySavePoint(false);
-			if ((pos < LengthNoExcept()) || (pos == 0))
-				ModifiedAt(pos);
-			else
-				ModifiedAt(pos-1);
-			NotifyModified(
-			    DocModification(
-			        ModificationFlags::DeleteText | ModificationFlags::User |
-					(startSequence?ModificationFlags::StartAction:ModificationFlags::None),
-			        pos, len,
-			        LinesTotal() - prevLinesTotal, text));
-		}
-		enteredModification--;
 	}
+	enteredModification++;
+	if (!cb.IsReadOnly()) {
+		if (cb.IsCollectingUndo() && cb.CanRedo()) {
+			// Abandoning some undo actions so truncate any later selections
+			TruncateUndoComments(cb.UndoCurrent());
+		}
+		NotifyModified(
+			DocModification(
+			    ModificationFlags::BeforeDelete | ModificationFlags::User,
+			    pos, len,
+			0, nullptr));
+		const Sci::Line prevLinesTotal = LinesTotal();
+		const bool startSavePoint = cb.IsSavePoint();
+		bool startSequence = false;
+		const char *text = cb.DeleteChars(pos, len, startSequence);
+		if (startSavePoint && cb.IsCollectingUndo())
+			NotifySavePoint(false);
+		if ((pos < LengthNoExcept()) || (pos == 0))
+			ModifiedAt(pos);
+		else
+			ModifiedAt(pos-1);
+		NotifyModified(
+			DocModification(
+			    ModificationFlags::DeleteText | ModificationFlags::User |
+				(startSequence?ModificationFlags::StartAction:ModificationFlags::None),
+			    pos, len,
+			    LinesTotal() - prevLinesTotal, text));
+	}
+	enteredModification--;
 	return !cb.IsReadOnly();
 }
 
@@ -1702,25 +1727,6 @@ void Document::DelCharBack(Sci::Position pos) {
 	}
 }
 
-static constexpr Sci::Position NextTab(Sci::Position pos, Sci::Position tabSize) noexcept {
-	return ((pos / tabSize) + 1) * tabSize;
-}
-
-static std::string CreateIndentation(Sci::Position indent, int tabSize, bool insertSpaces) {
-	std::string indentation;
-	if (!insertSpaces) {
-		while (indent >= tabSize) {
-			indentation += '\t';
-			indent -= tabSize;
-		}
-	}
-	while (indent > 0) {
-		indentation += ' ';
-		indent--;
-	}
-	return indentation;
-}
-
 int SCI_METHOD Document::GetLineIndentation(Sci_Position line) {
 	int indent = 0;
 	if ((line >= 0) && (line < LinesTotal())) {
@@ -2364,7 +2370,7 @@ Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, con
 			constexpr size_t maxFoldingExpansion = 4;
 			std::vector<char> searchThing((lengthFind+1) * UTF8MaxBytes * maxFoldingExpansion + 1);
 			const size_t lenSearch =
-				pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind);
+				pcf->Fold(searchThing.data(), searchThing.size(), search, lengthFind);
 			while (forward ? (pos < endPos) : (pos >= endPos)) {
 				int widthFirstCharacter = 1;
 				Sci::Position posIndexDocument = pos;
@@ -2397,7 +2403,7 @@ Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, con
 						// memcmp may examine lenFlat bytes in both arguments so assert it doesn't read past end of searchThing
 						assert((indexSearch + lenFlat) <= searchThing.size());
 						// Does folded match the buffer
-						characterMatches = 0 == memcmp(folded, &searchThing[0] + indexSearch, lenFlat);
+						characterMatches = 0 == memcmp(folded, searchThing.data() + indexSearch, lenFlat);
 					}
 					if (!characterMatches) {
 						break;
@@ -2423,7 +2429,7 @@ Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, con
 			constexpr size_t maxBytesCharacter = 2;
 			constexpr size_t maxFoldingExpansion = 4;
 			std::vector<char> searchThing((lengthFind+1) * maxBytesCharacter * maxFoldingExpansion + 1);
-			const size_t lenSearch = pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind);
+			const size_t lenSearch = pcf->Fold(searchThing.data(), searchThing.size(), search, lengthFind);
 			while (forward ? (pos < endPos) : (pos >= endPos)) {
 				int widthFirstCharacter = 0;
 				Sci::Position indexDocument = 0;
@@ -2452,7 +2458,7 @@ Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, con
 						// memcmp may examine lenFlat bytes in both arguments so assert it doesn't read past end of searchThing
 						assert((indexSearch + lenFlat) <= searchThing.size());
 						// Does folded match the buffer
-						characterMatches = 0 == memcmp(folded, &searchThing[0] + indexSearch, lenFlat);
+						characterMatches = 0 == memcmp(folded, searchThing.data() + indexSearch, lenFlat);
 					}
 					if (!characterMatches) {
 						break;
@@ -2477,7 +2483,7 @@ Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, con
 		} else {
 			const Sci::Position endSearch = (startPos <= endPos) ? endPos - lengthFind + 1 : endPos;
 			std::vector<char> searchThing(lengthFind + 1);
-			pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind);
+			pcf->Fold(searchThing.data(), searchThing.size(), search, lengthFind);
 			while (forward ? (pos < endSearch) : (pos >= endSearch)) {
 				bool found = (pos + lengthFind) <= limitPos;
 				for (int indexSearch = 0; (indexSearch < lengthFind) && found; indexSearch++) {
@@ -2503,10 +2509,10 @@ Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, con
 }
 
 const char *Document::SubstituteByPosition(const char *text, Sci::Position *length) {
-	if (regex)
+	if (regex) {
 		return regex->SubstituteByPosition(this, text, length);
-	else
-		return nullptr;
+	}
+	return nullptr;
 }
 
 LineCharacterIndexType Document::LineCharacterIndex() const noexcept {
@@ -2556,46 +2562,44 @@ void SCI_METHOD Document::StartStyling(Sci_Position position) {
 bool SCI_METHOD Document::SetStyleFor(Sci_Position length, char style) {
 	if (enteredStyling != 0) {
 		return false;
-	} else {
-		enteredStyling++;
-		const Sci::Position prevEndStyled = endStyled;
-		if (cb.SetStyleFor(endStyled, length, style)) {
-			const DocModification mh(ModificationFlags::ChangeStyle | ModificationFlags::User,
-			                   prevEndStyled, length);
-			NotifyModified(mh);
-		}
-		endStyled += length;
-		enteredStyling--;
-		return true;
 	}
+	enteredStyling++;
+	const Sci::Position prevEndStyled = endStyled;
+	if (cb.SetStyleFor(endStyled, length, style)) {
+		const DocModification mh(ModificationFlags::ChangeStyle | ModificationFlags::User,
+			                prevEndStyled, length);
+		NotifyModified(mh);
+	}
+	endStyled += length;
+	enteredStyling--;
+	return true;
 }
 
 bool SCI_METHOD Document::SetStyles(Sci_Position length, const char *styles) {
 	if (enteredStyling != 0) {
 		return false;
-	} else {
-		enteredStyling++;
-		bool didChange = false;
-		Sci::Position startMod = 0;
-		Sci::Position endMod = 0;
-		for (int iPos = 0; iPos < length; iPos++, endStyled++) {
-			PLATFORM_ASSERT(endStyled < Length());
-			if (cb.SetStyleAt(endStyled, styles[iPos])) {
-				if (!didChange) {
-					startMod = endStyled;
-				}
-				didChange = true;
-				endMod = endStyled;
+	}
+	enteredStyling++;
+	bool didChange = false;
+	Sci::Position startMod = 0;
+	Sci::Position endMod = 0;
+	for (int iPos = 0; iPos < length; iPos++, endStyled++) {
+		PLATFORM_ASSERT(endStyled < Length());
+		if (cb.SetStyleAt(endStyled, styles[iPos])) {
+			if (!didChange) {
+				startMod = endStyled;
 			}
+			didChange = true;
+			endMod = endStyled;
 		}
-		if (didChange) {
-			const DocModification mh(ModificationFlags::ChangeStyle | ModificationFlags::User,
-			                   startMod, endMod - startMod + 1);
-			NotifyModified(mh);
-		}
-		enteredStyling--;
-		return true;
 	}
+	if (didChange) {
+		const DocModification mh(ModificationFlags::ChangeStyle | ModificationFlags::User,
+			                startMod, endMod - startMod + 1);
+		NotifyModified(mh);
+	}
+	enteredStyling--;
+	return true;
 }
 
 void Document::EnsureStyledTo(Sci::Position pos) {
@@ -2631,7 +2635,7 @@ void Document::SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noex
 
 void Document::SetViewState(void *view, ViewStateShared pVSS) {
 	if (pVSS) {
-		viewData[view] = pVSS;
+		viewData[view] = std::move(pVSS);
 	} else {
 		viewData.erase(view);
 	}
@@ -2975,7 +2979,9 @@ Sci::Position Document::ExtendStyleRange(Sci::Position pos, int delta, bool sing
 	return pos;
 }
 
-static char BraceOpposite(char ch) noexcept {
+namespace {
+
+constexpr char BraceOpposite(char ch) noexcept {
 	switch (ch) {
 	case '(':
 		return ')';
@@ -2998,6 +3004,8 @@ static char BraceOpposite(char ch) noexcept {
 	}
 }
 
+}
+
 // TODO: should be able to extend styled region to find matching brace
 Sci::Position Document::BraceMatch(Sci::Position position, Sci::Position /*maxReStyle*/, Sci::Position startPos, bool useStartPos) noexcept {
 	const unsigned char chBrace = CharAt(position);
@@ -3014,7 +3022,7 @@ Sci::Position Document::BraceMatch(Sci::Position position, Sci::Position /*maxRe
 	// Avoid using MovePositionOutsideChar to check DBCS trail byte
 	unsigned char maxSafeChar = 0xff;
 	if (dbcsCodePage != 0 && dbcsCodePage != CpUtf8) {
-		maxSafeChar = DBCSMinTrailByte() - 1;
+		maxSafeChar = std::max<unsigned char>(DBCSMinTrailByte(), 1) - 1;
 	}
 
 	while ((position >= 0) && (position < LengthNoExcept())) {
@@ -3075,7 +3083,7 @@ class RESearchRange {
 		lineRangeEnd = doc->SciLineFromPosition(endPos);
 		lineRangeBreak = lineRangeEnd + increment;
 	}
-	Range LineRange(Sci::Line line, Sci::Position lineStartPos, Sci::Position lineEndPos) const noexcept {
+	[[nodiscard]] Range LineRange(Sci::Line line, Sci::Position lineStartPos, Sci::Position lineEndPos) const noexcept {
 		Range range(lineStartPos, lineEndPos);
 		if (increment == 1) {
 			if (line == lineRangeStart)
@@ -3101,13 +3109,13 @@ class DocumentIndexer final : public CharacterIndexer {
 		pdoc(pdoc_), end(end_) {
 	}
 
-	char CharAt(Sci::Position index) const noexcept override {
-		if (index < 0 || index >= end)
+	[[nodiscard]] char CharAt(Sci::Position index) const noexcept override {
+		if (index < 0 || index >= end) {
 			return 0;
-		else
-			return pdoc->CharAt(index);
+		}
+		return pdoc->CharAt(index);
 	}
-	Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir) const noexcept override {
+	[[nodiscard]] Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir) const noexcept override {
 		return pdoc->MovePositionOutsideChar(pos, moveDir, false);
 	}
 };
@@ -3150,10 +3158,10 @@ class ByteIterator {
 	bool operator!=(const ByteIterator &other) const noexcept {
 		return doc != other.doc || position != other.position;
 	}
-	Sci::Position Pos() const noexcept {
+	[[nodiscard]] Sci::Position Pos() const noexcept {
 		return position;
 	}
-	Sci::Position PosRoundUp() const noexcept {
+	[[nodiscard]] Sci::Position PosRoundUp() const noexcept {
 		return position;
 	}
 };
@@ -3178,11 +3186,11 @@ class UTF8Iterator {
 	// These 3 fields determine the iterator position and are used for comparisons
 	const Document *doc;
 	Sci::Position position;
-	size_t characterIndex;
+	size_t characterIndex = 0;
 	// Remaining fields are derived from the determining fields so are excluded in comparisons
-	unsigned int lenBytes;
-	size_t lenCharacters;
-	wchar_t buffered[2];
+	unsigned int lenBytes = 0;
+	size_t lenCharacters = 0;
+	wchar_t buffered[2]{};
 public:
 	using iterator_category = std::bidirectional_iterator_tag;
 	using value_type = wchar_t;
@@ -3191,9 +3199,7 @@ class UTF8Iterator {
 	using reference = wchar_t&;
 
 	explicit UTF8Iterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
-		doc(doc_), position(position_), characterIndex(0), lenBytes(0), lenCharacters(0), buffered{} {
-		buffered[0] = 0;
-		buffered[1] = 0;
+		doc(doc_), position(position_) {
 		if (doc) {
 			ReadCharacter();
 		}
@@ -3245,10 +3251,10 @@ class UTF8Iterator {
 			position != other.position ||
 			characterIndex != other.characterIndex;
 	}
-	Sci::Position Pos() const noexcept {
+	[[nodiscard]] Sci::Position Pos() const noexcept {
 		return position;
 	}
-	Sci::Position PosRoundUp() const noexcept {
+	[[nodiscard]] Sci::Position PosRoundUp() const noexcept {
 		if (characterIndex)
 			return position + lenBytes;	// Force to end of character
 		else
diff --git a/src/scintilla/src/Document.h b/src/scintilla/src/Document.h
index 4c6832d89..7655d5290 100644
--- a/src/scintilla/src/Document.h
+++ b/src/scintilla/src/Document.h
@@ -173,7 +173,7 @@ class HighlightDelimiter {
 };
 
 // Base class for view state that can be held and transferred without understanding the contents.
-// Declared here but real implementation subclass declared in EditModel 
+// Declared here but real implementation subclass declared in EditModel
 struct ViewState {
 	ViewState() noexcept = default;
 	// Deleted so ViewState objects can not be copied
diff --git a/src/scintilla/src/EditModel.cxx b/src/scintilla/src/EditModel.cxx
index e12aab38e..65d39f9e7 100644
--- a/src/scintilla/src/EditModel.cxx
+++ b/src/scintilla/src/EditModel.cxx
@@ -172,7 +172,7 @@ int EditModel::GetMark(Sci::Line line) const {
 }
 
 void EditModel::EnsureModelState() {
-	if (!modelState && (undoSelectionHistoryOption == UndoSelectionHistoryOption::Enabled)) {
+	if (!modelState && (undoSelectionHistoryOption != UndoSelectionHistoryOption::Disabled)) {
 		if (ViewStateShared vss = pdoc->GetViewState(this)) {
 			modelState = std::dynamic_pointer_cast<ModelState>(vss);
 		} else {
diff --git a/src/scintilla/src/EditView.cxx b/src/scintilla/src/EditView.cxx
index 8215f7b68..dddd84d94 100644
--- a/src/scintilla/src/EditView.cxx
+++ b/src/scintilla/src/EditView.cxx
@@ -277,7 +277,7 @@ void EditView::DropGraphics() noexcept {
 }
 
 void EditView::RefreshPixMaps(Surface *surfaceWindow, const ViewStyle &vsDraw) {
-	if (!pixmapIndentGuide) {
+	if (!(pixmapIndentGuide && pixmapIndentGuideHighlight)) {
 		// 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
 		pixmapIndentGuide = surfaceWindow->AllocatePixMap(1, vsDraw.lineHeight + 1);
 		pixmapIndentGuideHighlight = surfaceWindow->AllocatePixMap(1, vsDraw.lineHeight + 1);
@@ -670,8 +670,8 @@ Point EditView::LocationFromPosition(Surface *surface, const EditModel &model, S
 				pt.y = static_cast<XYPOSITION>(subLine*vs.lineHeight);
 			}
 		}
-		pt.y += (lineVisible - topLine) * vs.lineHeight;
-		pt.x += pos.VirtualSpace() * vs.styles[ll->EndLineStyle()].spaceWidth;
+		pt.y += static_cast<XYPOSITION>((lineVisible - topLine) * vs.lineHeight);
+		pt.x += pos.VirtualSpaceWidth(vs.styles[ll->EndLineStyle()].spaceWidth);
 	}
 	return pt;
 }
@@ -958,7 +958,7 @@ void EditView::DrawEOL(Surface *surface, const EditModel &model, const ViewStyle
 	XYPOSITION virtualSpace = 0;
 	if (lastSubLine) {
 		const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
-		virtualSpace = model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line)) * spaceWidth;
+		virtualSpace = static_cast<XYPOSITION>(model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line))) * spaceWidth;
 	}
 	const XYPOSITION xEol = ll->positions[lineEnd] - subLineStart;
 
@@ -977,9 +977,9 @@ void EditView::DrawEOL(Surface *surface, const EditModel &model, const ViewStyle
 				if (!portion.Empty()) {
 					const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
 					rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
-						subLineStart+portion.start.VirtualSpace() * spaceWidth;
+						subLineStart + portion.start.VirtualSpaceWidth(spaceWidth);
 					rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
-						subLineStart+portion.end.VirtualSpace() * spaceWidth;
+						subLineStart + portion.end.VirtualSpaceWidth(spaceWidth);
 					rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
 					rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
 					surface->FillRectangleAligned(rcSegment, Fill(
@@ -1149,8 +1149,8 @@ void EditView::DrawFoldDisplayText(Surface *surface, const EditModel &model, con
 	}
 
 	const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
-	const XYPOSITION virtualSpace = model.sel.VirtualSpaceFor(
-		model.pdoc->LineEnd(line)) * spaceWidth;
+	const XYPOSITION virtualSpace = static_cast<XYPOSITION>(model.sel.VirtualSpaceFor(
+		model.pdoc->LineEnd(line))) * spaceWidth;
 	rcSegment.left = xStart + ll->positions[ll->numCharsInLine] - subLineStart + virtualSpace + vsDraw.aveCharWidth;
 	rcSegment.right = rcSegment.left + static_cast<XYPOSITION>(widthFoldDisplayText);
 
@@ -1267,8 +1267,8 @@ void EditView::DrawEOLAnnotationText(Surface *surface, const EditModel &model, c
 		leftBoxSpace + rightBoxSpace);
 
 	const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
-	const XYPOSITION virtualSpace = model.sel.VirtualSpaceFor(
-		model.pdoc->LineEnd(line)) * spaceWidth;
+	const XYPOSITION virtualSpace = static_cast<XYPOSITION>(model.sel.VirtualSpaceFor(
+		model.pdoc->LineEnd(line))) * spaceWidth;
 	rcSegment.left = xStart +
 		ll->positions[ll->numCharsInLine] - subLineStart
 		+ virtualSpace + vsDraw.aveCharWidth;
@@ -1518,7 +1518,7 @@ void EditView::DrawCarets(Surface *surface, const EditModel &model, const ViewSt
 		}
 		const int offset = static_cast<int>(posCaret.Position() - posLineStart);
 		const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
-		const XYPOSITION virtualOffset = posCaret.VirtualSpace() * spaceWidth;
+		const XYPOSITION virtualOffset = posCaret.VirtualSpaceWidth(spaceWidth);
 		if (ll->InLine(offset, subLine) && offset <= ll->numCharsBeforeEOL) {
 			XYPOSITION xposCaret = ll->positions[offset] + virtualOffset - ll->positions[ll->LineStart(subLine)];
 			if (model.BidirectionalEnabled() && (posCaret.VirtualSpace() == 0)) {
@@ -1785,7 +1785,9 @@ void DrawTranslucentSelection(Surface *surface, const EditModel &model, const Vi
 				const ColourRGBA selectionBack = SelectionBackground(
 					model, vsDraw, model.sel.RangeType(r));
 				const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
-				const Interval intervalVirtual{ portion.start.VirtualSpace() * spaceWidth, portion.end.VirtualSpace() * spaceWidth };
+				const Interval intervalVirtual{
+					portion.start.VirtualSpaceWidth(spaceWidth),
+					portion.end.VirtualSpaceWidth(spaceWidth) };
 				if (model.BidirectionalEnabled()) {
 					const SelectionSegment portionInSubLine = portionInLine.Subtract(lineRange.start);
 
diff --git a/src/scintilla/src/Editor.cxx b/src/scintilla/src/Editor.cxx
index 283edff8f..8bc5d036a 100644
--- a/src/scintilla/src/Editor.cxx
+++ b/src/scintilla/src/Editor.cxx
@@ -106,15 +106,7 @@ constexpr bool IsLastStep(const DocModification &mh) noexcept {
 	    && ((mh.modificationType & finalMask) == finalMask);
 }
 
-}
-
-Timer::Timer() noexcept :
-		ticking(false), ticksToWait(0), tickerID{} {}
-
-Idler::Idler() noexcept :
-		state(false), idlerID(nullptr) {}
-
-static constexpr bool IsAllSpacesOrTabs(std::string_view sv) noexcept {
+constexpr bool IsAllSpacesOrTabs(std::string_view sv) noexcept {
 	for (const char ch : sv) {
 		// This is safe because IsSpaceOrTab() will return false for null terminators
 		if (!IsSpaceOrTab(ch))
@@ -123,6 +115,14 @@ static constexpr bool IsAllSpacesOrTabs(std::string_view sv) noexcept {
 	return true;
 }
 
+}
+
+Timer::Timer() noexcept :
+		ticking(false), ticksToWait(0), tickerID{} {}
+
+Idler::Idler() noexcept :
+		state(false), idlerID(nullptr) {}
+
 Editor::Editor() : durationWrapOneByte(0.000001, 0.00000001, 0.00001) {
 	ctrlID = 0;
 
@@ -202,6 +202,8 @@ Editor::Editor() : durationWrapOneByte(0.000001, 0.00000001, 0.00001) {
 	recordingMacro = false;
 	foldAutomatic = AutomaticFold::None;
 
+	insideWrapScroll = false;
+
 	convertPastes = true;
 
 	SetRepresentations();
@@ -267,7 +269,7 @@ PointDocument Editor::DocumentPointFromView(Point ptView) const {
 		ptDocument.y += ptOrigin.y;
 	} else {
 		ptDocument.x += xOffset;
-		ptDocument.y += topLine * vs.lineHeight;
+		ptDocument.y += static_cast<double>(topLine * vs.lineHeight);
 	}
 	return ptDocument;
 }
@@ -275,8 +277,7 @@ PointDocument Editor::DocumentPointFromView(Point ptView) const {
 Sci::Line Editor::TopLineOfMain() const noexcept {
 	if (HasMarginWindow())
 		return 0;
-	else
-		return topLine;
+	return topLine;
 }
 
 Point Editor::ClientSize() const {
@@ -310,8 +311,7 @@ Sci::Line Editor::LinesToScroll() const {
 	const Sci::Line retVal = LinesOnScreen() - 1;
 	if (retVal < 1)
 		return 1;
-	else
-		return retVal;
+	return retVal;
 }
 
 Sci::Line Editor::MaxScrollPos() const {
@@ -325,9 +325,8 @@ Sci::Line Editor::MaxScrollPos() const {
 	}
 	if (retVal < 0) {
 		return 0;
-	} else {
-		return retVal;
 	}
+	return retVal;
 }
 
 SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const {
@@ -626,7 +625,7 @@ void Editor::InvalidateWholeSelection() {
 
 /* For Line selection - the anchor and caret are always
    at the beginning and end of the region lines. */
-SelectionRange Editor::LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const {
+SelectionRange Editor::LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const noexcept {
 	if (currentPos_ > anchor_) {
 		anchor_ = SelectionPosition(pdoc->LineStartPosition(anchor_.Position()));
 		currentPos_ = SelectionPosition(pdoc->LineEndPosition(currentPos_.Position()));
@@ -743,9 +742,9 @@ void Editor::MultipleSelectAdd(AddNumber addNumber) {
 			// Common case is that the selection is completely within the target but
 			// may also have overlap at start or end.
 			if (rangeMainSelection.end < rangeTarget.end)
-				searchRanges.push_back(Range(rangeMainSelection.end, rangeTarget.end));
+				searchRanges.emplace_back(rangeMainSelection.end, rangeTarget.end);
 			if (rangeTarget.start < rangeMainSelection.start)
-				searchRanges.push_back(Range(rangeTarget.start, rangeMainSelection.start));
+				searchRanges.emplace_back(rangeTarget.start, rangeMainSelection.start);
 		} else {
 			// No overlap
 			searchRanges.push_back(rangeTarget);
@@ -903,18 +902,17 @@ SelectionPosition Editor::MovePositionSoVisible(SelectionPosition pos, int moveD
 	const Sci::Line lineDoc = pdoc->SciLineFromPosition(pos.Position());
 	if (pcs->GetVisible(lineDoc)) {
 		return pos;
+	}
+	Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
+	if (moveDir > 0) {
+		// lineDisplay is already line before fold as lines in fold use display line of line after fold
+		lineDisplay = std::clamp<Sci::Line>(lineDisplay, 0, pcs->LinesDisplayed());
+		return SelectionPosition(
+			pdoc->LineStart(pcs->DocFromDisplay(lineDisplay)));
 	} else {
-		Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
-		if (moveDir > 0) {
-			// lineDisplay is already line before fold as lines in fold use display line of line after fold
-			lineDisplay = std::clamp<Sci::Line>(lineDisplay, 0, pcs->LinesDisplayed());
-			return SelectionPosition(
-				pdoc->LineStart(pcs->DocFromDisplay(lineDisplay)));
-		} else {
-			lineDisplay = std::clamp<Sci::Line>(lineDisplay - 1, 0, pcs->LinesDisplayed());
-			return SelectionPosition(
-				pdoc->LineEnd(pcs->DocFromDisplay(lineDisplay)));
-		}
+		lineDisplay = std::clamp<Sci::Line>(lineDisplay - 1, 0, pcs->LinesDisplayed());
+		return SelectionPosition(
+			pdoc->LineEnd(pcs->DocFromDisplay(lineDisplay)));
 	}
 }
 
@@ -1113,9 +1111,9 @@ void Editor::MoveCaretInsideView(bool ensureVisible) {
 					false, false, UserVirtualSpace()),
 					Selection::SelTypes::none, ensureVisible);
 	} else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
-		const ptrdiff_t yOfLastLineFullyDisplayed = static_cast<ptrdiff_t>(rcClient.top) + (LinesOnScreen() - 1) * vs.lineHeight;
+		const ptrdiff_t yOfLastLineFullyDisplayed = static_cast<ptrdiff_t>(rcClient.top) + ((LinesOnScreen() - 1) * vs.lineHeight);
 		MovePositionTo(SPositionFromLocation(
-		            Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top + yOfLastLineFullyDisplayed)),
+		            Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top + static_cast<XYPOSITION>(yOfLastLineFullyDisplayed))),
 					false, false, UserVirtualSpace()),
 		        Selection::SelTypes::none, ensureVisible);
 	}
@@ -1543,7 +1541,7 @@ bool Editor::WrapBlock(Surface *surface, Sci::Line lineToWrap, Sci::Line lineToW
 
 	std::vector<int> linesAfterWrap(linesBeingWrapped);
 
-	size_t threads = std::min<size_t>({ linesBeingWrapped, view.maxLayoutThreads });
+	size_t threads = std::min<size_t>(linesBeingWrapped, view.maxLayoutThreads);
 	if (!surface->SupportsFeature(Supports::ThreadSafeMeasureWidths)) {
 		threads = 1;
 	}
@@ -1607,7 +1605,7 @@ bool Editor::WrapBlock(Surface *surface, Sci::Line lineToWrap, Sci::Line lineToW
 
 	// Multiply duration by number of threads to produce (near) equivalence to duration if single threaded
 	const double durationShortLines = epWrapping.Duration(true);
-	const double durationShortLinesThreads = durationShortLines * threads;
+	const double durationShortLinesThreads = durationShortLines * static_cast<double>(threads);
 
 	// Wrap all the long lines in the main thread.
 	// LayoutLine may then multi-thread over segments in each line.
@@ -1683,8 +1681,15 @@ bool Editor::WrapLines(WrapScope ws) {
 		// Decide where to start wrapping
 		Sci::Line lineToWrap = wrapPending.start;
 		Sci::Line lineToWrapEnd = std::min(wrapPending.end, pdoc->LinesTotal());
+
 		const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
-		const Sci::Line subLineTop = topLine - pcs->DisplayFromDoc(lineDocTop);
+		LineDocSub lineScrollTo;
+		if (scrollToAfterWrap) {
+			lineScrollTo = scrollToAfterWrap.value();
+		} else {
+			const Sci::Line subLineTop = topLine - pcs->DisplayFromDoc(lineDocTop);
+			lineScrollTo = { lineDocTop, subLineTop };
+		}
 		if (ws == WrapScope::wsVisible) {
 			lineToWrap = std::clamp(lineDocTop-5, wrapPending.start, pdoc->LinesTotal());
 			// Priority wrap to just after visible area.
@@ -1735,21 +1740,23 @@ bool Editor::WrapLines(WrapScope ws) {
 
 				wrapOccurred = WrapBlock(surface, lineToWrap, lineToWrapEnd);
 
-				goodTopLine = pcs->DisplayFromDoc(lineDocTop) + std::min(
-					subLineTop, static_cast<Sci::Line>(pcs->GetHeight(lineDocTop)-1));
+				goodTopLine = pcs->DisplayFromDocSub(lineScrollTo.lineDoc, lineScrollTo.subLine);
 			}
 		}
 
 		// If wrapping is done, bring it to resting position
 		if (wrapPending.start >= lineEndNeedWrap) {
 			wrapPending.Reset();
+			scrollToAfterWrap.reset();
 		}
 	}
 
 	if (wrapOccurred) {
+		insideWrapScroll = true;
 		SetScrollBars();
 		SetTopLine(std::clamp<Sci::Line>(goodTopLine, 0, MaxScrollPos()));
 		SetVerticalScrollPos();
+		insideWrapScroll = false;
 	}
 
 	return wrapOccurred;
@@ -1850,15 +1857,11 @@ void Editor::PaintSelMargin(Surface *surfaceWindow, const PRectangle &rc) {
 void Editor::RefreshPixMaps(Surface *surfaceWindow) {
 	view.RefreshPixMaps(surfaceWindow, vs);
 	marginView.RefreshPixMaps(surfaceWindow, vs);
-	if (view.bufferedDraw) {
+	if (view.bufferedDraw && !(view.pixmapLine && marginView.pixmapSelMargin)) {
 		const PRectangle rcClient = GetClientRectangle();
-		if (!view.pixmapLine) {
-			view.pixmapLine = surfaceWindow->AllocatePixMap(static_cast<int>(rcClient.Width()), vs.lineHeight);
-		}
-		if (!marginView.pixmapSelMargin) {
-			marginView.pixmapSelMargin = surfaceWindow->AllocatePixMap(vs.fixedColumnWidth,
-				static_cast<int>(rcClient.Height()));
-		}
+		view.pixmapLine = surfaceWindow->AllocatePixMap(static_cast<int>(rcClient.Width()), vs.lineHeight);
+		marginView.pixmapSelMargin = surfaceWindow->AllocatePixMap(vs.fixedColumnWidth,
+			static_cast<int>(rcClient.Height()));
 	}
 }
 
@@ -1872,7 +1875,6 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
 	RefreshStyleData();
 	if (paintState == PaintState::abandoned)
 		return;	// Scroll bars may have changed so need redraw
-	RefreshPixMaps(surfaceWindow);
 
 	paintAbandonedByStyling = false;
 
@@ -1884,7 +1886,6 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
 
 	if (NotifyUpdateUI()) {
 		RefreshStyleData();
-		RefreshPixMaps(surfaceWindow);
 	}
 
 	// Wrap the visible lines if needed.
@@ -1894,9 +1895,10 @@ void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
 		if (AbandonPaint()) {
 			return;
 		}
-		RefreshPixMaps(surfaceWindow);	// In case pixmaps invalidated by scrollbar change
 	}
 
+	RefreshPixMaps(surfaceWindow);
+
 	if (!marginView.pixmapSelPattern->Initialised()) {
 		// When Direct2D is used, pixmap creation may fail with D2DERR_RECREATE_TARGET so
 		// abandon this paint to avoid further failures.
@@ -1990,8 +1992,13 @@ long Editor::TextWidth(uptr_t style, const char *text) {
 	AutoSurface surface(this);
 	if (surface) {
 		return std::lround(surface->WidthText(vs.styles[style].font.get(), text));
-	} else {
-		return 1;
+	}
+	return 1;
+}
+
+void Editor::SetVerticalScrollPos() {
+	if (!insideWrapScroll) {
+		scrollToAfterWrap.reset();
 	}
 }
 
@@ -2047,11 +2054,10 @@ Sci::Position Editor::RealizeVirtualSpace(Sci::Position position, Sci::Position
 		const Sci::Position indent = pdoc->GetLineIndentPosition(line);
 		if (indent == position) {
 			return pdoc->SetLineIndentation(line, pdoc->GetLineIndentation(line) + virtualSpace);
-		} else {
-			const std::string spaceText(virtualSpace, ' ');
-			const Sci::Position lengthInserted = pdoc->InsertString(position, spaceText);
-			position += lengthInserted;
 		}
+		const std::string spaceText(virtualSpace, ' ');
+		const Sci::Position lengthInserted = pdoc->InsertString(position, spaceText);
+		position += lengthInserted;
 	}
 	return position;
 }
@@ -2409,12 +2415,14 @@ void Editor::SelectAll() {
 
 void Editor::RestoreSelection(Sci::Position newPos, UndoRedo history) {
 	EnsureModelState();
-	if ((undoSelectionHistoryOption == UndoSelectionHistoryOption::Enabled) && modelState) {
+	if (FlagSet(undoSelectionHistoryOption, UndoSelectionHistoryOption::Enabled) && modelState) {
 		// Undo wants the element after the current as it just undid it
 		const int index = pdoc->UndoCurrent() + (history == UndoRedo::undo ? 1 : 0);
 		const SelectionWithScroll selAndLine = modelState->SelectionFromStack(index, history);
 		if (!selAndLine.selection.empty()) {
-			ScrollTo(selAndLine.topLine);
+			if (FlagSet(undoSelectionHistoryOption, UndoSelectionHistoryOption::Scroll)) {
+				ScrollTo(selAndLine.topLine);
+			}
 			sel = Selection(selAndLine.selection);
 			if (sel.IsRectangular()) {
 				const size_t mainForRectangular = sel.Main();
@@ -2654,9 +2662,8 @@ bool Editor::NotifyMarginClick(Point pt, KeyMod modifiers) {
 		scn.margin = marginClicked;
 		NotifyParent(scn);
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
 bool Editor::NotifyMarginRightClick(Point pt, KeyMod modifiers) {
@@ -2670,9 +2677,8 @@ bool Editor::NotifyMarginRightClick(Point pt, KeyMod modifiers) {
 		scn.margin = marginRightClicked;
 		NotifyParent(scn);
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
 void Editor::NotifyNeedShown(Sci::Position pos, Sci::Position len) {
@@ -2746,12 +2752,10 @@ constexpr Sci::Position MovePositionForDeletion(Sci::Position position, Sci::Pos
 		const Sci::Position endDeletion = startDeletion + length;
 		if (position > endDeletion) {
 			return position - length;
-		} else {
-			return startDeletion;
 		}
-	} else {
-		return position;
+		return startDeletion;
 	}
+	return position;
 }
 
 }
@@ -2799,7 +2803,7 @@ void Editor::NotifyModified(Document *, DocModification mh, void *) {
 			view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
 		}
 	} else {
-		if ((undoSelectionHistoryOption == UndoSelectionHistoryOption::Enabled) &&
+		if (FlagSet(undoSelectionHistoryOption, UndoSelectionHistoryOption::Enabled) &&
 			FlagSet(mh.modificationType, ModificationFlags::User)) {
 			if (FlagSet(mh.modificationType, ModificationFlags::BeforeInsert | ModificationFlags::BeforeDelete)) {
 				RememberSelectionForUndo(pdoc->UndoCurrent());
@@ -3143,7 +3147,7 @@ void Editor::ChangeCaseOfSelection(CaseMapping caseMapping) {
 		SelectionRange currentNoVS = current;
 		currentNoVS.ClearVirtualSpace();
 		const size_t rangeBytes = currentNoVS.Length();
-		if (rangeBytes > 0) {
+		if (rangeBytes > 0 && !RangeContainsProtected(currentNoVS)) {
 			std::string sText = RangeText(currentNoVS.Start().Position(), currentNoVS.End().Position());
 
 			std::string sMapped = CaseMapString(sText, caseMapping);
@@ -3366,7 +3370,7 @@ SelectionPosition Editor::PositionUpOrDown(SelectionPosition spStart, int direct
 		// There is an equivalent case when moving down which skips
 		// over a line.
 		Point ptNew = LocationFromPosition(posNew.Position());
-		while ((posNew.Position() > spStart.Position()) && (ptNew.y > newY)) {
+		while ((posNew.Position() > spStart.Position()) && (ptNew.y > static_cast<XYPOSITION>(newY))) {
 			posNew.Add(-1);
 			posNew.SetVirtualSpace(0);
 			ptNew = LocationFromPosition(posNew.Position());
@@ -3452,9 +3456,8 @@ Sci::Position Editor::StartEndDisplayLine(Sci::Position pos, bool start) {
 	const Sci::Position posRet = view.StartEndDisplayLine(surface, *this, pos, start, vs);
 	if (posRet == Sci::invalidPosition) {
 		return pos;
-	} else {
-		return posRet;
 	}
+	return posRet;
 }
 
 namespace {
@@ -3564,19 +3567,19 @@ Sci::Position Editor::HomeWrapPosition(Sci::Position position) {
 Sci::Position Editor::VCHomeDisplayPosition(Sci::Position position) {
 	const Sci::Position homePos = pdoc->VCHomePosition(position);
 	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
-	if (viewLineStart > homePos)
+	if (viewLineStart > homePos) {
 		return viewLineStart;
-	else
-		return homePos;
+	}
+	return homePos;
 }
 
 Sci::Position Editor::VCHomeWrapPosition(Sci::Position position) {
 	const Sci::Position homePos = pdoc->VCHomePosition(position);
 	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
-	if ((viewLineStart < position) && (viewLineStart > homePos))
+	if ((viewLineStart < position) && (viewLineStart > homePos)) {
 		return viewLineStart;
-	else
-		return homePos;
+	}
+	return homePos;
 }
 
 Sci::Position Editor::LineEndWrapPosition(Sci::Position position) {
@@ -3585,8 +3588,7 @@ Sci::Position Editor::LineEndWrapPosition(Sci::Position position) {
 	if (endPos > realEndPos      // if moved past visible EOLs
 		|| position >= endPos) // if at end of display line already
 		return realEndPos;
-	else
-		return endPos;
+	return endPos;
 }
 
 SelectionPosition Editor::PositionMove(Message iMessage, SelectionPosition spCaret) {
@@ -4144,11 +4146,10 @@ int Editor::KeyDownWithModifiers(Keys key, KeyMod modifiers, bool *consumed) {
 		if (consumed)
 			*consumed = true;
 		return static_cast<int>(WndProc(msg, 0, 0));
-	} else {
-		if (consumed)
-			*consumed = false;
-		return KeyDefault(key, modifiers);
 	}
+	if (consumed)
+		*consumed = false;
+	return KeyDefault(key, modifiers);
 }
 
 void Editor::Indent(bool forwards, bool lineIndent) {
@@ -4175,7 +4176,7 @@ void Editor::Indent(bool forwards, bool lineIndent) {
 						sel.Range(r) = SelectionRange(caretPosition + lengthInserted);
 					} else {
 						int numSpaces = (pdoc->tabInChars) -
-								(pdoc->GetColumn(caretPosition) % (pdoc->tabInChars));
+								static_cast<int>((pdoc->GetColumn(caretPosition) % (pdoc->tabInChars)));
 						if (numSpaces < 1)
 							numSpaces = pdoc->tabInChars;
 						const std::string spaceText(numSpaces, ' ');
@@ -4402,7 +4403,9 @@ void Editor::GoToLine(Sci::Line lineNo) {
 	EnsureCaretVisible();
 }
 
-static bool Close(Point pt1, Point pt2, Point threshold) noexcept {
+namespace {
+
+bool Close(Point pt1, Point pt2, Point threshold) noexcept {
 	const Point ptDifference = pt2 - pt1;
 	if (std::abs(ptDifference.x) > threshold.x)
 		return false;
@@ -4411,6 +4414,12 @@ static bool Close(Point pt1, Point pt2, Point threshold) noexcept {
 	return true;
 }
 
+constexpr bool AllowVirtualSpace(VirtualSpace virtualSpaceOptions, bool rectangular) noexcept {
+	return FlagSet(virtualSpaceOptions, (rectangular ? VirtualSpace::RectangularSelection : VirtualSpace::UserAccessible));
+}
+
+}
+
 std::string Editor::RangeText(Sci::Position start, Sci::Position end) const {
 	if (start < end) {
 		const Sci::Position len = end - start;
@@ -4418,7 +4427,7 @@ std::string Editor::RangeText(Sci::Position start, Sci::Position end) const {
 		pdoc->GetCharRange(ret.data(), start, len);
 		return ret;
 	}
-	return std::string();
+	return {};
 }
 
 bool Editor::CopyLineRange(SelectionText *ss, bool allowProtected) {
@@ -4432,9 +4441,8 @@ bool Editor::CopyLineRange(SelectionText *ss, bool allowProtected) {
 		ss->Copy(text, pdoc->dbcsCodePage,
 			vs.styles[StyleDefault].characterSet, false, true);
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
 void Editor::CopySelectionRange(SelectionText *ss, bool allowLineCopy) {
@@ -4621,7 +4629,7 @@ bool Editor::PointInSelection(Point pt) {
 }
 
 ptrdiff_t Editor::SelectionFromPoint(Point pt) {
-	// Prioritize checking inside non-empty selections since each character will be inside only 1 
+	// Prioritize checking inside non-empty selections since each character will be inside only 1
 	const SelectionPosition posChar = SPositionFromLocation(pt, true, true);
 	for (size_t r = 0; r < sel.Count(); r++) {
 		if (sel.Range(r).ContainsCharacter(posChar)) {
@@ -4651,9 +4659,8 @@ bool Editor::PointInSelMargin(Point pt) const {
 		const Point ptOrigin = GetVisibleOriginInMain();
 		rcSelMargin.Move(0, -ptOrigin.y);
 		return rcSelMargin.ContainsWholePixel(pt);
-	} else {
-		return false;
 	}
+	return false;
 }
 
 Window::Cursor Editor::GetMarginCursor(Point pt) const noexcept {
@@ -4756,10 +4763,6 @@ void Editor::MouseLeave() {
 	}
 }
 
-static constexpr bool AllowVirtualSpace(VirtualSpace virtualSpaceOptions, bool rectangular) noexcept {
-	return FlagSet(virtualSpaceOptions, (rectangular ? VirtualSpace::RectangularSelection : VirtualSpace::UserAccessible));
-}
-
 void Editor::ButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
 	SetHoverIndicatorPoint(pt);
 	//Platform::DebugPrintf("ButtonDown %d %d = %d alt=%d %d\n", curTime, lastClickTime, curTime - lastClickTime, alt, inDragDrop);
@@ -4907,10 +4910,9 @@ void Editor::ButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modi
 							DropSelection(selectionPart);
 							// Completed: don't want any more processing of this click
 							return;
-						} else {
-							// Switch to just the click position
-							SetSelection(newPos, newPos);
 						}
+						// Switch to just the click position
+						SetSelection(newPos, newPos);
 					}
 					if (!sel.Range(selectionPart).Empty()) {
 						inDragDrop = DragDrop::initial;
@@ -5344,10 +5346,10 @@ Sci::Position Editor::PositionAfterArea(PRectangle rcArea) const {
 	// This often means that the line after a modification is restyled which helps
 	// detect multiline comment additions and heals single line comments
 	const Sci::Line lineAfter = TopLineOfMain() + static_cast<Sci::Line>(rcArea.bottom - 1) / vs.lineHeight + 1;
-	if (lineAfter < pcs->LinesDisplayed())
+	if (lineAfter < pcs->LinesDisplayed()) {
 		return pdoc->LineStart(pcs->DocFromDisplay(lineAfter) + 1);
-	else
-		return pdoc->Length();
+	}
+	return pdoc->Length();
 }
 
 // Style to a position within the view. If this causes a change at end of last line then
@@ -5450,9 +5452,8 @@ int Editor::SupportsFeature(Supports feature) {
 bool Editor::PaintContains(PRectangle rc) {
 	if (rc.Empty()) {
 		return true;
-	} else {
-		return rcPaint.Contains(rc);
 	}
+	return rcPaint.Contains(rc);
 }
 
 bool Editor::PaintContainsMargin() {
@@ -5556,6 +5557,8 @@ void Editor::SetDocPointer(Document *document) {
 
 	SetRepresentations();
 
+	scrollToAfterWrap.reset();
+
 	// Reset the contraction state to fully shown.
 	pcs->Clear();
 	pcs->InsertLines(0, pdoc->LinesTotal() - 1);
@@ -5695,7 +5698,7 @@ void Editor::FoldExpand(Sci::Line line, FoldAction action, FoldLevel level) {
 	Redraw();
 }
 
-Sci::Line Editor::ContractedFoldNext(Sci::Line lineStart) const {
+Sci::Line Editor::ContractedFoldNext(Sci::Line lineStart) const noexcept {
 	for (Sci::Line line = lineStart; line<pdoc->LinesTotal();) {
 		if (!pcs->GetExpanded(line) && LevelIsHeader(pdoc->GetFoldLevel(line)))
 			return line;
@@ -5946,8 +5949,7 @@ bool Editor::IsUnicodeMode() const noexcept {
 int Editor::CodePage() const noexcept {
 	if (pdoc)
 		return pdoc->dbcsCodePage;
-	else
-		return 0;
+	return 0;
 }
 
 std::unique_ptr<Surface> Editor::CreateMeasurementSurface() const {
@@ -5977,9 +5979,8 @@ Sci::Line Editor::WrapCount(Sci::Line line) {
 	if (surface && ll) {
 		view.LayoutLine(*this, surface, vs, ll.get(), wrapWidth);
 		return ll->lines;
-	} else {
-		return 1;
 	}
+	return 1;
 }
 
 void Editor::AddStyledText(const char *buffer, Sci::Position appendLength) {
@@ -6567,6 +6568,15 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		HorizontalScrollTo(xOffset + static_cast<int>(static_cast<int>(wParam) * vs.spaceWidth));
 		return 1;
 
+	case Message::ScrollVertical:
+		if (Wrapping()) {
+			scrollToAfterWrap = { LineFromUPtr(wParam), lParam };
+		} else {
+			scrollToAfterWrap.reset();
+		}
+		ScrollTo(pcs->DisplayFromDocSub(LineFromUPtr(wParam), lParam));
+		break;
+
 	case Message::SetXOffset:
 		xOffset = static_cast<int>(wParam);
 		ContainerNeedsUpdate(Update::HScroll);
@@ -7483,7 +7493,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 	case Message::MarkerSetStrokeWidth:
 		if (wParam <= MarkerMax)
-			vs.markers[wParam].strokeWidth = lParam / 100.0f;
+			vs.markers[wParam].strokeWidth = static_cast<XYPOSITION>(lParam) / 100.0f;
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
@@ -8177,7 +8187,7 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case Message::IndicSetStrokeWidth:
 		if (wParam <= IndicatorMax && lParam >= 0 && lParam <= 1000) {
-			vs.indicators[wParam].strokeWidth = lParam / 100.0f;
+			vs.indicators[wParam].strokeWidth = static_cast<XYPOSITION>(lParam) / 100.0;
 			InvalidateStyleRedraw();
 		}
 		break;
@@ -8448,7 +8458,8 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 			doc->Allocate(PositionFromUPtr(wParam));
 			doc->SetUndoCollection(false);
 			pcs = ContractionStateCreate(pdoc->IsLarge());
-			return reinterpret_cast<sptr_t>(static_cast<ILoader *>(doc));
+			ILoader *loader = doc;
+			return reinterpret_cast<sptr_t>(loader);
 		}
 
 	case Message::SetModEventMask:
diff --git a/src/scintilla/src/Editor.h b/src/scintilla/src/Editor.h
index ff940bc49..f8bc18970 100644
--- a/src/scintilla/src/Editor.h
+++ b/src/scintilla/src/Editor.h
@@ -283,6 +283,12 @@ class Editor : public EditModel, public DocWatcher {
 	// Wrapping support
 	WrapPending wrapPending;
 	ActionDuration durationWrapOneByte;
+	bool insideWrapScroll;
+	struct LineDocSub {
+		Scintilla::Line lineDoc = 0;
+		Scintilla::Line subLine = 0;
+	};
+	std::optional<LineDocSub> scrollToAfterWrap;
 
 	bool convertPastes;
 
@@ -346,7 +352,7 @@ class Editor : public EditModel, public DocWatcher {
 	void ThinRectangularRange();
 	void InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection=false);
 	void InvalidateWholeSelection();
-	SelectionRange LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const;
+	SelectionRange LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const noexcept;
 	void SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_);
 	void SetSelection(Sci::Position currentPos_, Sci::Position anchor_);
 	void SetSelection(SelectionPosition currentPos_);
@@ -417,7 +423,7 @@ class Editor : public EditModel, public DocWatcher {
 	Sci::Position FormatRange(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
 	long TextWidth(Scintilla::uptr_t style, const char *text);
 
-	virtual void SetVerticalScrollPos() = 0;
+	virtual void SetVerticalScrollPos();
 	virtual void SetHorizontalScrollPos() = 0;
 	virtual bool ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) = 0;
 	virtual void ReconfigureScrollBars();
@@ -593,7 +599,7 @@ class Editor : public EditModel, public DocWatcher {
 	void SetFoldExpanded(Sci::Line lineDoc, bool expanded);
 	void FoldLine(Sci::Line line, Scintilla::FoldAction action);
 	void FoldExpand(Sci::Line line, Scintilla::FoldAction action, Scintilla::FoldLevel level);
-	Sci::Line ContractedFoldNext(Sci::Line lineStart) const;
+	Sci::Line ContractedFoldNext(Sci::Line lineStart) const noexcept;
 	void EnsureLineVisible(Sci::Line lineDoc, bool enforcePolicy);
 	void FoldChanged(Sci::Line line, Scintilla::FoldLevel levelNow, Scintilla::FoldLevel levelPrev);
 	void NeedShown(Sci::Position pos, Sci::Position len);
diff --git a/src/scintilla/src/LineMarker.cxx b/src/scintilla/src/LineMarker.cxx
index 0afa64f2b..31287883a 100644
--- a/src/scintilla/src/LineMarker.cxx
+++ b/src/scintilla/src/LineMarker.cxx
@@ -196,7 +196,7 @@ void LineMarker::DrawFoldingMark(Surface *surface, const PRectangle &rcWhole, Fo
 	// To centre +/-, odd strokeWidth -> odd symbol width, even -> even
 	const XYPOSITION widthSymbol =
 		((std::lround(minDimension * pixelDivisions) % 2) == (std::lround(widthStroke * pixelDivisions) % 2)) ?
-		minDimension : minDimension - 1.0f / pixelDivisions;
+		minDimension : minDimension - (1.0 / static_cast<XYPOSITION>(pixelDivisions));
 
 	const Point centre = PixelAlign(rcWhole.Centre(), pixelDivisions);
 
@@ -464,11 +464,13 @@ void LineMarker::Draw(Surface *surface, const PRectangle &rcWhole, const Font *f
 		break;
 
 	case MarkerSymbol::DotDotDot: {
-			XYPOSITION right = static_cast<XYPOSITION>(centreX - 6);
+			// 3 2x2 dots with 3 pixels between, margin must be 12 wide to show all
+			constexpr XYPOSITION pitchDots = 5.0;
+			XYPOSITION xBlob = std::floor(centreX - (pitchDots + 1));
 			for (int b = 0; b < 3; b++) {
-				const PRectangle rcBlob(right, rc.bottom - 4, right + 2, rc.bottom - 2);
+				const PRectangle rcBlob(xBlob, rc.bottom - 4, xBlob + 2, rc.bottom - 2);
 				surface->FillRectangle(rcBlob, fore);
-				right += 5.0f;
+				xBlob += pitchDots;
 			}
 		}
 		break;
@@ -516,26 +518,28 @@ void LineMarker::Draw(Surface *surface, const PRectangle &rcWhole, const Font *f
 		break;
 
 	case MarkerSymbol::Bar: {
+			// Hide cap by continuing a bit.
+			constexpr XYPOSITION continueLength = 5.0;
 			PRectangle rcBar = rcWhole;
-			const XYPOSITION widthBar = std::floor(rcWhole.Width() / 3.0);
+			const XYPOSITION widthBar = std::ceil(rcWhole.Width() / 3.0);
 			rcBar.left = centreX - std::floor(widthBar / 2.0);
 			rcBar.right = rcBar.left + widthBar;
-			surface->SetClip(rcWhole);
+			surface->SetClip(rcWhole);	// Hide continued caps
 			switch (part) {
 			case LineMarker::FoldPart::headWithTail:
 				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
 				break;
 			case LineMarker::FoldPart::head:
-				rcBar.bottom += 5;
+				rcBar.bottom += continueLength;
 				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
 				break;
 			case LineMarker::FoldPart::tail:
-				rcBar.top -= 5;
+				rcBar.top -= continueLength;
 				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
 				break;
 			case LineMarker::FoldPart::body:
-				rcBar.top -= 5;
-				rcBar.bottom += 5;
+				rcBar.top -= continueLength;
+				rcBar.bottom += continueLength;
 				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
 				break;
 			default:
diff --git a/src/scintilla/src/MarginView.cxx b/src/scintilla/src/MarginView.cxx
index 348b5dd05..18c1b33b0 100644
--- a/src/scintilla/src/MarginView.cxx
+++ b/src/scintilla/src/MarginView.cxx
@@ -124,7 +124,7 @@ void MarginView::DropGraphics() noexcept {
 }
 
 void MarginView::RefreshPixMaps(Surface *surfaceWindow, const ViewStyle &vsDraw) {
-	if (!pixmapSelPattern) {
+	if (!(pixmapSelPattern && pixmapSelPatternOffset1)) {
 		constexpr int patternSize = 8;
 		pixmapSelPattern = surfaceWindow->AllocatePixMap(patternSize, patternSize);
 		pixmapSelPatternOffset1 = surfaceWindow->AllocatePixMap(patternSize, patternSize);
@@ -278,7 +278,7 @@ void MarginView::PaintOneMargin(Surface *surface, PRectangle rc, PRectangle rcOn
 	const Point ptOrigin = model.GetVisibleOriginInMain();
 	const Sci::Line lineStartPaint = static_cast<Sci::Line>(rcOneMargin.top + ptOrigin.y) / vs.lineHeight;
 	Sci::Line visibleLine = model.TopLineOfMain() + lineStartPaint;
-	XYPOSITION yposScreen = lineStartPaint * vs.lineHeight - ptOrigin.y;
+	XYPOSITION yposScreen = static_cast<XYPOSITION>(lineStartPaint * vs.lineHeight) - ptOrigin.y;
 	// Work out whether the top line is whitespace located after a
 	// lessening of fold level which implies a 'fold tail' but which should not
 	// be displayed until the last of a sequence of whitespace.
diff --git a/src/scintilla/src/Platform.h b/src/scintilla/src/Platform.h
index 77464945e..119b4ef3f 100644
--- a/src/scintilla/src/Platform.h
+++ b/src/scintilla/src/Platform.h
@@ -317,6 +317,7 @@ struct ListOptions {
 	std::optional<ColourRGBA> foreSelected;
 	std::optional<ColourRGBA> backSelected;
 	AutoCompleteOption options=AutoCompleteOption::Normal;
+	float imageScale=1.0f;
 };
 
 class ListBox : public Window {
diff --git a/src/scintilla/src/PositionCache.cxx b/src/scintilla/src/PositionCache.cxx
index df5e5acf9..1f3a803fc 100644
--- a/src/scintilla/src/PositionCache.cxx
+++ b/src/scintilla/src/PositionCache.cxx
@@ -81,23 +81,17 @@ LineLayout::LineLayout(Sci::Line lineNumber_, int maxLineLength_) :
 	Resize(maxLineLength_);
 }
 
-LineLayout::~LineLayout() {
-	Free();
-}
-
 void LineLayout::Resize(int maxLineLength_) {
 	if (maxLineLength_ > maxLineLength) {
-		Free();
 		const size_t lineAllocation = maxLineLength_ + 1;
 		chars = std::make_unique<char[]>(lineAllocation);
 		styles = std::make_unique<unsigned char []>(lineAllocation);
 		// Extra position allocated as sometimes the Windows
 		// GetTextExtentExPoint API writes an extra element.
 		positions = std::make_unique<XYPOSITION []>(lineAllocation + 1);
-		if (bidiData) {
-			bidiData->Resize(maxLineLength_);
-		}
-
+		lineStarts.reset();
+		bidiData.reset();
+		lenLineStarts = 0;
 		maxLineLength = maxLineLength_;
 	}
 }
@@ -116,15 +110,6 @@ void LineLayout::EnsureBidiData() {
 	}
 }
 
-void LineLayout::Free() noexcept {
-	chars.reset();
-	styles.reset();
-	positions.reset();
-	lineStarts.reset();
-	lenLineStarts = 0;
-	bidiData.reset();
-}
-
 void LineLayout::ClearPositions() {
 	std::fill(&positions[0], &positions[maxLineLength + 2], 0.0f);
 }
@@ -203,7 +188,7 @@ int LineLayout::SubLineFromPosition(int posInLine, PointEnd pe) const noexcept {
 void LineLayout::AddLineStart(Sci::Position start) {
 	lines++;
 	if (lines >= lenLineStarts) {
-		const int newMaxLines = lines + 20;
+		const int newMaxLines = lines * 2 + 4;
 		std::unique_ptr<int[]> newLineStarts = std::make_unique<int[]>(newMaxLines);
 		if (lenLineStarts) {
 			std::copy(lineStarts.get(), lineStarts.get() + lenLineStarts, newLineStarts.get());
@@ -338,8 +323,8 @@ int LineLayout::EndLineStyle() const noexcept {
 void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap wrapState, XYPOSITION wrapWidth) {
 	// Document wants document positions but simpler to work in line positions
 	// so take care of adding and subtracting line start in a lambda.
-	auto CharacterBoundary = [=](Sci::Position i, Sci::Position moveDir) noexcept -> Sci::Position {
-		return pdoc->MovePositionOutsideChar(i + posLineStart, moveDir) - posLineStart;
+	auto CharacterBoundary = [=](Sci::Position i, int moveDir) noexcept -> Sci::Position {
+		return pdoc->NextPosition(i + posLineStart, moveDir) - posLineStart;
 	};
 	lines = 0;
 	// Calculate line start positions based upon width.
@@ -353,8 +338,9 @@ void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap
 		if (p < numCharsInLine) {
 			// backtrack to find lastGoodBreak
 			Sci::Position lastGoodBreak = p;
+			// Try moving to start of last character
 			if (p > 0) {
-				lastGoodBreak = CharacterBoundary(p, -1);
+				lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1) - posLineStart;
 			}
 			bool foundBreak = false;
 			if (wrapState != Wrap::Char) {
@@ -367,7 +353,7 @@ void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap
 					if (IsBreakSpace(chars[pos - 1]) && !IsBreakSpace(chars[pos])) {
 						break;
 					}
-					pos = CharacterBoundary(pos - 1, -1);
+					pos = CharacterBoundary(pos, -1);
 				}
 				if (pos > lastLineStart) {
 					lastGoodBreak = pos;
@@ -377,25 +363,19 @@ void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap
 			if (!foundBreak) {
 				if (CpUtf8 == pdoc->dbcsCodePage) {
 					// Go back before a base character, commonly a letter as modifiers are after the letter they modify
-					std::string_view svWithoutLast(&chars[lastLineStart], CharacterBoundary(p + 1, 1) - lastLineStart);
+					const Sci::Position afterWrap = CharacterBoundary(lastGoodBreak, 1);
+					std::string_view svWithoutLast(&chars[lastLineStart], afterWrap - lastLineStart);
 					if (DiscardLastCombinedCharacter(svWithoutLast) && !svWithoutLast.empty()) {
 						lastGoodBreak = lastLineStart + static_cast<Sci::Position>(svWithoutLast.length());
-						foundBreak = true;
-					}
-				}
-				if (!foundBreak) {
-					// Try moving to start of last character
-					if (p > 0) {
-						lastGoodBreak = CharacterBoundary(p, -1);
 					}
 				}
 				if (lastGoodBreak == lastLineStart) {
 					// Ensure at least one character on line.
-					lastGoodBreak = CharacterBoundary(lastGoodBreak + 1, 1);
+					lastGoodBreak = CharacterBoundary(lastGoodBreak, 1);
 				}
 			}
+			AddLineStart(lastGoodBreak);
 			lastLineStart = lastGoodBreak;
-			AddLineStart(lastLineStart);
 			startOffset = positions[lastLineStart];
 			// take into account the space for start wrap mark and indent
 			startOffset += wrapWidth - wrapIndent;
@@ -1133,7 +1113,7 @@ void PositionCache::MeasureWidths(Surface *surface, const ViewStyle &vstyle, uns
 		if (AllGraphicASCII(sv)) {
 			const XYPOSITION monospaceCharacterWidth = style.monospaceCharacterWidth;
 			for (size_t i = 0; i < sv.length(); i++) {
-				positions[i] = monospaceCharacterWidth * (i+1);
+				positions[i] = monospaceCharacterWidth * static_cast<XYPOSITION>(i+1);
 			}
 			return;
 		}
diff --git a/src/scintilla/src/PositionCache.h b/src/scintilla/src/PositionCache.h
index 4b35ec092..b912c2fcc 100644
--- a/src/scintilla/src/PositionCache.h
+++ b/src/scintilla/src/PositionCache.h
@@ -76,16 +76,9 @@ class LineLayout {
 	XYPOSITION wrapIndent; // In pixels
 
 	LineLayout(Sci::Line lineNumber_, int maxLineLength_);
-	// Deleted so LineLayout objects can not be copied.
-	LineLayout(const LineLayout &) = delete;
-	LineLayout(LineLayout &&) = delete;
-	void operator=(const LineLayout &) = delete;
-	void operator=(LineLayout &&) = delete;
-	virtual ~LineLayout();
 	void Resize(int maxLineLength_);
 	void ReSet(Sci::Line lineNumber_, Sci::Position maxLineLength_);
 	void EnsureBidiData();
-	void Free() noexcept;
 	void ClearPositions();
 	void Invalidate(ValidLevel validity_) noexcept;
 	Sci::Line LineNumber() const noexcept;
diff --git a/src/scintilla/src/ScintillaBase.cxx b/src/scintilla/src/ScintillaBase.cxx
index a95df76ae..1f4c360da 100644
--- a/src/scintilla/src/ScintillaBase.cxx
+++ b/src/scintilla/src/ScintillaBase.cxx
@@ -70,8 +70,7 @@ ScintillaBase::ScintillaBase() {
 	multiAutoCMode = MultiAutoComplete::Once;
 }
 
-ScintillaBase::~ScintillaBase() {
-}
+ScintillaBase::~ScintillaBase() = default;
 
 void ScintillaBase::Finalise() {
 	Editor::Finalise();
@@ -133,6 +132,9 @@ void ScintillaBase::Command(int cmdId) {
 	case idcmdSelectAll:
 		WndProc(Message::SelectAll, 0, 0);
 		break;
+
+	default:
+		break;
 	}
 }
 
@@ -213,6 +215,30 @@ void ScintillaBase::ListNotify(ListBoxEvent *plbe) {
 	}
 }
 
+void ScintillaBase::MoveImeCarets(Sci::Position offset) noexcept {
+	// Move carets relatively by bytes.
+	for (size_t r = 0; r < sel.Count(); r++) {
+		const Sci::Position positionInsert = sel.Range(r).Start().Position();
+		sel.Range(r) = SelectionRange(positionInsert + offset);
+	}
+}
+
+void ScintillaBase::DrawImeIndicator(int indicator, Sci::Position len) {
+	// Emulate the visual style of IME characters with indicators.
+	// Draw an indicator on the character before caret by the character bytes of len
+	// so it should be called after InsertCharacter().
+	// It does not affect caret positions.
+	const IndicatorNumbers ind = static_cast<IndicatorNumbers>(indicator);
+	if (ind < IndicatorNumbers::Container || ind > IndicatorNumbers::Max) {
+		return;
+	}
+	pdoc->DecorationSetCurrentIndicator(indicator);
+	for (size_t r = 0; r < sel.Count(); r++) {
+		const Sci::Position positionInsert = sel.Range(r).Start().Position();
+		pdoc->DecorationFillRange(positionInsert - len, 1, len);
+	}
+}
+
 void ScintillaBase::AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, std::string_view text) {
 	UndoGroup ug(pdoc);
 	if (multiAutoCMode == MultiAutoComplete::Once) {
@@ -270,6 +296,7 @@ void ScintillaBase::AutoCompleteStart(Sci::Position lenEntered, const char *list
 		vs.ElementColour(Element::ListSelected),
 		vs.ElementColour(Element::ListSelectedBack),
 		ac.options,
+		ac.imageScale,
 	};
 
 	int lineHeight;
@@ -582,8 +609,8 @@ class LexState : public LexInterface {
 
 	const char *DescribeWordListSets();
 	void SetWordList(int n, const char *wl);
-	int GetIdentifier() const;
-	const char *GetName() const;
+	[[nodiscard]] int GetIdentifier() const;
+	[[nodiscard]] const char *GetName() const;
 	void *PrivateCall(int operation, void *pointer);
 	const char *PropertyNames();
 	TypeProperty PropertyType(const char *name);
@@ -623,9 +650,8 @@ LexState *ScintillaBase::DocumentLexState() {
 const char *LexState::DescribeWordListSets() {
 	if (instance) {
 		return instance->DescribeWordListSets();
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 void LexState::SetWordList(int n, const char *wl) {
@@ -654,33 +680,29 @@ const char *LexState::GetName() const {
 void *LexState::PrivateCall(int operation, void *pointer) {
 	if (instance) {
 		return instance->PrivateCall(operation, pointer);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 const char *LexState::PropertyNames() {
 	if (instance) {
 		return instance->PropertyNames();
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 TypeProperty LexState::PropertyType(const char *name) {
 	if (instance) {
 		return static_cast<TypeProperty>(instance->PropertyType(name));
-	} else {
-		return TypeProperty::Boolean;
 	}
+	return TypeProperty::Boolean;
 }
 
 const char *LexState::DescribeProperty(const char *name) {
 	if (instance) {
 		return instance->DescribeProperty(name);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 void LexState::PropSet(const char *key, const char *val) {
@@ -695,9 +717,8 @@ void LexState::PropSet(const char *key, const char *val) {
 const char *LexState::PropGet(const char *key) const {
 	if (instance) {
 		return instance->PropertyGet(key);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 int LexState::PropGetInt(const char *key, int defaultValue) const {
@@ -782,39 +803,35 @@ const char *LexState::GetSubStyleBases() {
 int LexState::NamedStyles() {
 	if (instance) {
 		return instance->NamedStyles();
-	} else {
-		return -1;
 	}
+	return -1;
 }
 
 const char *LexState::NameOfStyle(int style) {
 	if (instance) {
 		return instance->NameOfStyle(style);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 const char *LexState::TagsOfStyle(int style) {
 	if (instance) {
 		return instance->TagsOfStyle(style);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 const char *LexState::DescriptionOfStyle(int style) {
 	if (instance) {
 		return instance->DescriptionOfStyle(style);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 void ScintillaBase::NotifyStyleToNeeded(Sci::Position endStyleNeeded) {
 	if (!DocumentLexState()->UseContainerLexing()) {
-		const Sci::Position endStyled = pdoc->LineStartPosition(pdoc->GetEndStyled());
-		DocumentLexState()->Colourise(endStyled, endStyleNeeded);
+		const Sci::Position startStyling = pdoc->LineStartPosition(pdoc->GetEndStyled());
+		DocumentLexState()->Colourise(startStyling, endStyleNeeded);
 		return;
 	}
 	Editor::NotifyStyleToNeeded(endStyleNeeded);
@@ -956,6 +973,13 @@ sptr_t ScintillaBase::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::AutoCGetStyle:
 		return vs.autocStyle;
 
+	case Message::AutoCSetImageScale:
+		ac.imageScale = static_cast<float>(wParam) / 100.0f;
+		break;
+
+	case Message::AutoCGetImageScale:
+		return static_cast<int>(ac.imageScale * 100);
+
 	case Message::RegisterImage:
 		ac.lb->RegisterImage(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
diff --git a/src/scintilla/src/ScintillaBase.h b/src/scintilla/src/ScintillaBase.h
index bfeb5a3d9..d3a6e1ad6 100644
--- a/src/scintilla/src/ScintillaBase.h
+++ b/src/scintilla/src/ScintillaBase.h
@@ -14,6 +14,11 @@ namespace Scintilla::Internal {
 // blue, with different patterns.
 constexpr ColourRGBA colourIME(0x0, 0x0, 0xffU);
 
+constexpr int IndicatorInput = static_cast<int>(Scintilla::IndicatorNumbers::Ime);
+constexpr int IndicatorTarget = IndicatorInput + 1;
+constexpr int IndicatorConverted = IndicatorInput + 2;
+constexpr int IndicatorUnknown = IndicatorInput + 3;
+
 class LexState;
 /**
  */
@@ -61,6 +66,9 @@ class ScintillaBase : public Editor, IListBoxDelegate {
 	void CancelModes() override;
 	int KeyCommand(Scintilla::Message iMessage) override;
 
+	void MoveImeCarets(Sci::Position offset) noexcept;
+	void DrawImeIndicator(int indicator, Sci::Position len);
+
 	void AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, std::string_view text);
 	void AutoCompleteStart(Sci::Position lenEntered, const char *list);
 	void AutoCompleteCancel();
diff --git a/src/scintilla/src/Selection.cxx b/src/scintilla/src/Selection.cxx
index 0de60a958..795570ee2 100644
--- a/src/scintilla/src/Selection.cxx
+++ b/src/scintilla/src/Selection.cxx
@@ -96,6 +96,10 @@ bool SelectionPosition::operator >=(const SelectionPosition &other) const noexce
 	return *this > other;
 }
 
+double SelectionPosition::VirtualSpaceWidth(double spaceWidth) const noexcept {
+	return static_cast<double>(virtualSpace) * spaceWidth;
+}
+
 std::string SelectionPosition::ToString() const {
 	std::string result = std::to_string(position);
 	if (virtualSpace) {
diff --git a/src/scintilla/src/Selection.h b/src/scintilla/src/Selection.h
index 8ffcbb0bb..6779ee7ce 100644
--- a/src/scintilla/src/Selection.h
+++ b/src/scintilla/src/Selection.h
@@ -50,6 +50,7 @@ class SelectionPosition {
 	Sci::Position VirtualSpace() const noexcept {
 		return virtualSpace;
 	}
+	[[nodiscard]] double VirtualSpaceWidth(double spaceWidth) const noexcept;
 	void SetVirtualSpace(Sci::Position virtualSpace_) noexcept {
 		PLATFORM_ASSERT(virtualSpace_ < 800000000);
 		if (virtualSpace_ >= 0)
diff --git a/src/scintilla/src/UniConversion.cxx b/src/scintilla/src/UniConversion.cxx
index 868fbacf5..75fa679e0 100644
--- a/src/scintilla/src/UniConversion.cxx
+++ b/src/scintilla/src/UniConversion.cxx
@@ -15,16 +15,83 @@
 
 namespace Scintilla::Internal {
 
+namespace {
+
+constexpr int first2Byte = 0x80;
+constexpr int first3Byte = 0x800;
+
+constexpr unsigned int maskSurrogate = 0x3FF;
+constexpr unsigned int shiftSurrogate = 10;
+
+// The top 2 bits are 0b10 to indicate a trail byte.
+// The lower 6 bits contain the value.
+constexpr unsigned int trailByteFlag = 0b1000'0000;
+constexpr unsigned int trailByteMask = 0b0011'1111;
+
+// With each UTF-8 length the bits are divided into length indicator
+// bits and value bits separated by a 0 bit.
+constexpr unsigned int leadByte2 = 0b1100'0000;
+constexpr unsigned int leadBits2 = 0b0001'1111;
+
+constexpr unsigned int leadByte3 = 0b1110'0000;
+constexpr unsigned int leadBits3 = 0b0000'1111;
+
+constexpr unsigned int leadByte4 = 0b1111'0000;
+constexpr unsigned int leadBits4 = 0b0000'0111;
+
+constexpr unsigned int shiftByte2 = 6;
+constexpr unsigned int shiftByte3 = 12;
+constexpr unsigned int shiftByte4 = 18;
+
+constexpr char LeadByte(unsigned int lengthValue, unsigned int uch) noexcept {
+	return static_cast<unsigned char>(lengthValue | uch);
+}
+
+constexpr char TrailByte(unsigned int uch) noexcept {
+	return trailByteFlag | (uch & trailByteMask);
+}
+
+constexpr unsigned char TrailByteValue(unsigned char c) noexcept {
+	return c & trailByteMask;
+}
+
+constexpr wchar_t SurrogateLead(int val) noexcept {
+	return static_cast<wchar_t>(((val - SUPPLEMENTAL_PLANE_FIRST) >> shiftSurrogate) + SURROGATE_LEAD_FIRST);
+}
+
+constexpr wchar_t SurrogateTrail(int val) noexcept {
+	return (val & maskSurrogate) + SURROGATE_TRAIL_FIRST;
+}
+
+void UTF8AppendCharacter(int uch, char *putf, size_t &k) noexcept {
+	if (uch < first2Byte) {
+		putf[k++] = LeadByte(0, uch);
+	} else if (uch < first3Byte) {
+		putf[k++] = LeadByte(leadByte2, uch >> shiftByte2);
+		putf[k++] = TrailByte(uch);
+	} else if (uch < SUPPLEMENTAL_PLANE_FIRST) {
+		putf[k++] = LeadByte(leadByte3, uch >> shiftByte3);
+		putf[k++] = TrailByte(uch >> shiftByte2);
+		putf[k++] = TrailByte(uch);
+	} else {
+		putf[k++] = LeadByte(leadByte4, uch >> shiftByte4);
+		putf[k++] = TrailByte(uch >> shiftByte3);
+		putf[k++] = TrailByte(uch >> shiftByte2);
+		putf[k++] = TrailByte(uch);
+	}
+}
+
+}
+
 size_t UTF8Length(std::wstring_view wsv) noexcept {
 	size_t len = 0;
 	for (size_t i = 0; i < wsv.length() && wsv[i];) {
-		const unsigned int uch = wsv[i];
-		if (uch < 0x80) {
+		const wchar_t uch = wsv[i];
+		if (uch < first2Byte) {
 			len++;
-		} else if (uch < 0x800) {
+		} else if (uch < first3Byte) {
 			len += 2;
-		} else if ((uch >= SURROGATE_LEAD_FIRST) &&
-			(uch <= SURROGATE_TRAIL_LAST)) {
+		} else if (IsSurrogate(uch)) {
 			len += 4;
 			i++;
 		} else {
@@ -50,26 +117,13 @@ size_t UTF8PositionFromUTF16Position(std::string_view u8Text, size_t positionUTF
 void UTF8FromUTF16(std::wstring_view wsv, char *putf, size_t len) noexcept {
 	size_t k = 0;
 	for (size_t i = 0; i < wsv.length() && wsv[i];) {
-		const unsigned int uch = wsv[i];
-		if (uch < 0x80) {
-			putf[k++] = static_cast<char>(uch);
-		} else if (uch < 0x800) {
-			putf[k++] = static_cast<char>(0xC0 | (uch >> 6));
-			putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
-		} else if ((uch >= SURROGATE_LEAD_FIRST) &&
-			(uch <= SURROGATE_TRAIL_LAST)) {
+		unsigned int uch = wsv[i];
+		if (IsSurrogate(wsv[i])) {
 			// Half a surrogate pair
 			i++;
-			const unsigned int xch = 0x10000 + ((uch & 0x3ff) << 10) + (wsv[i] & 0x3ff);
-			putf[k++] = static_cast<char>(0xF0 | (xch >> 18));
-			putf[k++] = static_cast<char>(0x80 | ((xch >> 12) & 0x3f));
-			putf[k++] = static_cast<char>(0x80 | ((xch >> 6) & 0x3f));
-			putf[k++] = static_cast<char>(0x80 | (xch & 0x3f));
-		} else {
-			putf[k++] = static_cast<char>(0xE0 | (uch >> 12));
-			putf[k++] = static_cast<char>(0x80 | ((uch >> 6) & 0x3f));
-			putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
+			uch = SUPPLEMENTAL_PLANE_FIRST + ((uch & maskSurrogate) << shiftSurrogate) + (wsv[i] & maskSurrogate);
 		}
+		UTF8AppendCharacter(uch, putf, k);
 		i++;
 	}
 	if (k < len)
@@ -78,21 +132,7 @@ void UTF8FromUTF16(std::wstring_view wsv, char *putf, size_t len) noexcept {
 
 void UTF8FromUTF32Character(int uch, char *putf) noexcept {
 	size_t k = 0;
-	if (uch < 0x80) {
-		putf[k++] = static_cast<char>(uch);
-	} else if (uch < 0x800) {
-		putf[k++] = static_cast<char>(0xC0 | (uch >> 6));
-		putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
-	} else if (uch < 0x10000) {
-		putf[k++] = static_cast<char>(0xE0 | (uch >> 12));
-		putf[k++] = static_cast<char>(0x80 | ((uch >> 6) & 0x3f));
-		putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
-	} else {
-		putf[k++] = static_cast<char>(0xF0 | (uch >> 18));
-		putf[k++] = static_cast<char>(0x80 | ((uch >> 12) & 0x3f));
-		putf[k++] = static_cast<char>(0x80 | ((uch >> 6) & 0x3f));
-		putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
-	}
+	UTF8AppendCharacter(uch, putf, k);
 	putf[k] = '\0';
 }
 
@@ -108,18 +148,12 @@ size_t UTF16Length(std::string_view svu8) noexcept {
 	return ulen;
 }
 
-constexpr unsigned char TrailByteValue(unsigned char c) {
-	// The top 2 bits are 0b10 to indicate a trail byte.
-	// The lower 6 bits contain the value.
-	return c & 0b0011'1111;
-}
-
 size_t UTF16FromUTF8(std::string_view svu8, wchar_t *tbuf, size_t tlen) {
 	size_t ui = 0;
 	for (size_t i = 0; i < svu8.length();) {
 		unsigned char ch = svu8[i];
 		const unsigned int byteCount = UTF8BytesOfLead[ch];
-		unsigned int value;
+		unsigned int value = 0;
 
 		if (i + byteCount > svu8.length()) {
 			// Trying to read past end but still have space to write
@@ -141,31 +175,31 @@ size_t UTF16FromUTF8(std::string_view svu8, wchar_t *tbuf, size_t tlen) {
 			tbuf[ui] = ch;
 			break;
 		case 2:
-			value = (ch & 0x1F) << 6;
+			value = (ch & leadBits2) << shiftByte2;
 			ch = svu8[i++];
 			value += TrailByteValue(ch);
 			tbuf[ui] = static_cast<wchar_t>(value);
 			break;
 		case 3:
-			value = (ch & 0xF) << 12;
+			value = (ch & leadBits3) << shiftByte3;
 			ch = svu8[i++];
-			value += (TrailByteValue(ch) << 6);
+			value += (TrailByteValue(ch) << shiftByte2);
 			ch = svu8[i++];
 			value += TrailByteValue(ch);
 			tbuf[ui] = static_cast<wchar_t>(value);
 			break;
 		default:
 			// Outside the BMP so need two surrogates
-			value = (ch & 0x7) << 18;
+			value = (ch & leadBits4) << shiftByte4;
 			ch = svu8[i++];
-			value += TrailByteValue(ch) << 12;
+			value += TrailByteValue(ch) << shiftByte3;
 			ch = svu8[i++];
-			value += TrailByteValue(ch) << 6;
+			value += TrailByteValue(ch) << shiftByte2;
 			ch = svu8[i++];
 			value += TrailByteValue(ch);
-			tbuf[ui] = static_cast<wchar_t>(((value - 0x10000) >> 10) + SURROGATE_LEAD_FIRST);
+			tbuf[ui] = SurrogateLead(value);
 			ui++;
-			tbuf[ui] = static_cast<wchar_t>((value & 0x3ff) + SURROGATE_TRAIL_FIRST);
+			tbuf[ui] = SurrogateTrail(value);
 			break;
 		}
 		ui++;
@@ -189,7 +223,7 @@ size_t UTF32FromUTF8(std::string_view svu8, unsigned int *tbuf, size_t tlen) {
 	for (size_t i = 0; i < svu8.length();) {
 		unsigned char ch = svu8[i];
 		const unsigned int byteCount = UTF8BytesOfLead[ch];
-		unsigned int value;
+		unsigned int value = 0;
 
 		if (i + byteCount > svu8.length()) {
 			// Trying to read past end but still have space to write
@@ -210,23 +244,23 @@ size_t UTF32FromUTF8(std::string_view svu8, unsigned int *tbuf, size_t tlen) {
 			value = ch;
 			break;
 		case 2:
-			value = (ch & 0x1F) << 6;
+			value = (ch & leadBits2) << shiftByte2;
 			ch = svu8[i++];
 			value += TrailByteValue(ch);
 			break;
 		case 3:
-			value = (ch & 0xF) << 12;
+			value = (ch & leadBits3) << shiftByte3;
 			ch = svu8[i++];
-			value += TrailByteValue(ch) << 6;
+			value += TrailByteValue(ch) << shiftByte2;
 			ch = svu8[i++];
 			value += TrailByteValue(ch);
 			break;
 		default:
-			value = (ch & 0x7) << 18;
+			value = (ch & leadBits4) << shiftByte4;
 			ch = svu8[i++];
-			value += TrailByteValue(ch) << 12;
+			value += TrailByteValue(ch) << shiftByte3;
 			ch = svu8[i++];
-			value += TrailByteValue(ch) << 6;
+			value += TrailByteValue(ch) << shiftByte2;
 			ch = svu8[i++];
 			value += TrailByteValue(ch);
 			break;
@@ -256,8 +290,8 @@ unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf) noexcept {
 		tbuf[0] = static_cast<wchar_t>(val);
 		return 1;
 	}
-	tbuf[0] = static_cast<wchar_t>(((val - SUPPLEMENTAL_PLANE_FIRST) >> 10) + SURROGATE_LEAD_FIRST);
-	tbuf[1] = static_cast<wchar_t>((val & 0x3ff) + SURROGATE_TRAIL_FIRST);
+	tbuf[0] = SurrogateLead(val);
+	tbuf[1] = SurrogateTrail(val);
 	return 2;
 }
 
@@ -269,7 +303,7 @@ int UnicodeFromUTF8(std::string_view sv) noexcept {
 			return UnicodeFromUTF8(reinterpret_cast<const unsigned char *>(sv.data()));
 		}
 	}
-	// Failure so let the caller know  
+	// Failure so let the caller know
 	return unicodeReplacementChar;
 }
 
@@ -292,6 +326,10 @@ const unsigned char UTF8BytesOfLead[256] = {
 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // F0 - FF
 };
 
+// Silence 'magic' number warning as UTF-8 needs to distinguish byte values and byte value ranges.
+
+// NOLINTBEGIN(*-magic-numbers)
+
 // Return both the width of the first character in the string and a status
 // saying whether it is valid or invalid.
 // Most invalid sequences return a width of 1 so are treated as isolated bytes but
@@ -369,6 +407,8 @@ int UTF8Classify(const unsigned char *us, size_t len) noexcept {
 	return UTF8MaskInvalid | 1;
 }
 
+// NOLINTEND(*-magic-numbers)
+
 int UTF8Classify(const char *s, size_t len) noexcept {
 	return UTF8Classify(reinterpret_cast<const unsigned char *>(s), len);
 }
diff --git a/src/scintilla/src/UniConversion.h b/src/scintilla/src/UniConversion.h
index 5990cca8c..ce5de4bc7 100644
--- a/src/scintilla/src/UniConversion.h
+++ b/src/scintilla/src/UniConversion.h
@@ -99,8 +99,12 @@ enum { SURROGATE_TRAIL_FIRST = 0xDC00 };
 enum { SURROGATE_TRAIL_LAST = 0xDFFF };
 enum { SUPPLEMENTAL_PLANE_FIRST = 0x10000 };
 
+constexpr bool IsSurrogate(wchar_t uch) noexcept {
+	return (uch >= SURROGATE_LEAD_FIRST) && (uch <= SURROGATE_TRAIL_LAST);
+}
+
 constexpr unsigned int UTF16CharLength(wchar_t uch) noexcept {
-	return ((uch >= SURROGATE_LEAD_FIRST) && (uch <= SURROGATE_LEAD_LAST)) ? 2 : 1;
+	return IsSurrogate(uch) ? 2 : 1;
 }
 
 constexpr unsigned int UTF16LengthFromUTF8ByteCount(unsigned int byteCount) noexcept {
diff --git a/src/scintilla/test/performanceTests.py b/src/scintilla/test/performanceTests.py
index 2da14db03..8cf9c11b3 100644
--- a/src/scintilla/test/performanceTests.py
+++ b/src/scintilla/test/performanceTests.py
@@ -145,5 +145,27 @@ def testUTF8AsciiSearches(self):
 		print("%6.3f testUTF8AsciiSearches" % duration)
 		self.xite.DoEvents()
 
+	def testShiftJISSearches(self):
+		self.ed.SetCodePage(932)
+		self.ed.StyleSetCharacterSet(32, 128)
+		oneLine = "Fold Margin=折りたたみ表示用の余白(&F)\n".encode('cp932')
+		manyLines = oneLine * 100000
+		manyLines = manyLines + "φ\n".encode('cp932')
+		#~ with open("932.txt", "wb") as fp:
+			#~ fp.write(manyLines)
+		self.ed.AddText(len(manyLines), manyLines)
+		searchString = "φ".encode('cp932')
+		start = timer()
+		for i in range(20):
+			self.ed.TargetStart = 0
+			self.ed.TargetEnd = self.ed.Length-1
+			self.ed.SearchFlags = 0
+			pos = self.ed.SearchInTarget(len(searchString), searchString)
+			self.assertTrue(pos > 0)
+		end = timer()
+		duration = end - start
+		print("%6.3f testShiftJISSearches" % duration)
+		self.xite.DoEvents()
+
 if __name__ == '__main__':
 	Xite.main("performanceTests")
diff --git a/src/scintilla/test/simpleTests.py b/src/scintilla/test/simpleTests.py
index 867c0ebbc..0389d6dbc 100644
--- a/src/scintilla/test/simpleTests.py
+++ b/src/scintilla/test/simpleTests.py
@@ -3188,6 +3188,7 @@ def testDefaults(self):
 		self.assertEqual(self.ed.AutoCGetIgnoreCase(), 0)
 		self.assertEqual(self.ed.AutoCGetAutoHide(), 1)
 		self.assertEqual(self.ed.AutoCGetDropRestOfWord(), 0)
+		self.assertEqual(self.ed.AutoCGetImageScale(), 100)
 
 	def testChangeDefaults(self):
 		self.ed.AutoCSetSeparator(ord('-'))
@@ -3222,6 +3223,10 @@ def testChangeDefaults(self):
 		self.assertEqual(self.ed.AutoCGetStyle(), 13)
 		self.ed.AutoCSetStyle(self.ed.STYLE_DEFAULT)
 
+		self.ed.AutoCSetImageScale(200)
+		self.assertEqual(self.ed.AutoCGetImageScale(), 200)
+		self.ed.AutoCSetImageScale(100)
+
 	def testAutoShow(self):
 		self.assertEqual(self.ed.AutoCActive(), 0)
 		self.ed.SetSel(0, 0)
diff --git a/src/scintilla/test/unit/testDocument.cxx b/src/scintilla/test/unit/testDocument.cxx
index e764e209b..fb8448da4 100644
--- a/src/scintilla/test/unit/testDocument.cxx
+++ b/src/scintilla/test/unit/testDocument.cxx
@@ -1042,6 +1042,137 @@ TEST_CASE("SafeSegment") {
 	}
 }
 
+TEST_CASE("DiscardLastCombinedCharacter") {
+	SECTION("Short") {
+		const std::string_view base = "12345";
+		// Short strings (up to 4 bytes) aren't changed to avoid null and problematic results
+		for (size_t len = 0; len < 5; len++) {
+			std::string_view text = base.substr(0, len);
+			REQUIRE(text.length() == len);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(!changed);
+			REQUIRE(text.length() == len);
+		}
+	}
+
+	SECTION("ASCII") {
+		std::string_view text = "12345";
+		REQUIRE(text.length() == 5);
+		const bool changed = DiscardLastCombinedCharacter(text);
+		REQUIRE(changed);
+		REQUIRE(text.length() == 4);
+	}
+
+	SECTION("Control") {
+		{
+			std::string_view text = "12345\007";
+			REQUIRE(text.length() == 6);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			REQUIRE(text.length() == 5);
+		}
+		{
+			std::string_view text = "12345\007Z";
+			REQUIRE(text.length() == 7);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			REQUIRE(text.length() == 6);
+		}
+	}
+
+	SECTION("Japanese") {
+		std::string_view text = "Japanese\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e";
+		REQUIRE(text.length() == 17);
+		const bool changed = DiscardLastCombinedCharacter(text);
+		REQUIRE(changed);
+		REQUIRE(text.length() == 14);
+	}
+
+	SECTION("Thai Combining") {
+		// Ends with two combined characters
+		// 7 characters, 5 base characters and 2 combining
+		// HO HIP, SARA AA, KHO KHAI, MAI THO, O ANG, MO MA, SARA UU
+		std::string_view text = "\xe0\xb8\xab\xe0\xb8\xb2\xe0\xb8\x82\xe0\xb9\x89\xe0\xb8\xad\xe0\xb8\xa1\xe0\xb8\xb9";
+		REQUIRE(text.length() == 21);
+		const bool changed = DiscardLastCombinedCharacter(text);
+		REQUIRE(changed);
+		// Discarded 2 x 3-byte characters
+		REQUIRE(text.length() == 15);
+	}
+
+	SECTION("Invalid UTF-8") {
+		{
+			// Ends with isolated lead byte
+			std::string_view text = "1234\xe0";
+			REQUIRE(text.length() == 5);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded final invalid byte
+			REQUIRE(text.length() == 4);
+		}
+		{
+			// Ends with isolated trail byte
+			std::string_view text = "1234\xb8";
+			REQUIRE(text.length() == 5);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded final invalid byte
+			REQUIRE(text.length() == 4);
+		}
+		{
+			// Ends with lead byte and only one of two required trail bytes
+			std::string_view text = "1234\xe0\xb8";
+			REQUIRE(text.length() == 6);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded final invalid byte
+			REQUIRE(text.length() == 5);
+		}
+	}
+
+	SECTION("Private Use UTF-8") {
+		{
+			// Ends with private use area U+F8FF - Apple uses for apple symbol.
+			std::string_view text = "1234\xEF\xA3\xBF";
+			REQUIRE(text.length() == 7);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded whole final character
+			REQUIRE(text.length() == 4);
+		}
+		{
+			// At end: PUA + letter: PUA acts as base
+			std::string_view text = "1234\xEF\xA3\xBFZ";
+			REQUIRE(text.length() == 8);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded just final character
+			REQUIRE(text.length() == 7);
+		}
+	}
+
+	SECTION("Surrogates") {
+		{
+			// Ends with surrogate U+D800.
+			std::string_view text = "1234\xED\xA0\x80";
+			REQUIRE(text.length() == 7);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded final invalid byte
+			REQUIRE(text.length() == 6);
+		}
+		{
+			// Ends with surrogate U+DC00.
+			std::string_view text = "1234\xED\xB0\x80";
+			REQUIRE(text.length() == 7);
+			const bool changed = DiscardLastCombinedCharacter(text);
+			REQUIRE(changed);
+			// Discarded final invalid byte
+			REQUIRE(text.length() == 6);
+		}
+	}
+}
+
 TEST_CASE("PerLine") {
 	SECTION("LineMarkers") {
 		DocPlus doc("1\n2\n", CpUtf8);
diff --git a/src/scintilla/test/unit/testUniConversion.cxx b/src/scintilla/test/unit/testUniConversion.cxx
index a3b15d84c..25bdf50d2 100644
--- a/src/scintilla/test/unit/testUniConversion.cxx
+++ b/src/scintilla/test/unit/testUniConversion.cxx
@@ -121,6 +121,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF16FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 'a');
+		char back[4]{};
+		UTF8FromUTF16(std::wstring_view(tbuf, tlen), back, sizeof(back));
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF16FromUTF8 Example1") {
@@ -129,6 +132,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF16FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0x24);
+		char back[4]{};
+		UTF8FromUTF16(std::wstring_view(tbuf, tlen), back, sizeof(back));
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF16FromUTF8 Example2") {
@@ -137,6 +143,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF16FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0xA2);
+		char back[4]{};
+		UTF8FromUTF16(std::wstring_view(tbuf, tlen), back, sizeof(back));
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF16FromUTF8 Example3") {
@@ -145,6 +154,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF16FromUTF8(s, tbuf, 1);;
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0x20AC);
+		char back[4]{};
+		UTF8FromUTF16(std::wstring_view(tbuf, tlen), back, sizeof(back));
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF16FromUTF8 Example4") {
@@ -154,6 +166,9 @@ TEST_CASE("UniConversion") {
 		REQUIRE(tlen == 2U);
 		REQUIRE(tbuf[0] == 0xD800);
 		REQUIRE(tbuf[1] == 0xDF48);
+		char back[5]{};
+		UTF8FromUTF16(std::wstring_view(tbuf, tlen), back, sizeof(back));
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF16FromUTF8 Invalid Trail byte in lead position") {
@@ -165,6 +180,7 @@ TEST_CASE("UniConversion") {
 		REQUIRE(tbuf[1] == 0xB5);
 		REQUIRE(tbuf[2] == 'y');
 		REQUIRE(tbuf[3] == 'z');
+		// Invalid so can't round trip
 	}
 
 	SECTION("UTF16FromUTF8 Invalid Lead byte at end") {
@@ -174,6 +190,7 @@ TEST_CASE("UniConversion") {
 		REQUIRE(tlen == 2U);
 		REQUIRE(tbuf[0] == 'a');
 		REQUIRE(tbuf[1] == 0xC2);
+		// Invalid so can't round trip
 	}
 
 	SECTION("UTF16FromUTF8 Invalid Lead byte implies 3 trails but only 2") {
@@ -183,6 +200,7 @@ TEST_CASE("UniConversion") {
 		REQUIRE(tlen == 2U);
 		REQUIRE(tbuf[0] == 'a');
 		REQUIRE(tbuf[1] == 0xF1);
+		// Invalid so can't round trip
 	}
 
 	// UTF32FromUTF8
@@ -193,6 +211,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF32FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == static_cast<unsigned int>('a'));
+		char back[5]{};
+		UTF8FromUTF32Character(tbuf[0], back);
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF32FromUTF8 Example1") {
@@ -201,6 +222,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF32FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0x24);
+		char back[5]{};
+		UTF8FromUTF32Character(tbuf[0], back);
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF32FromUTF8 Example2") {
@@ -209,6 +233,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF32FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0xA2);
+		char back[5]{};
+		UTF8FromUTF32Character(tbuf[0], back);
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF32FromUTF8 Example3") {
@@ -217,6 +244,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF32FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0x20AC);
+		char back[5]{};
+		UTF8FromUTF32Character(tbuf[0], back);
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF32FromUTF8 Example4") {
@@ -225,6 +255,9 @@ TEST_CASE("UniConversion") {
 		const size_t tlen = UTF32FromUTF8(s, tbuf, 1);
 		REQUIRE(tlen == 1U);
 		REQUIRE(tbuf[0] == 0x10348);
+		char back[5]{};
+		UTF8FromUTF32Character(tbuf[0], back);
+		REQUIRE(strcmp(s, back) == 0);
 	}
 
 	SECTION("UTF32FromUTF8 Invalid Trail byte in lead position") {
diff --git a/src/scintilla/version.txt b/src/scintilla/version.txt
index 3749383de..0ee983639 100644
--- a/src/scintilla/version.txt
+++ b/src/scintilla/version.txt
@@ -1 +1 @@
-555
+557
diff --git a/src/scintilla/win32/ListBox.cxx b/src/scintilla/win32/ListBox.cxx
new file mode 100644
index 000000000..38806a373
--- /dev/null
+++ b/src/scintilla/win32/ListBox.cxx
@@ -0,0 +1,991 @@
+// Scintilla source code edit control
+/** @file ListBox.cxx
+ ** Implementation of list box on Windows.
+ **/
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+#include <ctime>
+#include <cmath>
+#include <climits>
+
+#include <string_view>
+#include <vector>
+#include <map>
+#include <optional>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <mutex>
+
+// Want to use std::min and std::max so don't want Windows.h version of min and max
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0A00
+#undef WINVER
+#define WINVER 0x0A00
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#include <commctrl.h>
+#include <richedit.h>
+#include <windowsx.h>
+#include <shellscalingapi.h>
+
+#include <wrl.h>
+using Microsoft::WRL::ComPtr;
+
+#if !defined(DISABLE_D2D)
+#define USE_D2D 1
+#endif
+
+#if defined(USE_D2D)
+#include <d2d1_1.h>
+#include <d3d11_1.h>
+#include <dwrite_1.h>
+#endif
+
+#include "ScintillaTypes.h"
+
+#include "Debugging.h"
+#include "Geometry.h"
+#include "Platform.h"
+#include "XPM.h"
+#include "UniConversion.h"
+#include "DBCS.h"
+
+#include "WinTypes.h"
+#include "PlatWin.h"
+#include "ListBox.h"
+#if defined(USE_D2D)
+#include "SurfaceD2D.h"
+#endif
+
+using namespace Scintilla;
+using namespace Scintilla::Internal;
+
+namespace {
+
+void *PtrFromLParam(Scintilla::sptr_t lParam) noexcept {
+	return reinterpret_cast<void *>(lParam);
+}
+
+struct ListItemData {
+	const char *text;
+	int pixId;
+};
+
+class LineToItem {
+	std::vector<char> words;
+
+	std::vector<ListItemData> data;
+
+public:
+	void Clear() noexcept {
+		words.clear();
+		data.clear();
+	}
+
+	[[nodiscard]] ListItemData Get(size_t index) const noexcept {
+		if (index < data.size()) {
+			return data[index];
+		}
+		ListItemData missing = {"", -1};
+		return missing;
+	}
+	[[nodiscard]] int Count() const noexcept {
+		return static_cast<int>(data.size());
+	}
+
+	void AllocItem(const char *text, int pixId) {
+		const ListItemData lid = { text, pixId };
+		data.push_back(lid);
+	}
+
+	char *SetWords(const char *s) {
+		words = std::vector<char>(s, s+strlen(s)+1);
+		return words.data();
+	}
+};
+
+const TCHAR ListBoxX_ClassName[] = TEXT("ListBoxX");
+
+ColourRGBA ColourElement(std::optional<ColourRGBA> colour, int nIndex) {
+	if (colour.has_value()) {
+		return colour.value();
+	}
+	return ColourFromSys(nIndex);
+}
+
+struct LBGraphics {
+	GDIBitMap bm;
+	std::unique_ptr<Surface> pixmapLine;
+#if defined(USE_D2D)
+	DCRenderTarget pBMDCTarget;
+#endif
+
+	void Release() noexcept {
+		pixmapLine.reset();
+#if defined(USE_D2D)
+		pBMDCTarget = nullptr;
+#endif
+		bm.Release();
+	}
+};
+
+}
+
+class ListBoxX : public ListBox {
+	int lineHeight = 10;
+	HFONT fontCopy {};
+	std::unique_ptr<FontWin> fontWin;
+	Technology technology = Technology::Default;
+	RGBAImageSet images;
+	LineToItem lti;
+	HWND lb {};
+	bool unicodeMode = false;
+	int codePage = 0;
+	int desiredVisibleRows = 9;
+	int maxItemCharacters = 0;
+	unsigned int aveCharWidth = 8;
+	Window *parent = nullptr;
+	WNDPROC prevWndProc{};
+	int ctrlID = 0;
+	UINT dpi = USER_DEFAULT_SCREEN_DPI;
+	IListBoxDelegate *delegate = nullptr;
+	unsigned int maxCharWidth = 1;
+	WPARAM resizeHit = 0;
+	PRectangle rcPreSize;
+	Point dragOffset;
+	Point location;	// Caret location at which the list is opened
+	MouseWheelDelta wheelDelta;
+	ListOptions options;
+	DWORD frameStyle = WS_THICKFRAME;
+
+	LBGraphics graphics;
+
+	HWND GetHWND() const noexcept;
+	void AppendListItem(const char *text, const char *numword);
+	void AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept;
+	int ItemHeight() const noexcept;
+	int MinClientWidth() const noexcept;
+	int TextOffset() const noexcept;
+	POINT GetClientExtent() const noexcept;
+	POINT MinTrackSize() const noexcept;
+	POINT MaxTrackSize() const noexcept;
+	void SetRedraw(bool on) noexcept;
+	void OnDoubleClick();
+	void OnSelChange();
+	void ResizeToCursor();
+	void StartResize(WPARAM);
+	LRESULT NcHitTest(WPARAM, LPARAM) const;
+	void CentreItem(int n);
+	void AllocateBitMap();
+	LRESULT PASCAL ListProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+	static LRESULT PASCAL ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+
+	static constexpr POINT ItemInset {0, 0};	// Padding around whole item
+	static constexpr POINT TextInset {2, 0};	// Padding around text
+	static constexpr POINT ImageInset {1, 0};	// Padding around image
+
+public:
+	ListBoxX() = default;
+	ListBoxX(const ListBoxX &) = delete;
+	ListBoxX(ListBoxX &&) = delete;
+	ListBoxX &operator=(const ListBoxX &) = delete;
+	ListBoxX &operator=(ListBoxX &&) = delete;
+	~ListBoxX() noexcept override {
+		if (fontCopy) {
+			::DeleteObject(fontCopy);
+			fontCopy = {};
+		}
+		graphics.Release();
+	}
+	void SetFont(const Font *font) override;
+	void Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, Technology technology_) override;
+	void SetAverageCharWidth(int width) override;
+	void SetVisibleRows(int rows) override;
+	int GetVisibleRows() const override;
+	PRectangle GetDesiredRect() override;
+	int CaretFromEdge() override;
+	void Clear() noexcept override;
+	void Append(char *s, int type) override;
+	int Length() override;
+	void Select(int n) override;
+	int GetSelection() override;
+	int Find(const char *prefix) override;
+	std::string GetValue(int n) override;
+	void RegisterImage(int type, const char *xpm_data) override;
+	void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) override;
+	void ClearRegisteredImages() override;
+	void SetDelegate(IListBoxDelegate *lbDelegate) override;
+	void SetList(const char *list, char separator, char typesep) override;
+	void SetOptions(ListOptions options_) override;
+	void Draw(DRAWITEMSTRUCT *pDrawItem);
+	LRESULT WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+	static LRESULT PASCAL StaticWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+};
+
+std::unique_ptr<ListBox> ListBox::Allocate() {
+	return std::make_unique<ListBoxX>();
+}
+
+void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, Technology technology_) {
+	parent = &parent_;
+	ctrlID = ctrlID_;
+	location = location_;
+	lineHeight = lineHeight_;
+	unicodeMode = unicodeMode_;
+	codePage = unicodeMode ? CpUtf8 : 0;
+	technology = technology_;
+	HWND hwndParent = HwndFromWindow(*parent);
+	HINSTANCE hinstanceParent = GetWindowInstance(hwndParent);
+	// Window created as popup so not clipped within parent client area
+	wid = ::CreateWindowEx(
+		WS_EX_WINDOWEDGE, ListBoxX_ClassName, TEXT(""),
+		WS_POPUP | frameStyle,
+		100,100, 150,80, hwndParent,
+		{},
+		hinstanceParent,
+		this);
+
+	dpi = DpiForWindow(hwndParent);
+	POINT locationw = POINTFromPoint(location);
+	::MapWindowPoints(hwndParent, {}, &locationw, 1);
+	location = PointFromPOINT(locationw);
+}
+
+void ListBoxX::SetFont(const Font *font) {
+	const FontWin *pfm = dynamic_cast<const FontWin *>(font);
+	if (pfm) {
+		if (fontCopy) {
+			::DeleteObject(fontCopy);
+			fontCopy = {};
+		}
+		fontCopy = pfm->HFont();
+		SetWindowFont(lb, fontCopy, 0);
+		fontWin = pfm->Duplicate();
+		codePage = unicodeMode ? CpUtf8 : CodePageFromCharSet(fontWin->GetCharacterSet(), 1252);
+		graphics.Release();
+	}
+}
+
+void ListBoxX::SetAverageCharWidth(int width) {
+	aveCharWidth = width;
+}
+
+void ListBoxX::SetVisibleRows(int rows) {
+	desiredVisibleRows = rows;
+}
+
+int ListBoxX::GetVisibleRows() const {
+	return desiredVisibleRows;
+}
+
+HWND ListBoxX::GetHWND() const noexcept {
+	return HwndFromWindowID(GetID());
+}
+
+PRectangle ListBoxX::GetDesiredRect() {
+	PRectangle rcDesired = GetPosition();
+
+	int rows = Length();
+	if ((rows == 0) || (rows > desiredVisibleRows))
+		rows = desiredVisibleRows;
+	rcDesired.bottom = rcDesired.top + ItemHeight() * rows;
+
+	int width = MinClientWidth();
+	int textSize = 0;
+	int averageCharWidth = 8;
+
+	// Make a measuring surface
+	std::unique_ptr<Surface> surfaceItem(Surface::Allocate(technology));
+	surfaceItem->Init(GetID());
+	surfaceItem->SetMode(SurfaceMode(codePage, false));
+
+	// Find the widest item in pixels
+	const int items = lti.Count();
+	for (int i = 0; i < items; i++) {
+		const ListItemData item = lti.Get(i);
+		const int itemTextSize = static_cast<int>(std::ceil(
+			surfaceItem->WidthText(fontWin.get(), item.text)));
+		textSize = std::max(textSize, itemTextSize);
+	}
+
+	maxCharWidth = static_cast<int>(std::ceil(surfaceItem->WidthText(fontWin.get(), "W")));
+	averageCharWidth = static_cast<int>(surfaceItem->AverageCharWidth(fontWin.get()));
+
+	width = std::max({ width, textSize, (maxItemCharacters + 1) * averageCharWidth });
+
+	rcDesired.right = rcDesired.left + TextOffset() + width + (TextInset.x * 2);
+	if (Length() > rows)
+		rcDesired.right += SystemMetricsForDpi(SM_CXVSCROLL, dpi);
+
+	AdjustWindowRect(&rcDesired, dpi);
+	return rcDesired;
+}
+
+int ListBoxX::TextOffset() const noexcept {
+	const int pixWidth = images.GetWidth();
+	return pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2);
+}
+
+int ListBoxX::CaretFromEdge() {
+	PRectangle rc;
+	AdjustWindowRect(&rc, dpi);
+	return TextOffset() + static_cast<int>(TextInset.x + (0 - rc.left) - 1);
+}
+
+void ListBoxX::Clear() noexcept {
+	ListBox_ResetContent(lb);
+	maxItemCharacters = 0;
+	lti.Clear();
+}
+
+void ListBoxX::Append(char *, int) {
+	// This method is no longer called in Scintilla
+	PLATFORM_ASSERT(false);
+}
+
+int ListBoxX::Length() {
+	return lti.Count();
+}
+
+void ListBoxX::Select(int n) {
+	// We are going to scroll to centre on the new selection and then select it, so disable
+	// redraw to avoid flicker caused by a painting new selection twice in unselected and then
+	// selected states
+	SetRedraw(false);
+	CentreItem(n);
+	ListBox_SetCurSel(lb, n);
+	OnSelChange();
+	SetRedraw(true);
+}
+
+int ListBoxX::GetSelection() {
+	return ListBox_GetCurSel(lb);
+}
+
+// This is not actually called at present
+int ListBoxX::Find(const char *) {
+	return LB_ERR;
+}
+
+std::string ListBoxX::GetValue(int n) {
+	const ListItemData item = lti.Get(n);
+	return item.text;
+}
+
+void ListBoxX::RegisterImage(int type, const char *xpm_data) {
+	XPM xpmImage(xpm_data);
+	images.AddImage(type, std::make_unique<RGBAImage>(xpmImage));
+}
+
+void ListBoxX::RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) {
+	images.AddImage(type, std::make_unique<RGBAImage>(width, height, 1.0f, pixelsImage));
+}
+
+void ListBoxX::ClearRegisteredImages() {
+	images.Clear();
+}
+
+void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
+	if ((pDrawItem->itemAction != ODA_SELECT) && (pDrawItem->itemAction != ODA_DRAWENTIRE)) {
+		return;
+	}
+	if (!graphics.pixmapLine) {
+		AllocateBitMap();
+		if (!graphics.pixmapLine) {
+			// Failed to allocate, so release fully and give up
+			graphics.Release();
+			return;
+		}
+	}
+#if defined(USE_D2D)
+	if (graphics.pBMDCTarget) {
+		graphics.pBMDCTarget->BeginDraw();
+	}
+#endif
+
+	const PRectangle rcItemBase = PRectangleFromRECT(pDrawItem->rcItem);
+	const PRectangle rcItem(0, 0, rcItemBase.Width(), rcItemBase.Height());
+	PRectangle rcBox = rcItem;
+	rcBox.left += TextOffset();
+	ColourRGBA colourFore;
+	ColourRGBA colourBack;
+	if (pDrawItem->itemState & ODS_SELECTED) {
+		PRectangle rcImage = rcItem;
+		rcImage.right = rcBox.left;
+		// The image is not highlighted
+		graphics.pixmapLine->FillRectangle(rcImage, ColourElement(options.back, COLOR_WINDOW));
+		colourBack = ColourElement(options.backSelected, COLOR_HIGHLIGHT);
+		graphics.pixmapLine->FillRectangle(rcBox, colourBack);
+		colourFore = ColourElement(options.foreSelected, COLOR_HIGHLIGHTTEXT);
+	} else {
+		colourBack = ColourElement(options.back, COLOR_WINDOW);
+		graphics.pixmapLine->FillRectangle(rcItem, colourBack);
+		colourFore = ColourElement(options.fore, COLOR_WINDOWTEXT);
+	}
+
+	const ListItemData item = lti.Get(pDrawItem->itemID);
+	const int pixId = item.pixId;
+	const char *text = item.text;
+
+	const PRectangle rcText = rcBox.Inset(Point(TextInset.x, TextInset.y));
+
+	const double ascent = graphics.pixmapLine->Ascent(fontWin.get());
+	graphics.pixmapLine->DrawTextClipped(rcText, fontWin.get(), rcText.top + ascent, text, colourFore, colourBack);
+
+	// Draw the image, if any
+	const RGBAImage *pimage = images.Get(pixId);
+	if (pimage) {
+		const XYPOSITION left = rcItem.left + ItemInset.x + ImageInset.x;
+		PRectangle rcImage = rcItem;
+		rcImage.left = left;
+		rcImage.right = rcImage.left + images.GetWidth();
+		graphics.pixmapLine->DrawRGBAImage(rcImage,
+			pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
+	}
+
+#if defined(USE_D2D)
+	if (graphics.pBMDCTarget) {
+		const HRESULT hrEnd = graphics.pBMDCTarget->EndDraw();
+		if (FAILED(hrEnd)) {
+			return;
+		}
+	}
+#endif
+
+	// Blit from hMemDC to hDC
+	const SIZE extent = SizeOfRect(pDrawItem->rcItem);
+	::BitBlt(pDrawItem->hDC, pDrawItem->rcItem.left, pDrawItem->rcItem.top, extent.cx, extent.cy, graphics.bm.DC(), 0, 0, SRCCOPY);
+}
+
+void ListBoxX::AppendListItem(const char *text, const char *numword) {
+	int pixId = -1;
+	if (numword) {
+		pixId = 0;
+		char ch;
+		while ((ch = *++numword) != '\0') {
+			pixId = 10 * pixId + (ch - '0');
+		}
+	}
+
+	lti.AllocItem(text, pixId);
+	maxItemCharacters = std::max(maxItemCharacters, static_cast<int>(strlen(text)));
+}
+
+void ListBoxX::SetDelegate(IListBoxDelegate *lbDelegate) {
+	delegate = lbDelegate;
+}
+
+void ListBoxX::SetList(const char *list, char separator, char typesep) {
+	// Turn off redraw while populating the list - this has a significant effect, even if
+	// the listbox is not visible.
+	SetRedraw(false);
+	Clear();
+	const size_t size = strlen(list);
+	char *words = lti.SetWords(list);
+	const char *startword = words;
+	char *numword = nullptr;
+	for (size_t i=0; i < size; i++) {
+		if (words[i] == separator) {
+			words[i] = '\0';
+			if (numword)
+				*numword = '\0';
+			AppendListItem(startword, numword);
+			startword = words + i + 1;
+			numword = nullptr;
+		} else if (words[i] == typesep) {
+			numword = words + i;
+		}
+	}
+	if (startword) {
+		if (numword)
+			*numword = '\0';
+		AppendListItem(startword, numword);
+	}
+
+	// Finally populate the listbox itself with the correct number of items
+	const int count = lti.Count();
+	::SendMessage(lb, LB_INITSTORAGE, count, 0);
+	for (intptr_t j=0; j<count; j++) {
+		ListBox_AddItemData(lb, j+1);
+	}
+	SetRedraw(true);
+}
+
+void ListBoxX::SetOptions(ListOptions options_) {
+	options = options_;
+	frameStyle = FlagSet(options.options, AutoCompleteOption::FixedSize) ? WS_BORDER : WS_THICKFRAME;
+}
+
+void ListBoxX::AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept {
+	RECT rcw = RectFromPRectangle(*rc);
+	AdjustWindowRectForDpi(&rcw, frameStyle, dpiAdjust);
+	*rc = PRectangleFromRECT(rcw);
+}
+
+int ListBoxX::ItemHeight() const noexcept {
+	int itemHeight = lineHeight + (TextInset.y * 2);
+	const int pixHeight = images.GetHeight() + (ImageInset.y * 2);
+	if (itemHeight < pixHeight) {
+		itemHeight = pixHeight;
+	}
+	return itemHeight;
+}
+
+int ListBoxX::MinClientWidth() const noexcept {
+	return 12 * (aveCharWidth+aveCharWidth/3);
+}
+
+POINT ListBoxX::MinTrackSize() const noexcept {
+	PRectangle rc = PRectangle::FromInts(0, 0, MinClientWidth(), ItemHeight());
+	AdjustWindowRect(&rc, dpi);
+	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
+	return ret;
+}
+
+POINT ListBoxX::MaxTrackSize() const noexcept {
+	PRectangle rc = PRectangle::FromInts(0, 0,
+		std::max<int>(static_cast<unsigned int>(MinClientWidth()),
+		maxCharWidth * maxItemCharacters + TextInset.x * 2 +
+		 TextOffset() + SystemMetricsForDpi(SM_CXVSCROLL, dpi)),
+		ItemHeight() * lti.Count());
+	AdjustWindowRect(&rc, dpi);
+	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
+	return ret;
+}
+
+void ListBoxX::SetRedraw(bool on) noexcept {
+	::SendMessage(lb, WM_SETREDRAW, on, 0);
+	if (on) {
+		::RedrawWindow(lb, {}, {}, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
+	}
+}
+
+void ListBoxX::ResizeToCursor() {
+	PRectangle rc = GetPosition();
+	POINT ptw;
+	::GetCursorPos(&ptw);
+	const Point pt = PointFromPOINT(ptw) + dragOffset;
+
+	switch (resizeHit) {
+		case HTLEFT:
+			rc.left = pt.x;
+			break;
+		case HTRIGHT:
+			rc.right = pt.x;
+			break;
+		case HTTOP:
+			rc.top = pt.y;
+			break;
+		case HTTOPLEFT:
+			rc.top = pt.y;
+			rc.left = pt.x;
+			break;
+		case HTTOPRIGHT:
+			rc.top = pt.y;
+			rc.right = pt.x;
+			break;
+		case HTBOTTOM:
+			rc.bottom = pt.y;
+			break;
+		case HTBOTTOMLEFT:
+			rc.bottom = pt.y;
+			rc.left = pt.x;
+			break;
+		case HTBOTTOMRIGHT:
+			rc.bottom = pt.y;
+			rc.right = pt.x;
+			break;
+		default:
+			break;
+	}
+
+	const POINT ptMin = MinTrackSize();
+	const POINT ptMax = MaxTrackSize();
+	// We don't allow the left edge to move at present, but just in case
+	rc.left = std::clamp(rc.left, rcPreSize.right - ptMax.x, rcPreSize.right - ptMin.x);
+	rc.top = std::clamp(rc.top, rcPreSize.bottom - ptMax.y, rcPreSize.bottom - ptMin.y);
+	rc.right = std::clamp(rc.right, rcPreSize.left + ptMin.x, rcPreSize.left + ptMax.x);
+	rc.bottom = std::clamp(rc.bottom, rcPreSize.top + ptMin.y, rcPreSize.top + ptMax.y);
+
+	SetPosition(rc);
+}
+
+void ListBoxX::StartResize(WPARAM hitCode) {
+	rcPreSize = GetPosition();
+	POINT cursorPos;
+	::GetCursorPos(&cursorPos);
+
+	switch (hitCode) {
+		case HTRIGHT:
+		case HTBOTTOM:
+		case HTBOTTOMRIGHT:
+			dragOffset.x = rcPreSize.right - cursorPos.x;
+			dragOffset.y = rcPreSize.bottom - cursorPos.y;
+			break;
+
+		case HTTOPRIGHT:
+			dragOffset.x = rcPreSize.right - cursorPos.x;
+			dragOffset.y = rcPreSize.top - cursorPos.y;
+			break;
+
+		// Note that the current hit test code prevents the left edge cases ever firing
+		// as we don't want the left edge to be movable
+		case HTLEFT:
+		case HTTOP:
+		case HTTOPLEFT:
+			dragOffset.x = rcPreSize.left - cursorPos.x;
+			dragOffset.y = rcPreSize.top - cursorPos.y;
+			break;
+		case HTBOTTOMLEFT:
+			dragOffset.x = rcPreSize.left - cursorPos.x;
+			dragOffset.y = rcPreSize.bottom - cursorPos.y;
+			break;
+
+		default:
+			return;
+	}
+
+	::SetCapture(GetHWND());
+	resizeHit = hitCode;
+}
+
+LRESULT ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
+	const PRectangle rc = GetPosition();
+
+	LRESULT hit = ::DefWindowProc(GetHWND(), WM_NCHITTEST, wParam, lParam);
+	// There is an apparent bug in the DefWindowProc hit test code whereby it will
+	// return HTTOPXXX if the window in question is shorter than the default
+	// window caption height + frame, even if one is hovering over the bottom edge of
+	// the frame, so workaround that here
+	if (hit >= HTTOP && hit <= HTTOPRIGHT) {
+		const int minHeight = SystemMetricsForDpi(SM_CYMINTRACK, dpi);
+		const int yPos = GET_Y_LPARAM(lParam);
+		if ((rc.Height() < minHeight) && (yPos > ((rc.top + rc.bottom)/2))) {
+			hit += HTBOTTOM - HTTOP;
+		}
+	}
+
+	// Never permit resizing that moves the left edge. Allow movement of top or bottom edge
+	// depending on whether the list is above or below the caret
+	switch (hit) {
+		case HTLEFT:
+		case HTTOPLEFT:
+		case HTBOTTOMLEFT:
+			hit = HTERROR;
+			break;
+
+		case HTTOP:
+		case HTTOPRIGHT: {
+				// Valid only if caret below list
+				if (location.y < rc.top)
+					hit = HTERROR;
+			}
+			break;
+
+		case HTBOTTOM:
+		case HTBOTTOMRIGHT: {
+				// Valid only if caret above list
+				if (rc.bottom <= location.y)
+					hit = HTERROR;
+			}
+			break;
+		default:
+			break;
+	}
+
+	return hit;
+}
+
+void ListBoxX::OnDoubleClick() {
+	if (delegate) {
+		ListBoxEvent event(ListBoxEvent::EventType::doubleClick);
+		delegate->ListNotify(&event);
+	}
+}
+
+void ListBoxX::OnSelChange() {
+	if (delegate) {
+		ListBoxEvent event(ListBoxEvent::EventType::selectionChange);
+		delegate->ListNotify(&event);
+	}
+}
+
+POINT ListBoxX::GetClientExtent() const noexcept {
+	RECT rc;
+	::GetWindowRect(HwndFromWindowID(wid), &rc);
+	POINT ret { rc.right - rc.left, rc.bottom - rc.top };
+	return ret;
+}
+
+void ListBoxX::CentreItem(int n) {
+	// If below mid point, scroll up to centre, but with more items below if uneven
+	if (n >= 0) {
+		const POINT extent = GetClientExtent();
+		const int visible = extent.y/ItemHeight();
+		if (visible < Length()) {
+			const int top = ListBox_GetTopIndex(lb);
+			const int half = (visible - 1) / 2;
+			if (n > (top + half))
+				ListBox_SetTopIndex(lb, n - half);
+		}
+	}
+}
+
+void ListBoxX::AllocateBitMap() {
+	const SIZE extent { GetClientExtent().x, lineHeight };
+
+	graphics.bm.Create({}, extent.cx, -extent.cy, nullptr);
+	if (!graphics.bm) {
+		return;
+	}
+
+	// Make a surface
+	graphics.pixmapLine = Surface::Allocate(technology);
+	graphics.pixmapLine->SetMode(SurfaceMode(codePage, false));
+
+#if defined(USE_D2D)
+	if (technology != Technology::Default) {
+		if (!LoadD2D()) {
+			return;
+		}
+
+		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
+			D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED });
+
+		HRESULT hr = CreateDCRenderTarget(&drtp, graphics.pBMDCTarget);
+		if (FAILED(hr) || !graphics.pBMDCTarget) {
+			return;
+		}
+
+		const RECT rcExtent = { 0, 0, extent.cx, extent.cy };
+		hr = graphics.pBMDCTarget->BindDC(graphics.bm.DC(), &rcExtent);
+		if (SUCCEEDED(hr)) {
+			graphics.pixmapLine->Init(graphics.pBMDCTarget.Get(), GetID());
+		}
+		return;
+	}
+#endif
+
+	// Either technology == Technology::Default or USE_D2D turned off
+	graphics.pixmapLine->Init(graphics.bm.DC(), GetID());
+}
+
+LRESULT PASCAL ListBoxX::ListProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	try {
+		switch (iMessage) {
+		case WM_ERASEBKGND:
+			return TRUE;
+
+		case WM_MOUSEACTIVATE:
+			// This prevents the view activating when the scrollbar is clicked
+			return MA_NOACTIVATE;
+
+		case WM_LBUTTONDOWN: {
+				// We must take control of selection to prevent the ListBox activating
+				// the popup
+				const LRESULT lResult = ::SendMessage(hWnd, LB_ITEMFROMPOINT, 0, lParam);
+				if (HIWORD(lResult) == 0) {
+					ListBox_SetCurSel(hWnd, LOWORD(lResult));
+					OnSelChange();
+				}
+			}
+			return 0;
+
+		case WM_LBUTTONUP:
+			return 0;
+
+		case WM_LBUTTONDBLCLK:
+			OnDoubleClick();
+			return 0;
+
+		case WM_MBUTTONDOWN:
+			// disable the scroll wheel button click action
+			return 0;
+
+		default:
+			break;
+		}
+
+		if (prevWndProc) {
+			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
+		}
+	} catch (...) {
+	}
+	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+}
+
+LRESULT PASCAL ListBoxX::ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	if (ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(::GetParent(hWnd)))) {
+		return lbx->ListProc(hWnd, iMessage, wParam, lParam);
+	}
+	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+}
+
+LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	switch (iMessage) {
+	case WM_CREATE: {
+			HINSTANCE hinstanceParent = GetWindowInstance(HwndFromWindow(*parent));
+			// Note that LBS_NOINTEGRALHEIGHT is specified to fix cosmetic issue when resizing the list
+			// but has useful side effect of speeding up list population significantly
+			lb = ::CreateWindowExW(
+				0, WC_LISTBOXW, L"",
+				WS_CHILD | WS_VSCROLL | WS_VISIBLE |
+				LBS_OWNERDRAWFIXED | LBS_NODATA | LBS_NOINTEGRALHEIGHT,
+				0, 0, 150,80, hWnd,
+				reinterpret_cast<HMENU>(static_cast<ptrdiff_t>(ctrlID)),
+				hinstanceParent,
+				nullptr);
+			prevWndProc = SubclassWindow(lb, ControlWndProc);
+		}
+		break;
+
+	case WM_SIZE:
+		if (lb) {
+			graphics.Release();	// Bitmap must be reallocated to new size.
+			SetRedraw(false);
+			::SetWindowPos(lb, {}, 0, 0, LOWORD(lParam), HIWORD(lParam), SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
+			// Ensure the selection remains visible
+			CentreItem(GetSelection());
+			SetRedraw(true);
+		}
+		break;
+
+	case WM_PAINT: {
+			Painter painter(hWnd);
+		}
+		break;
+
+	case WM_COMMAND:
+		// This is not actually needed now - the registered double click action is used
+		// directly to action a choice from the list.
+		::SendMessage(HwndFromWindow(*parent), iMessage, wParam, lParam);
+		break;
+
+	case WM_MEASUREITEM: {
+			MEASUREITEMSTRUCT *pMeasureItem = static_cast<MEASUREITEMSTRUCT *>(PtrFromLParam(lParam));
+			pMeasureItem->itemHeight = ItemHeight();
+		}
+		break;
+
+	case WM_DRAWITEM:
+		Draw(static_cast<DRAWITEMSTRUCT *>(PtrFromLParam(lParam)));
+		break;
+
+	case WM_DESTROY:
+		lb = {};
+		SetWindowPointer(hWnd, nullptr);
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+
+	case WM_ERASEBKGND:
+		// To reduce flicker we can elide background erasure since this window is
+		// completely covered by its child.
+		return TRUE;
+
+	case WM_GETMINMAXINFO: {
+			MINMAXINFO *minMax = static_cast<MINMAXINFO*>(PtrFromLParam(lParam));
+			minMax->ptMaxTrackSize = MaxTrackSize();
+			minMax->ptMinTrackSize = MinTrackSize();
+		}
+		break;
+
+	case WM_MOUSEACTIVATE:
+		return MA_NOACTIVATE;
+
+	case WM_NCHITTEST:
+		return NcHitTest(wParam, lParam);
+
+	case WM_NCLBUTTONDOWN:
+		// We have to implement our own window resizing because the DefWindowProc
+		// implementation insists on activating the resized window
+		StartResize(wParam);
+		return 0;
+
+	case WM_MOUSEMOVE: {
+			if (resizeHit == 0) {
+				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+			}
+			ResizeToCursor();
+		}
+		break;
+
+	case WM_LBUTTONUP:
+	case WM_CANCELMODE:
+		if (resizeHit != 0) {
+			resizeHit = 0;
+			::ReleaseCapture();
+		}
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+	case WM_MOUSEWHEEL:
+		if (wheelDelta.Accumulate(wParam)) {
+			const int nRows = GetVisibleRows();
+			int linesToScroll = std::clamp(nRows - 1, 1, 3);
+			linesToScroll *= wheelDelta.Actions();
+			int top = ListBox_GetTopIndex(lb) + linesToScroll;
+			if (top < 0) {
+				top = 0;
+			}
+			ListBox_SetTopIndex(lb, top);
+		}
+		break;
+
+	default:
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+	}
+
+	return 0;
+}
+
+LRESULT PASCAL ListBoxX::StaticWndProc(
+    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	if (iMessage == WM_CREATE) {
+		CREATESTRUCT *pCreate = static_cast<CREATESTRUCT *>(PtrFromLParam(lParam));
+		SetWindowPointer(hWnd, pCreate->lpCreateParams);
+	}
+	// Find C++ object associated with window.
+	if (ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd))) {
+		return lbx->WndProc(hWnd, iMessage, wParam, lParam);
+	}
+	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+}
+
+namespace Scintilla::Internal {
+
+bool ListBoxX_Register() noexcept {
+	WNDCLASSEX wndclassc {};
+	wndclassc.cbSize = sizeof(wndclassc);
+	// We need CS_HREDRAW and CS_VREDRAW because of the ellipsis that might be drawn for
+	// truncated items in the list and the appearance/disappearance of the vertical scroll bar.
+	// The list repaint is double-buffered to avoid the flicker this would otherwise cause.
+	wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
+	wndclassc.cbWndExtra = sizeof(ListBoxX *);
+	wndclassc.hInstance = hinstPlatformRes;
+	wndclassc.lpfnWndProc = ListBoxX::StaticWndProc;
+	wndclassc.hCursor = ::LoadCursor({}, IDC_ARROW);
+	wndclassc.lpszClassName = ListBoxX_ClassName;
+
+	return ::RegisterClassEx(&wndclassc) != 0;
+}
+
+void ListBoxX_Unregister() noexcept {
+	if (hinstPlatformRes) {
+		::UnregisterClass(ListBoxX_ClassName, hinstPlatformRes);
+	}
+}
+
+ListBox::ListBox() noexcept = default;
+
+ListBox::~ListBox() noexcept = default;
+
+}
diff --git a/src/scintilla/win32/ListBox.h b/src/scintilla/win32/ListBox.h
new file mode 100644
index 000000000..cb3a17479
--- /dev/null
+++ b/src/scintilla/win32/ListBox.h
@@ -0,0 +1,18 @@
+// Scintilla source code edit control
+/** @file ListBox.h
+ ** Definitions for list box on Windows.
+ **/
+// Copyright 2025 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LISTBOX_H
+#define LISTBOX_H
+
+namespace Scintilla::Internal {
+
+bool ListBoxX_Register() noexcept;
+void ListBoxX_Unregister() noexcept;
+
+}
+
+#endif
diff --git a/src/scintilla/win32/PlatWin.cxx b/src/scintilla/win32/PlatWin.cxx
index a4fd552b2..ff47c28ab 100644
--- a/src/scintilla/win32/PlatWin.cxx
+++ b/src/scintilla/win32/PlatWin.cxx
@@ -63,220 +63,16 @@ using Microsoft::WRL::ComPtr;
 
 #include "WinTypes.h"
 #include "PlatWin.h"
-
-// __uuidof is a Microsoft extension but makes COM code neater, so disable warning
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wlanguage-extension-token"
+#include "ListBox.h"
+#if defined(USE_D2D)
+#include "SurfaceD2D.h"
 #endif
 
 using namespace Scintilla;
 
 namespace Scintilla::Internal {
 
-UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept;
-
-#if defined(USE_D2D)
-IDWriteFactory1 *pIDWriteFactory = nullptr;
-ID2D1Factory1 *pD2DFactory = nullptr;
-D2D1_DRAW_TEXT_OPTIONS d2dDrawTextOptions = D2D1_DRAW_TEXT_OPTIONS_NONE;
-
-namespace {
-
-HMODULE hDLLD2D{};
-HMODULE hDLLD3D{};
-HMODULE hDLLDWrite{};
-
-PFN_D3D11_CREATE_DEVICE fnDCD {};
-
-void LoadD2DOnce() noexcept {
-	DWORD loadLibraryFlags = 0;
-	HMODULE kernel32 = ::GetModuleHandleW(L"kernel32.dll");
-	if (kernel32) {
-		if (::GetProcAddress(kernel32, "SetDefaultDllDirectories")) {
-			// Availability of SetDefaultDllDirectories implies Windows 8+ or
-			// that KB2533623 has been installed so LoadLibraryEx can be called
-			// with LOAD_LIBRARY_SEARCH_SYSTEM32.
-			loadLibraryFlags = LOAD_LIBRARY_SEARCH_SYSTEM32;
-		}
-	}
-
-	typedef HRESULT (WINAPI *D2D1CFSig)(D2D1_FACTORY_TYPE factoryType, REFIID riid,
-		CONST D2D1_FACTORY_OPTIONS *pFactoryOptions, IUnknown **factory);
-	typedef HRESULT (WINAPI *DWriteCFSig)(DWRITE_FACTORY_TYPE factoryType, REFIID iid,
-		IUnknown **factory);
-
-	hDLLD2D = ::LoadLibraryEx(TEXT("D2D1.DLL"), {}, loadLibraryFlags);
-	D2D1CFSig fnD2DCF = DLLFunction<D2D1CFSig>(hDLLD2D, "D2D1CreateFactory");
-	if (fnD2DCF) {
-		const D2D1_FACTORY_OPTIONS options {};
-		// A multi threaded factory in case Scintilla is used with multiple GUI threads
-		fnD2DCF(D2D1_FACTORY_TYPE_MULTI_THREADED,
-			__uuidof(ID2D1Factory1),
-			&options,
-			reinterpret_cast<IUnknown**>(&pD2DFactory));
-	}
-	hDLLDWrite = ::LoadLibraryEx(TEXT("DWRITE.DLL"), {}, loadLibraryFlags);
-	DWriteCFSig fnDWCF = DLLFunction<DWriteCFSig>(hDLLDWrite, "DWriteCreateFactory");
-	if (fnDWCF) {
-		const GUID IID_IDWriteFactory2 = // 0439fc60-ca44-4994-8dee-3a9af7b732ec
-		{ 0x0439fc60, 0xca44, 0x4994, { 0x8d, 0xee, 0x3a, 0x9a, 0xf7, 0xb7, 0x32, 0xec } };
-
-		const HRESULT hr = fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
-			IID_IDWriteFactory2,
-			reinterpret_cast<IUnknown**>(&pIDWriteFactory));
-		if (SUCCEEDED(hr)) {
-			// D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT
-			d2dDrawTextOptions = static_cast<D2D1_DRAW_TEXT_OPTIONS>(0x00000004);
-		} else {
-			fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
-				__uuidof(IDWriteFactory1),
-				reinterpret_cast<IUnknown**>(&pIDWriteFactory));
-		}
-	}
-
-	hDLLD3D = ::LoadLibraryEx(TEXT("D3D11.DLL"), {}, loadLibraryFlags);
-	if (!hDLLD3D) {
-		Platform::DebugPrintf("Direct3D not loaded\n");
-	}
-	fnDCD = DLLFunction<PFN_D3D11_CREATE_DEVICE>(hDLLD3D, "D3D11CreateDevice");
-	if (!fnDCD) {
-		Platform::DebugPrintf("Direct3D does not have D3D11CreateDevice\n");
-	}
-}
-
-}
-
-HRESULT CreateD3D(D3D11Device &device) noexcept {
-	device = nullptr;
-	if (!fnDCD) {
-		return E_FAIL;
-	}
-
-	const D3D_FEATURE_LEVEL featureLevels[] = {
-		D3D_FEATURE_LEVEL_11_1,
-		D3D_FEATURE_LEVEL_11_0,
-		D3D_FEATURE_LEVEL_10_1,
-		D3D_FEATURE_LEVEL_10_0,
-		D3D_FEATURE_LEVEL_9_3,
-		D3D_FEATURE_LEVEL_9_2,
-		D3D_FEATURE_LEVEL_9_1
-	};
-
-	// Create device.
-	// Try for a hardware device but, if that fails, fall back to the Warp software rasterizer.
-	ComPtr<ID3D11Device> upDevice;
-	HRESULT hr = S_OK;
-	const D3D_DRIVER_TYPE typesToTry[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP };
-	for (const D3D_DRIVER_TYPE type : typesToTry) {
-		hr = fnDCD(nullptr,
-			type,
-			{},
-			D3D11_CREATE_DEVICE_BGRA_SUPPORT,
-			featureLevels,
-			ARRAYSIZE(featureLevels),
-			D3D11_SDK_VERSION,
-			upDevice.GetAddressOf(),
-			nullptr,
-			nullptr);
-		if (SUCCEEDED(hr))
-			break;
-	}
-	if (FAILED(hr)) {
-		Platform::DebugPrintf("Failed to create D3D11 device 0x%lx\n", hr);
-		return hr;
-	}
-
-	// Convert from D3D11 to D3D11.1
-	hr = upDevice.As(&device);
-	if (FAILED(hr)) {
-		Platform::DebugPrintf("Failed to create D3D11.1 device 0x%lx\n", hr);
-	}
-	return hr;
-}
-
-bool LoadD2D() noexcept {
-	static std::once_flag once;
-	try {
-		std::call_once(once, LoadD2DOnce);
-	} catch (...) {
-		// ignore
-	}
-	return pIDWriteFactory && pD2DFactory;
-}
-
-HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept {
-	return pD2DFactory->CreateDCRenderTarget(renderTargetProperties, dcRT.ReleaseAndGetAddressOf());
-}
-
-namespace {
-
-constexpr D2D_COLOR_F ColorFromColourAlpha(ColourRGBA colour) noexcept {
-	return D2D_COLOR_F{
-		colour.GetRedComponent(),
-		colour.GetGreenComponent(),
-		colour.GetBlueComponent(),
-		colour.GetAlphaComponent()
-	};
-}
-
-using BrushSolid = ComPtr<ID2D1SolidColorBrush>;
-
-BrushSolid BrushSolidCreate(ID2D1RenderTarget *pTarget, COLORREF colour) noexcept {
-	BrushSolid brush;
-	const D2D_COLOR_F col = ColorFromColourAlpha(ColourRGBA::FromRGB(colour));
-	if (FAILED(pTarget->CreateSolidColorBrush(col, brush.GetAddressOf()))) {
-		return {};
-	}
-	return brush;
-}
-
-using Geometry = ComPtr<ID2D1PathGeometry>;
-
-Geometry GeometryCreate() noexcept {
-	Geometry geometry;
-	if (FAILED(pD2DFactory->CreatePathGeometry(geometry.GetAddressOf()))) {
-		return {};
-	}
-	return geometry;
-}
-
-using GeometrySink = ComPtr<ID2D1GeometrySink>;
-
-GeometrySink GeometrySinkCreate(ID2D1PathGeometry *geometry) noexcept {
-	GeometrySink sink;
-	if (FAILED(geometry->Open(sink.GetAddressOf()))) {
-		return {};
-	}
-	return sink;
-}
-
-using StrokeStyle = ComPtr<ID2D1StrokeStyle>;
-
-StrokeStyle StrokeStyleCreate(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties) noexcept {
-	StrokeStyle strokeStyle;
-	const HRESULT hr = pD2DFactory->CreateStrokeStyle(
-		strokeStyleProperties, nullptr, 0, strokeStyle.GetAddressOf());
-	if (FAILED(hr)) {
-		return {};
-	}
-	return strokeStyle;
-}
-
-using TextLayout = ComPtr<IDWriteTextLayout>;
-
-TextLayout LayoutCreate(std::wstring_view wsv, IDWriteTextFormat *pTextFormat, FLOAT maxWidth=10000.0F, FLOAT maxHeight=1000.0F) noexcept {
-	TextLayout layout;
-	const HRESULT hr = pIDWriteFactory->CreateTextLayout(wsv.data(), static_cast<UINT32>(wsv.length()),
-		pTextFormat, maxWidth, maxHeight, layout.GetAddressOf());
-	if (FAILED(hr)) {
-		return {};
-	}
-	return layout;
-}
-
-}
-
-#endif
+HINSTANCE hinstPlatformRes{};
 
 void *PointerFromWindow(HWND hWnd) noexcept {
 	return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
@@ -294,8 +90,8 @@ UINT uSystemDPI = USER_DEFAULT_SCREEN_DPI;
 using GetDpiForWindowSig = UINT(WINAPI *)(HWND hwnd);
 GetDpiForWindowSig fnGetDpiForWindow = nullptr;
 
-HMODULE hDLLShcore {};
-using GetDpiForMonitorSig = HRESULT (WINAPI *)(HMONITOR hmonitor, /*MONITOR_DPI_TYPE*/int dpiType, UINT *dpiX, UINT *dpiY);
+HMODULE hDLLShcore{};
+using GetDpiForMonitorSig = HRESULT(WINAPI *)(HMONITOR hmonitor, /*MONITOR_DPI_TYPE*/int dpiType, UINT *dpiX, UINT *dpiY);
 GetDpiForMonitorSig fnGetDpiForMonitor = nullptr;
 
 using GetSystemMetricsForDpiSig = int(WINAPI *)(int nIndex, UINT dpi);
@@ -343,177 +139,6 @@ void LoadDpiForWindow() noexcept {
 	}
 }
 
-HINSTANCE hinstPlatformRes {};
-
-constexpr Supports SupportsGDI[] = {
-	Supports::PixelModification,
-};
-
-constexpr BYTE Win32MapFontQuality(FontQuality extraFontFlag) noexcept {
-	switch (extraFontFlag & FontQuality::QualityMask) {
-
-		case FontQuality::QualityNonAntialiased:
-			return NONANTIALIASED_QUALITY;
-
-		case FontQuality::QualityAntialiased:
-			return ANTIALIASED_QUALITY;
-
-		case FontQuality::QualityLcdOptimized:
-			return CLEARTYPE_QUALITY;
-
-		default:
-			return DEFAULT_QUALITY;
-	}
-}
-
-#if defined(USE_D2D)
-constexpr D2D1_TEXT_ANTIALIAS_MODE DWriteMapFontQuality(FontQuality extraFontFlag) noexcept {
-	switch (extraFontFlag & FontQuality::QualityMask) {
-
-		case FontQuality::QualityNonAntialiased:
-			return D2D1_TEXT_ANTIALIAS_MODE_ALIASED;
-
-		case FontQuality::QualityAntialiased:
-			return D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE;
-
-		case FontQuality::QualityLcdOptimized:
-			return D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
-
-		default:
-			return D2D1_TEXT_ANTIALIAS_MODE_DEFAULT;
-	}
-}
-#endif
-
-// Both GDI and DirectWrite can produce a HFONT for use in list boxes
-struct FontWin : public Font {
-	[[nodiscard]] virtual HFONT HFont() const noexcept = 0;
-};
-
-void SetLogFont(LOGFONTW &lf, const char *faceName, CharacterSet characterSet, XYPOSITION size, FontWeight weight, bool italic, FontQuality extraFontFlag) {
-	lf = LOGFONTW();
-	// The negative is to allow for leading
-	lf.lfHeight = -(std::abs(std::lround(size)));
-	lf.lfWeight = static_cast<LONG>(weight);
-	lf.lfItalic = italic ? 1 : 0;
-	lf.lfCharSet = static_cast<BYTE>(characterSet);
-	lf.lfQuality = Win32MapFontQuality(extraFontFlag);
-	UTF16FromUTF8(faceName, lf.lfFaceName, LF_FACESIZE);
-}
-
-struct FontGDI : public FontWin {
-	HFONT hfont = {};
-	explicit FontGDI(const FontParameters &fp) {
-		LOGFONTW lf;
-		SetLogFont(lf, fp.faceName, fp.characterSet, fp.size, fp.weight, fp.italic, fp.extraFontFlag);
-		hfont = ::CreateFontIndirectW(&lf);
-	}
-	// Deleted so FontGDI objects can not be copied.
-	FontGDI(const FontGDI &) = delete;
-	FontGDI(FontGDI &&) = delete;
-	FontGDI &operator=(const FontGDI &) = delete;
-	FontGDI &operator=(FontGDI &&) = delete;
-	~FontGDI() noexcept override {
-		if (hfont)
-			::DeleteObject(hfont);
-	}
-	[[nodiscard]] HFONT HFont() const noexcept override {
-		// Duplicating hfont
-		LOGFONTW lf = {};
-		if (0 == ::GetObjectW(hfont, sizeof(lf), &lf)) {
-			return {};
-		}
-		return ::CreateFontIndirectW(&lf);
-	}
-};
-
-#if defined(USE_D2D)
-struct FontDirectWrite : public FontWin {
-	ComPtr<IDWriteTextFormat> pTextFormat;
-	FontQuality extraFontFlag = FontQuality::QualityDefault;
-	CharacterSet characterSet = CharacterSet::Ansi;
-	FLOAT yAscent = 2.0f;
-	FLOAT yDescent = 1.0f;
-	FLOAT yInternalLeading = 0.0f;
-
-	explicit FontDirectWrite(const FontParameters &fp) :
-		extraFontFlag(fp.extraFontFlag),
-		characterSet(fp.characterSet) {
-		const std::wstring wsFace = WStringFromUTF8(fp.faceName);
-		const std::wstring wsLocale = WStringFromUTF8(fp.localeName);
-		const FLOAT fHeight = static_cast<FLOAT>(fp.size);
-		const DWRITE_FONT_STYLE style = fp.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
-		HRESULT hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
-			static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
-			style,
-			static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
-				fHeight, wsLocale.c_str(), pTextFormat.GetAddressOf());
-		if (hr == E_INVALIDARG) {
-			// Possibly a bad locale name like "/" so try "en-us".
-			hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
-				static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
-				style,
-				static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
-				fHeight, L"en-us", pTextFormat.ReleaseAndGetAddressOf());
-		}
-		if (SUCCEEDED(hr)) {
-			pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
-
-			if (TextLayout pTextLayout = LayoutCreate(L"X", pTextFormat.Get())) {
-				constexpr int maxLines = 2;
-				DWRITE_LINE_METRICS lineMetrics[maxLines]{};
-				UINT32 lineCount = 0;
-				hr = pTextLayout->GetLineMetrics(lineMetrics, maxLines, &lineCount);
-				if (SUCCEEDED(hr)) {
-					yAscent = lineMetrics[0].baseline;
-					yDescent = lineMetrics[0].height - lineMetrics[0].baseline;
-
-					FLOAT emHeight;
-					hr = pTextLayout->GetFontSize(0, &emHeight);
-					if (SUCCEEDED(hr)) {
-						yInternalLeading = lineMetrics[0].height - emHeight;
-					}
-				}
-				pTextFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineMetrics[0].height, lineMetrics[0].baseline);
-			}
-		}
-	}
-	// Deleted so FontDirectWrite objects can not be copied.
-	FontDirectWrite(const FontDirectWrite &) = delete;
-	FontDirectWrite(FontDirectWrite &&) = delete;
-	FontDirectWrite &operator=(const FontDirectWrite &) = delete;
-	FontDirectWrite &operator=(FontDirectWrite &&) = delete;
-	~FontDirectWrite() noexcept override = default;
-	[[nodiscard]] HFONT HFont() const noexcept override {
-		LOGFONTW lf = {};
-		const HRESULT hr = pTextFormat->GetFontFamilyName(lf.lfFaceName, LF_FACESIZE);
-		if (!SUCCEEDED(hr)) {
-			return {};
-		}
-		lf.lfWeight = pTextFormat->GetFontWeight();
-		lf.lfItalic = pTextFormat->GetFontStyle() == DWRITE_FONT_STYLE_ITALIC;
-		lf.lfHeight = -static_cast<int>(pTextFormat->GetFontSize());
-		return ::CreateFontIndirectW(&lf);
-	}
-
-	[[nodiscard]] int CodePageText(int codePage) const noexcept {
-		if (!(codePage == CpUtf8) && (characterSet != CharacterSet::Ansi)) {
-			codePage = CodePageFromCharSet(characterSet, codePage);
-		}
-		return codePage;
-	}
-
-	static const FontDirectWrite *Cast(const Font *font_) {
-		const FontDirectWrite *pfm = dynamic_cast<const FontDirectWrite *>(font_);
-		PLATFORM_ASSERT(pfm);
-		if (!pfm) {
-			throw std::runtime_error("SurfaceD2D::SetFont: wrong Font type.");
-		}
-		return pfm;
-	}
-};
-#endif
-
 }
 
 HMONITOR MonitorFromWindowHandleScaling(HWND hWnd) noexcept {
@@ -543,70 +168,12 @@ float GetDeviceScaleFactorWhenGdiScalingActive(HWND hWnd) noexcept {
 			const HMONITOR hMonitor = MonitorFromWindowHandleScaling(hRootWnd);
 			DEVICE_SCALE_FACTOR deviceScaleFactor;
 			if (S_OK == fnGetScaleFactorForMonitor(hMonitor, &deviceScaleFactor))
-				return static_cast<int>(deviceScaleFactor) / 100.f;
+				return static_cast<float>(static_cast<int>(deviceScaleFactor)) / 100.f;
 		}
 	}
 	return 1.f;
 }
 
-std::shared_ptr<Font> Font::Allocate(const FontParameters &fp) {
-#if defined(USE_D2D)
-	if (fp.technology != Technology::Default) {
-		return std::make_shared<FontDirectWrite>(fp);
-	}
-#endif
-	return std::make_shared<FontGDI>(fp);
-}
-
-// Buffer to hold strings and string position arrays without always allocating on heap.
-// May sometimes have string too long to allocate on stack. So use a fixed stack-allocated buffer
-// when less than safe size otherwise allocate on heap and free automatically.
-template<typename T, int lengthStandard>
-class VarBuffer {
-	T bufferStandard[lengthStandard];
-public:
-	T *buffer;
-	explicit VarBuffer(size_t length) : buffer(nullptr) {
-		if (length > lengthStandard) {
-			buffer = new T[length];
-		} else {
-			buffer = bufferStandard;
-		}
-	}
-	// Deleted so VarBuffer objects can not be copied.
-	VarBuffer(const VarBuffer &) = delete;
-	VarBuffer(VarBuffer &&) = delete;
-	VarBuffer &operator=(const VarBuffer &) = delete;
-	VarBuffer &operator=(VarBuffer &&) = delete;
-
-	~VarBuffer() noexcept {
-		if (buffer != bufferStandard) {
-			delete []buffer;
-			buffer = nullptr;
-		}
-	}
-};
-
-constexpr int stackBufferLength = 400;
-class TextWide : public VarBuffer<wchar_t, stackBufferLength> {
-public:
-	int tlen;	// Using int instead of size_t as most Win32 APIs take int.
-	TextWide(std::string_view text, int codePage) :
-		VarBuffer<wchar_t, stackBufferLength>(text.length()) {
-		if (codePage == CpUtf8) {
-			tlen = static_cast<int>(UTF16FromUTF8(text, buffer, text.length()));
-		} else {
-			// Support Asian string display in 9x English
-			tlen = ::MultiByteToWideChar(codePage, 0, text.data(), static_cast<int>(text.length()),
-				buffer, static_cast<int>(text.length()));
-		}
-	}
-	[[nodiscard]] std::wstring_view AsView() const noexcept {
-		return std::wstring_view(buffer, tlen);
-	}
-};
-using TextPositions = VarBuffer<XYPOSITION, stackBufferLength>;
-
 UINT DpiForWindow(WindowID wid) noexcept {
 	if (fnGetDpiForWindow) {
 		return fnGetDpiForWindow(HwndFromWindowID(wid));
@@ -632,3459 +199,480 @@ int SystemMetricsForDpi(int nIndex, UINT dpi) noexcept {
 	return value;
 }
 
-class SurfaceGDI : public Surface {
-	SurfaceMode mode;
-	HDC hdc{};
-	bool hdcOwned=false;
-	HPEN pen{};
-	HPEN penOld{};
-	HBRUSH brush{};
-	HBRUSH brushOld{};
-	HFONT fontOld{};
-	HBITMAP bitmap{};
-	HBITMAP bitmapOld{};
-
-	int logPixelsY = USER_DEFAULT_SCREEN_DPI;
-
-	static constexpr int maxWidthMeasure = INT_MAX;
-	// There appears to be a 16 bit string length limit in GDI on NT.
-	static constexpr int maxLenText = 65535;
-
-	void PenColour(ColourRGBA fore, XYPOSITION widthStroke) noexcept;
-
-	void BrushColour(ColourRGBA back) noexcept;
-	void SetFont(const Font *font_);
-	void Clear() noexcept;
-
-public:
-	SurfaceGDI() noexcept = default;
-	SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
-	// Deleted so SurfaceGDI objects can not be copied.
-	SurfaceGDI(const SurfaceGDI &) = delete;
-	SurfaceGDI(SurfaceGDI &&) = delete;
-	SurfaceGDI &operator=(const SurfaceGDI &) = delete;
-	SurfaceGDI &operator=(SurfaceGDI &&) = delete;
-
-	~SurfaceGDI() noexcept override;
-
-	void Init(WindowID wid) override;
-	void Init(SurfaceID sid, WindowID wid) override;
-	std::unique_ptr<Surface> AllocatePixMap(int width, int height) override;
-
-	void SetMode(SurfaceMode mode_) override;
-
-	void Release() noexcept override;
-	int SupportsFeature(Supports feature) noexcept override;
-	bool Initialised() override;
-	int LogPixelsY() override;
-	int PixelDivisions() override;
-	int DeviceHeightFont(int points) override;
-	void LineDraw(Point start, Point end, Stroke stroke) override;
-	void PolyLine(const Point *pts, size_t npts, Stroke stroke) override;
-	void Polygon(const Point *pts, size_t npts, FillStroke fillStroke) override;
-	void RectangleDraw(PRectangle rc, FillStroke fillStroke) override;
-	void RectangleFrame(PRectangle rc, Stroke stroke) override;
-	void FillRectangle(PRectangle rc, Fill fill) override;
-	void FillRectangleAligned(PRectangle rc, Fill fill) override;
-	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
-	void RoundedRectangle(PRectangle rc, FillStroke fillStroke) override;
-	void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) override;
-	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
-	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
-	void Ellipse(PRectangle rc, FillStroke fillStroke) override;
-	void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) override;
-	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;
-
-	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;
-
-	void DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
-	void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
-	void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) override;
-	XYPOSITION WidthText(const Font *font_, std::string_view text) override;
-
-	void DrawTextCommonUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
-	void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
-	void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) override;
-	XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) override;
-
-	XYPOSITION Ascent(const Font *font_) override;
-	XYPOSITION Descent(const Font *font_) override;
-	XYPOSITION InternalLeading(const Font *font_) override;
-	XYPOSITION Height(const Font *font_) override;
-	XYPOSITION AverageCharWidth(const Font *font_) override;
-
-	void SetClip(PRectangle rc) override;
-	void PopClip() override;
-	void FlushCachedState() override;
-	void FlushDrawing() override;
-};
-
-SurfaceGDI::SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
-	hdc = ::CreateCompatibleDC(hdcCompatible);
-	hdcOwned = true;
-	bitmap = ::CreateCompatibleBitmap(hdcCompatible, width, height);
-	bitmapOld = SelectBitmap(hdc, bitmap);
-	::SetTextAlign(hdc, TA_BASELINE);
-	mode = mode_;
-	logPixelsY = logPixelsY_;
-}
-
-SurfaceGDI::~SurfaceGDI() noexcept {
-	Clear();
-}
-
-void SurfaceGDI::Clear() noexcept {
-	if (penOld) {
-		::SelectObject(hdc, penOld);
-		::DeleteObject(pen);
-		penOld = {};
-	}
-	pen = {};
-	if (brushOld) {
-		::SelectObject(hdc, brushOld);
-		::DeleteObject(brush);
-		brushOld = {};
-	}
-	brush = {};
-	if (fontOld) {
-		// Fonts are not deleted as they are owned by a Font object
-		::SelectObject(hdc, fontOld);
-		fontOld = {};
-	}
-	if (bitmapOld) {
-		::SelectObject(hdc, bitmapOld);
-		::DeleteObject(bitmap);
-		bitmapOld = {};
-	}
-	bitmap = {};
-	if (hdcOwned) {
-		::DeleteDC(hdc);
-		hdc = {};
-		hdcOwned = false;
+void AdjustWindowRectForDpi(LPRECT lpRect, DWORD dwStyle, UINT dpi) noexcept {
+	if (fnAdjustWindowRectExForDpi) {
+		fnAdjustWindowRectExForDpi(lpRect, dwStyle, false, WS_EX_WINDOWEDGE, dpi);
+	} else {
+		::AdjustWindowRectEx(lpRect, dwStyle, false, WS_EX_WINDOWEDGE);
 	}
 }
 
-void SurfaceGDI::Release() noexcept {
-	Clear();
-}
+namespace {
 
-int SurfaceGDI::SupportsFeature(Supports feature) noexcept {
-	for (const Supports f : SupportsGDI) {
-		if (f == feature)
-			return 1;
+constexpr BITMAPV5HEADER BitMapHeader(int width, int height) noexcept {
+	constexpr int pixelBits = 32;
+
+	// Divide each pixel up in the expected BGRA manner.
+	// Compatible with DXGI_FORMAT_B8G8R8A8_UNORM.
+	constexpr DWORD maskRed = 0x00FF0000U;
+	constexpr DWORD maskGreen = 0x0000FF00U;
+	constexpr DWORD maskBlue = 0x000000FFU;
+	constexpr DWORD maskAlpha = 0xFF000000U;
+
+	BITMAPV5HEADER bi{};
+	bi.bV5Size = sizeof(BITMAPV5HEADER);
+	bi.bV5Width = width;
+	bi.bV5Height = height;
+	bi.bV5Planes = 1;
+	bi.bV5BitCount = pixelBits;
+	bi.bV5Compression = BI_BITFIELDS;
+	// The following mask specification specifies a supported 32 BPP alpha format for Windows XP.
+	bi.bV5RedMask = maskRed;
+	bi.bV5GreenMask = maskGreen;
+	bi.bV5BlueMask = maskBlue;
+	bi.bV5AlphaMask = maskAlpha;
+	return bi;
+}
+
+HBITMAP BitMapSection(HDC hdc, int width, int height, DWORD **pixels) noexcept {
+	const BITMAPV5HEADER bi = BitMapHeader(width, height);
+	void *image = nullptr;
+	HBITMAP hbm = ::CreateDIBSection(hdc, reinterpret_cast<const BITMAPINFO *>(&bi), DIB_RGB_COLORS, &image, {}, 0);
+	if (pixels) {
+		*pixels = static_cast<DWORD *>(image);
 	}
-	return 0;
+	return hbm;
 }
 
-bool SurfaceGDI::Initialised() {
-	return hdc != 0;
 }
 
-void SurfaceGDI::Init(WindowID wid) {
+GDIBitMap::~GDIBitMap() noexcept {
 	Release();
-	hdc = ::CreateCompatibleDC({});
-	hdcOwned = true;
-	::SetTextAlign(hdc, TA_BASELINE);
-	logPixelsY = DpiForWindow(wid);
 }
 
-void SurfaceGDI::Init(SurfaceID sid, WindowID wid) {
+void GDIBitMap::Create(HDC hdcBase, int width, int height, DWORD **pixels) noexcept {
 	Release();
-	hdc = static_cast<HDC>(sid);
-	::SetTextAlign(hdc, TA_BASELINE);
-	// Windows on screen are scaled but printers are not.
-	const bool printing = ::GetDeviceCaps(hdc, TECHNOLOGY) != DT_RASDISPLAY;
-	logPixelsY = printing ? ::GetDeviceCaps(hdc, LOGPIXELSY) : DpiForWindow(wid);
-}
 
-std::unique_ptr<Surface> SurfaceGDI::AllocatePixMap(int width, int height) {
-	return std::make_unique<SurfaceGDI>(hdc, width, height, mode, logPixelsY);
-}
+	hdc = CreateCompatibleDC(hdcBase);
+	if (!hdc) {
+		return;
+	}
 
-void SurfaceGDI::SetMode(SurfaceMode mode_) {
-	mode = mode_;
+	hbm = BitMapSection(hdc, width, height, pixels);
+	if (!hbm) {
+		return;
+	}
+	hbmOriginal = SelectBitmap(hdc, hbm);
 }
 
-void SurfaceGDI::PenColour(ColourRGBA fore, XYPOSITION widthStroke) noexcept {
-	if (pen) {
-		::SelectObject(hdc, penOld);
-		::DeleteObject(pen);
-		pen = {};
-		penOld = {};
+void GDIBitMap::Release() noexcept {
+	if (hbmOriginal) {
+		// Deselect HBITMAP from HDC so it may be deleted.
+		SelectBitmap(hdc, hbmOriginal);
 	}
-	const DWORD penWidth = std::lround(widthStroke);
-	const COLORREF penColour = fore.OpaqueRGB();
-	if (widthStroke > 1) {
-		const LOGBRUSH brushParameters{ BS_SOLID, penColour, 0 };
-		pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
-			penWidth,
-			&brushParameters,
-			0,
-			nullptr);
-	} else {
-		pen = ::CreatePen(PS_INSIDEFRAME, penWidth, penColour);
+	hbmOriginal = {};
+	if (hbm) {
+		::DeleteObject(hbm);
 	}
-	penOld = SelectPen(hdc, pen);
-}
-
-void SurfaceGDI::BrushColour(ColourRGBA back) noexcept {
-	if (brush) {
-		::SelectObject(hdc, brushOld);
-		::DeleteObject(brush);
-		brush = {};
-		brushOld = {};
+	hbm = {};
+	if (hdc) {
+		::DeleteDC(hdc);
 	}
-	brush = ::CreateSolidBrush(back.OpaqueRGB());
-	brushOld = SelectBrush(hdc, brush);
+	hdc = {};
 }
 
-void SurfaceGDI::SetFont(const Font *font_) {
-	const FontGDI *pfm = dynamic_cast<const FontGDI *>(font_);
-	PLATFORM_ASSERT(pfm);
-	if (!pfm) {
-		throw std::runtime_error("SurfaceGDI::SetFont: wrong Font type.");
-	}
-	if (fontOld) {
-		SelectFont(hdc, pfm->hfont);
-	} else {
-		fontOld = SelectFont(hdc, pfm->hfont);
+HBITMAP GDIBitMap::Extract() noexcept {
+	// Deselect HBITMAP from HDC but keep so can delete.
+	// The caller will make a copy, not take ownership.
+	HBITMAP ret = hbm;
+	if (hbmOriginal) {
+		SelectBitmap(hdc, hbmOriginal);
+		hbmOriginal = {};
 	}
+	return ret;
 }
 
-int SurfaceGDI::LogPixelsY() {
-	return logPixelsY;
-}
+Window::~Window() noexcept = default;
 
-int SurfaceGDI::PixelDivisions() {
-	// Win32 uses device pixels.
-	return 1;
+void Window::Destroy() noexcept {
+	if (wid)
+		::DestroyWindow(HwndFromWindowID(wid));
+	wid = nullptr;
 }
 
-int SurfaceGDI::DeviceHeightFont(int points) {
-	return ::MulDiv(points, LogPixelsY(), 72);
+PRectangle Window::GetPosition() const {
+	RECT rc;
+	::GetWindowRect(HwndFromWindowID(wid), &rc);
+	return PRectangleFromRECT(rc);
 }
 
-void SurfaceGDI::LineDraw(Point start, Point end, Stroke stroke) {
-	PenColour(stroke.colour, stroke.width);
-	::MoveToEx(hdc, std::lround(std::floor(start.x)), std::lround(std::floor(start.y)), nullptr);
-	::LineTo(hdc, std::lround(std::floor(end.x)), std::lround(std::floor(end.y)));
+void Window::SetPosition(PRectangle rc) {
+	::SetWindowPos(HwndFromWindowID(wid),
+		{}, static_cast<int>(rc.left), static_cast<int>(rc.top),
+		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void SurfaceGDI::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
-	PLATFORM_ASSERT(npts > 1);
-	if (npts <= 1) {
-		return;
+namespace {
+
+RECT RectFromMonitor(HMONITOR hMonitor) noexcept {
+	MONITORINFO mi = {};
+	mi.cbSize = sizeof(mi);
+	if (GetMonitorInfo(hMonitor, &mi)) {
+		return mi.rcWork;
+	}
+	RECT rc = {0, 0, 0, 0};
+	if (::SystemParametersInfoA(SPI_GETWORKAREA, 0, &rc, 0) == 0) {
+		rc.left = 0;
+		rc.top = 0;
+		rc.right = 0;
+		rc.bottom = 0;
 	}
-	PenColour(stroke.colour, stroke.width);
-	std::vector<POINT> outline;
-	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
-	::Polyline(hdc, outline.data(), static_cast<int>(npts));
+	return rc;
 }
 
-void SurfaceGDI::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
-	PenColour(fillStroke.stroke.colour.WithoutAlpha(), fillStroke.stroke.width);
-	BrushColour(fillStroke.fill.colour.WithoutAlpha());
-	std::vector<POINT> outline;
-	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
-	::Polygon(hdc, outline.data(), static_cast<int>(npts));
 }
 
-void SurfaceGDI::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
-	RectangleFrame(rc, fillStroke.stroke);
-	FillRectangle(rc.Inset(fillStroke.stroke.width), fillStroke.fill.colour);
-}
+void Window::SetPositionRelative(PRectangle rc, const Window *relativeTo) {
+	const DWORD style = GetWindowStyle(HwndFromWindowID(wid));
+	if (style & WS_POPUP) {
+		POINT ptOther = {0, 0};
+		::ClientToScreen(HwndFromWindow(*relativeTo), &ptOther);
+		rc.Move(static_cast<XYPOSITION>(ptOther.x), static_cast<XYPOSITION>(ptOther.y));
 
-void SurfaceGDI::RectangleFrame(PRectangle rc, Stroke stroke) {
-	BrushColour(stroke.colour);
-	const RECT rcw = RectFromPRectangle(rc);
-	::FrameRect(hdc, &rcw, brush);
-}
+		const RECT rcMonitor = RectFromPRectangle(rc);
 
-void SurfaceGDI::FillRectangle(PRectangle rc, Fill fill) {
-	if (fill.colour.IsOpaque()) {
-		// Using ExtTextOut rather than a FillRect ensures that no dithering occurs.
-		// There is no need to allocate a brush either.
-		const RECT rcw = RectFromPRectangle(rc);
-		::SetBkColor(hdc, fill.colour.OpaqueRGB());
-		::ExtTextOut(hdc, rcw.left, rcw.top, ETO_OPAQUE, &rcw, TEXT(""), 0, nullptr);
-	} else {
-		AlphaRectangle(rc, 0, FillStroke(fill.colour));
+		HMONITOR hMonitor = MonitorFromRect(&rcMonitor, MONITOR_DEFAULTTONEAREST);
+		// If hMonitor is NULL, that's just the main screen anyways.
+		const RECT rcWork = RectFromMonitor(hMonitor);
+
+		if (rcWork.left < rcWork.right) {
+			// Now clamp our desired rectangle to fit inside the work area
+			// This way, the menu will fit wholly on one screen. An improvement even
+			// if you don't have a second monitor on the left... Menu's appears half on
+			// one screen and half on the other are just U.G.L.Y.!
+			if (rc.right > rcWork.right)
+				rc.Move(rcWork.right - rc.right, 0);
+			if (rc.bottom > rcWork.bottom)
+				rc.Move(0, rcWork.bottom - rc.bottom);
+			if (rc.left < rcWork.left)
+				rc.Move(rcWork.left - rc.left, 0);
+			if (rc.top < rcWork.top)
+				rc.Move(0, rcWork.top - rc.top);
+		}
 	}
+	SetPosition(rc);
 }
 
-void SurfaceGDI::FillRectangleAligned(PRectangle rc, Fill fill) {
-	FillRectangle(PixelAlign(rc, 1), fill);
+PRectangle Window::GetClientPosition() const {
+	RECT rc={0,0,0,0};
+	if (wid)
+		::GetClientRect(HwndFromWindowID(wid), &rc);
+	return PRectangleFromRECT(rc);
 }
 
-void SurfaceGDI::FillRectangle(PRectangle rc, Surface &surfacePattern) {
-	HBRUSH br{};
-	if (SurfaceGDI *psgdi = dynamic_cast<SurfaceGDI *>(&surfacePattern); psgdi && psgdi->bitmap) {
-		br = ::CreatePatternBrush(psgdi->bitmap);
-	} else {	// Something is wrong so display in red
-		br = ::CreateSolidBrush(RGB(0xff, 0, 0));
-	}
-	const RECT rcw = RectFromPRectangle(rc);
-	::FillRect(hdc, &rcw, br);
-	::DeleteObject(br);
-}
-
-void SurfaceGDI::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
-	PenColour(fillStroke.stroke.colour, fillStroke.stroke.width);
-	BrushColour(fillStroke.fill.colour);
-	const RECT rcw = RectFromPRectangle(rc);
-	::RoundRect(hdc,
-		rcw.left + 1, rcw.top,
-		rcw.right - 1, rcw.bottom,
-		8, 8);
-}
-
-namespace {
-
-constexpr DWORD dwordFromBGRA(byte b, byte g, byte r, byte a) noexcept {
-	return (a << 24) | (r << 16) | (g << 8) | b;
-}
-
-constexpr byte AlphaScaled(unsigned char component, unsigned int alpha) noexcept {
-	return static_cast<byte>(component * alpha / 255);
-}
-
-constexpr DWORD dwordMultiplied(ColourRGBA colour) noexcept {
-	return dwordFromBGRA(
-		AlphaScaled(colour.GetBlue(), colour.GetAlpha()),
-		AlphaScaled(colour.GetGreen(), colour.GetAlpha()),
-		AlphaScaled(colour.GetRed(), colour.GetAlpha()),
-		colour.GetAlpha());
-}
-
-class DIBSection {
-	HDC hMemDC {};
-	HBITMAP hbmMem {};
-	HBITMAP hbmOld {};
-	SIZE size {};
-	DWORD *pixels = nullptr;
-public:
-	DIBSection(HDC hdc, SIZE size_) noexcept;
-	// Deleted so DIBSection objects can not be copied.
-	DIBSection(const DIBSection&) = delete;
-	DIBSection(DIBSection&&) = delete;
-	DIBSection &operator=(const DIBSection&) = delete;
-	DIBSection &operator=(DIBSection&&) = delete;
-	~DIBSection() noexcept;
-	operator bool() const noexcept {
-		return hMemDC && hbmMem && pixels;
-	}
-	[[nodiscard]] DWORD *Pixels() const noexcept {
-		return pixels;
-	}
-	[[nodiscard]] unsigned char *Bytes() const noexcept {
-		return reinterpret_cast<unsigned char *>(pixels);
-	}
-	[[nodiscard]] HDC DC() const noexcept {
-		return hMemDC;
-	}
-	void SetPixel(LONG x, LONG y, DWORD value) noexcept {
-		PLATFORM_ASSERT(x >= 0);
-		PLATFORM_ASSERT(y >= 0);
-		PLATFORM_ASSERT(x < size.cx);
-		PLATFORM_ASSERT(y < size.cy);
-		pixels[y * size.cx + x] = value;
-	}
-	void SetSymmetric(LONG x, LONG y, DWORD value) noexcept;
-};
-
-DIBSection::DIBSection(HDC hdc, SIZE size_) noexcept {
-	hMemDC = ::CreateCompatibleDC(hdc);
-	if (!hMemDC) {
-		return;
-	}
-
-	size = size_;
-
-	// -size.y makes bitmap start from top
-	const BITMAPINFO bpih = { {sizeof(BITMAPINFOHEADER), size.cx, -size.cy, 1, 32, BI_RGB, 0, 0, 0, 0, 0},
-		{{0, 0, 0, 0}} };
-	void *image = nullptr;
-	hbmMem = CreateDIBSection(hMemDC, &bpih, DIB_RGB_COLORS, &image, {}, 0);
-	if (!hbmMem || !image) {
-		return;
-	}
-	pixels = static_cast<DWORD *>(image);
-	hbmOld = SelectBitmap(hMemDC, hbmMem);
-}
-
-DIBSection::~DIBSection() noexcept {
-	if (hbmOld) {
-		SelectBitmap(hMemDC, hbmOld);
-		hbmOld = {};
-	}
-	if (hbmMem) {
-		::DeleteObject(hbmMem);
-		hbmMem = {};
-	}
-	if (hMemDC) {
-		::DeleteDC(hMemDC);
-		hMemDC = {};
-	}
-}
-
-void DIBSection::SetSymmetric(LONG x, LONG y, DWORD value) noexcept {
-	// Plot a point symmetrically to all 4 quadrants
-	const LONG xSymmetric = size.cx - 1 - x;
-	const LONG ySymmetric = size.cy - 1 - y;
-	SetPixel(x, y, value);
-	SetPixel(xSymmetric, y, value);
-	SetPixel(x, ySymmetric, value);
-	SetPixel(xSymmetric, ySymmetric, value);
-}
-
-ColourRGBA GradientValue(const std::vector<ColourStop> &stops, XYPOSITION proportion) noexcept {
-	for (size_t stop = 0; stop < stops.size() - 1; stop++) {
-		// Loop through each pair of stops
-		const XYPOSITION positionStart = stops[stop].position;
-		const XYPOSITION positionEnd = stops[stop + 1].position;
-		if ((proportion >= positionStart) && (proportion <= positionEnd)) {
-			const XYPOSITION proportionInPair = (proportion - positionStart) /
-				(positionEnd - positionStart);
-			return stops[stop].colour.MixedWith(stops[stop + 1].colour, proportionInPair);
-		}
-	}
-	// Loop should always find a value
-	return ColourRGBA();
-}
-
-constexpr BLENDFUNCTION mergeAlpha = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
-
-}
-
-void SurfaceGDI::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) {
-	// TODO: Implement strokeWidth
-	const RECT rcw = RectFromPRectangle(rc);
-	const SIZE size = SizeOfRect(rcw);
-
-	if (size.cx > 0) {
-
-		DIBSection section(hdc, size);
-
-		if (section) {
-
-			// Ensure not distorted too much by corners when small
-			const LONG corner = std::min(static_cast<LONG>(cornerSize), (std::min(size.cx, size.cy) / 2) - 2);
-
-			constexpr DWORD valEmpty = dwordFromBGRA(0,0,0,0);
-			const DWORD valFill = dwordMultiplied(fillStroke.fill.colour);
-			const DWORD valOutline = dwordMultiplied(fillStroke.stroke.colour);
-
-			// Draw a framed rectangle
-			for (int y=0; y<size.cy; y++) {
-				for (int x=0; x<size.cx; x++) {
-					if ((x==0) || (x==size.cx-1) || (y == 0) || (y == size.cy -1)) {
-						section.SetPixel(x, y, valOutline);
-					} else {
-						section.SetPixel(x, y, valFill);
-					}
-				}
-			}
-
-			// Make the corners transparent
-			for (LONG c=0; c<corner; c++) {
-				for (LONG x=0; x<c+1; x++) {
-					section.SetSymmetric(x, c - x, valEmpty);
-				}
-			}
-
-			// Draw the corner frame pieces
-			for (LONG x=1; x<corner; x++) {
-				section.SetSymmetric(x, corner - x, valOutline);
-			}
-
-			GdiAlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
-		}
-	} else {
-		BrushColour(fillStroke.stroke.colour);
-		FrameRect(hdc, &rcw, brush);
-	}
-}
-
-void SurfaceGDI::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
-
-	const RECT rcw = RectFromPRectangle(rc);
-	const SIZE size = SizeOfRect(rcw);
-
-	DIBSection section(hdc, size);
-
-	if (section) {
-
-		if (options == GradientOptions::topToBottom) {
-			for (LONG y = 0; y < size.cy; y++) {
-				// Find y/height proportional colour
-				const XYPOSITION proportion = y / (rc.Height() - 1.0f);
-				const ColourRGBA mixed = GradientValue(stops, proportion);
-				const DWORD valFill = dwordMultiplied(mixed);
-				for (LONG x = 0; x < size.cx; x++) {
-					section.SetPixel(x, y, valFill);
-				}
-			}
-		} else {
-			for (LONG x = 0; x < size.cx; x++) {
-				// Find x/width proportional colour
-				const XYPOSITION proportion = x / (rc.Width() - 1.0f);
-				const ColourRGBA mixed = GradientValue(stops, proportion);
-				const DWORD valFill = dwordMultiplied(mixed);
-				for (LONG y = 0; y < size.cy; y++) {
-					section.SetPixel(x, y, valFill);
-				}
-			}
-		}
-
-		GdiAlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
-	}
-}
-
-void SurfaceGDI::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
-	if (rc.Width() > 0) {
-		if (rc.Width() > width)
-			rc.left += std::floor((rc.Width() - width) / 2);
-		rc.right = rc.left + width;
-		if (rc.Height() > height)
-			rc.top += std::floor((rc.Height() - height) / 2);
-		rc.bottom = rc.top + height;
-
-		const SIZE size { width, height };
-		DIBSection section(hdc, size);
-		if (section) {
-			RGBAImage::BGRAFromRGBA(section.Bytes(), pixelsImage, static_cast<size_t>(width) * height);
-			GdiAlphaBlend(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
-				static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), section.DC(),
-				0, 0, width, height, mergeAlpha);
-		}
-	}
-}
-
-void SurfaceGDI::Ellipse(PRectangle rc, FillStroke fillStroke) {
-	PenColour(fillStroke.stroke.colour, fillStroke.stroke.width);
-	BrushColour(fillStroke.fill.colour);
-	const RECT rcw = RectFromPRectangle(rc);
-	::Ellipse(hdc, rcw.left, rcw.top, rcw.right, rcw.bottom);
-}
-
-void SurfaceGDI::Stadium(PRectangle rc, FillStroke fillStroke, [[maybe_unused]] Ends ends) {
-	// TODO: Implement properly - the rectangle is just a placeholder
-	RectangleDraw(rc, fillStroke);
-}
-
-void SurfaceGDI::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
-	::BitBlt(hdc,
-		static_cast<int>(rc.left), static_cast<int>(rc.top),
-		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()),
-		dynamic_cast<SurfaceGDI &>(surfaceSource).hdc,
-		static_cast<int>(from.x), static_cast<int>(from.y), SRCCOPY);
-}
-
-std::unique_ptr<IScreenLineLayout> SurfaceGDI::Layout(const IScreenLine *) {
-	return {};
-}
-
-using TextPositionsI = VarBuffer<int, stackBufferLength>;
-
-void SurfaceGDI::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
-	SetFont(font_);
-	const RECT rcw = RectFromPRectangle(rc);
-	const int x = static_cast<int>(rc.left);
-	const int yBaseInt = static_cast<int>(ybase);
-
-	if (mode.codePage == CpUtf8) {
-		const TextWide tbuf(text, mode.codePage);
-		::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
-	} else {
-		::ExtTextOutA(hdc, x, yBaseInt, fuOptions, &rcw, text.data(), static_cast<UINT>(text.length()), nullptr);
-	}
-}
-
-void SurfaceGDI::DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	::SetTextColor(hdc, fore.OpaqueRGB());
-	::SetBkColor(hdc, back.OpaqueRGB());
-	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE);
-}
-
-void SurfaceGDI::DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	::SetTextColor(hdc, fore.OpaqueRGB());
-	::SetBkColor(hdc, back.OpaqueRGB());
-	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
-}
-
-void SurfaceGDI::DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore) {
-	// Avoid drawing spaces in transparent mode
-	for (const char ch : text) {
-		if (ch != ' ') {
-			::SetTextColor(hdc, fore.OpaqueRGB());
-			::SetBkMode(hdc, TRANSPARENT);
-			DrawTextCommon(rc, font_, ybase, text, 0);
-			::SetBkMode(hdc, OPAQUE);
-			return;
-		}
-	}
-}
-
-void SurfaceGDI::MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) {
-	// Zero positions to avoid random behaviour on failure.
-	std::fill(positions, positions + text.length(), 0.0f);
-	SetFont(font_);
-	SIZE sz = { 0,0 };
-	int fit = 0;
-	int i = 0;
-	const int len = static_cast<int>(text.length());
-	if (mode.codePage == CpUtf8) {
-		const TextWide tbuf(text, mode.codePage);
-		TextPositionsI poses(tbuf.tlen);
-		if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
-			// Failure
-			return;
-		}
-		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
-		for (int ui = 0; ui < fit; ui++) {
-			const unsigned char uch = text[i];
-			const unsigned int byteCount = UTF8BytesOfLead[uch];
-			if (byteCount == 4) {	// Non-BMP
-				ui++;
-			}
-			for (unsigned int bytePos = 0; (bytePos < byteCount) && (i < len); bytePos++) {
-				positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
-			}
-		}
-	} else {
-		TextPositionsI poses(len);
-		if (!::GetTextExtentExPointA(hdc, text.data(), len, maxWidthMeasure, &fit, poses.buffer, &sz)) {
-			// Eeek - a NULL DC or other foolishness could cause this.
-			return;
-		}
-		while (i < fit) {
-			positions[i] = static_cast<XYPOSITION>(poses.buffer[i]);
-			i++;
-		}
-	}
-	// If any positions not filled in then use the last position for them
-	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
-	std::fill(positions + i, positions + text.length(), lastPos);
+void Window::Show(bool show) {
+	if (show)
+		::ShowWindow(HwndFromWindowID(wid), SW_SHOWNOACTIVATE);
+	else
+		::ShowWindow(HwndFromWindowID(wid), SW_HIDE);
 }
 
-XYPOSITION SurfaceGDI::WidthText(const Font *font_, std::string_view text) {
-	SetFont(font_);
-	SIZE sz = { 0,0 };
-	if (!(mode.codePage == CpUtf8)) {
-		::GetTextExtentPoint32A(hdc, text.data(), std::min(static_cast<int>(text.length()), maxLenText), &sz);
-	} else {
-		const TextWide tbuf(text, mode.codePage);
-		::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
-	}
-	return static_cast<XYPOSITION>(sz.cx);
+void Window::InvalidateAll() {
+	::InvalidateRect(HwndFromWindowID(wid), nullptr, FALSE);
 }
 
-void SurfaceGDI::DrawTextCommonUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
-	SetFont(font_);
+void Window::InvalidateRectangle(PRectangle rc) {
 	const RECT rcw = RectFromPRectangle(rc);
-	const int x = static_cast<int>(rc.left);
-	const int yBaseInt = static_cast<int>(ybase);
-
-	const TextWide tbuf(text, CpUtf8);
-	::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
-}
-
-void SurfaceGDI::DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	::SetTextColor(hdc, fore.OpaqueRGB());
-	::SetBkColor(hdc, back.OpaqueRGB());
-	DrawTextCommonUTF8(rc, font_, ybase, text, ETO_OPAQUE);
-}
-
-void SurfaceGDI::DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	::SetTextColor(hdc, fore.OpaqueRGB());
-	::SetBkColor(hdc, back.OpaqueRGB());
-	DrawTextCommonUTF8(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
-}
-
-void SurfaceGDI::DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore) {
-	// Avoid drawing spaces in transparent mode
-	for (const char ch : text) {
-		if (ch != ' ') {
-			::SetTextColor(hdc, fore.OpaqueRGB());
-			::SetBkMode(hdc, TRANSPARENT);
-			DrawTextCommonUTF8(rc, font_, ybase, text, 0);
-			::SetBkMode(hdc, OPAQUE);
-			return;
-		}
-	}
-}
-
-void SurfaceGDI::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) {
-	// Zero positions to avoid random behaviour on failure.
-	std::fill(positions, positions + text.length(), 0.0f);
-	SetFont(font_);
-	SIZE sz = { 0,0 };
-	int fit = 0;
-	int i = 0;
-	const int len = static_cast<int>(text.length());
-	const TextWide tbuf(text, CpUtf8);
-	TextPositionsI poses(tbuf.tlen);
-	if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
-		// Failure
-		return;
-	}
-	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
-	for (int ui = 0; ui < fit; ui++) {
-		const unsigned char uch = text[i];
-		const unsigned int byteCount = UTF8BytesOfLead[uch];
-		if (byteCount == 4) {	// Non-BMP
-			ui++;
-		}
-		for (unsigned int bytePos = 0; (bytePos < byteCount) && (i < len); bytePos++) {
-			positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
-		}
-	}
-	// If any positions not filled in then use the last position for them
-	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
-	std::fill(positions + i, positions + text.length(), lastPos);
-}
-
-XYPOSITION SurfaceGDI::WidthTextUTF8(const Font *font_, std::string_view text) {
-	SetFont(font_);
-	SIZE sz = { 0,0 };
-	const TextWide tbuf(text, CpUtf8);
-	::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
-	return static_cast<XYPOSITION>(sz.cx);
-}
-
-XYPOSITION SurfaceGDI::Ascent(const Font *font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return static_cast<XYPOSITION>(tm.tmAscent);
-}
-
-XYPOSITION SurfaceGDI::Descent(const Font *font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return static_cast<XYPOSITION>(tm.tmDescent);
-}
-
-XYPOSITION SurfaceGDI::InternalLeading(const Font *font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return static_cast<XYPOSITION>(tm.tmInternalLeading);
-}
-
-XYPOSITION SurfaceGDI::Height(const Font *font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return static_cast<XYPOSITION>(tm.tmHeight);
-}
-
-XYPOSITION SurfaceGDI::AverageCharWidth(const Font *font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return static_cast<XYPOSITION>(tm.tmAveCharWidth);
-}
-
-void SurfaceGDI::SetClip(PRectangle rc) {
-	::SaveDC(hdc);
-	::IntersectClipRect(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
-		static_cast<int>(rc.right), static_cast<int>(rc.bottom));
-}
-
-void SurfaceGDI::PopClip() {
-	::RestoreDC(hdc, -1);
-}
-
-void SurfaceGDI::FlushCachedState() {
-	pen = {};
-	brush = {};
-}
-
-void SurfaceGDI::FlushDrawing() {
+	::InvalidateRect(HwndFromWindowID(wid), &rcw, FALSE);
 }
 
-#if defined(USE_D2D)
-
 namespace {
 
-constexpr D2D1_RECT_F RectangleFromPRectangle(PRectangle rc) noexcept {
-	return {
-		static_cast<FLOAT>(rc.left),
-		static_cast<FLOAT>(rc.top),
-		static_cast<FLOAT>(rc.right),
-		static_cast<FLOAT>(rc.bottom)
-	};
-}
-
-constexpr D2D1_POINT_2F DPointFromPoint(Point point) noexcept {
-	return { static_cast<FLOAT>(point.x), static_cast<FLOAT>(point.y) };
-}
-
-constexpr Supports SupportsD2D[] = {
-	Supports::LineDrawsFinal,
-	Supports::FractionalStrokeWidth,
-	Supports::TranslucentStroke,
-	Supports::PixelModification,
-	Supports::ThreadSafeMeasureWidths,
-};
-
-constexpr D2D1_RECT_F RectangleInset(D2D1_RECT_F rect, FLOAT inset) noexcept {
-	return D2D1_RECT_F{
-		rect.left + inset,
-		rect.top + inset,
-		rect.right - inset,
-		rect.bottom - inset };
-}
-
-}
-
-class BlobInline;
-
-class SurfaceD2D : public Surface, public ISetRenderingParams {
-	SurfaceMode mode;
-
-	// Text measuring surface: both pRenderTarget and pBitmapRenderTarget are null.
-	// Window surface: pRenderTarget is valid but not pBitmapRenderTarget.
-	// Bitmap drawing surface: both pRenderTarget and pBitmapRenderTarget are valid and the same.
-	ComPtr<ID2D1RenderTarget> pRenderTarget;
-	ComPtr<ID2D1BitmapRenderTarget> pBitmapRenderTarget;
-	int clipsActive = 0;
-
-	BrushSolid pBrush = nullptr;
-
-	static constexpr FontQuality invalidFontQuality = FontQuality::QualityMask;
-	FontQuality fontQuality = invalidFontQuality;
-	int logPixelsY = USER_DEFAULT_SCREEN_DPI;
-	int deviceScaleFactor = 1;
-	std::shared_ptr<RenderingParams> renderingParams;
-
-	void Clear() noexcept;
-	void SetFontQuality(FontQuality extraFontFlag);
-	HRESULT GetBitmap(ID2D1Bitmap **ppBitmap);
-	void SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept;
-
-public:
-	SurfaceD2D() noexcept = default;
-	SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
-	// Deleted so SurfaceD2D objects can not be copied.
-	SurfaceD2D(const SurfaceD2D &) = delete;
-	SurfaceD2D(SurfaceD2D &&) = delete;
-	SurfaceD2D &operator=(const SurfaceD2D &) = delete;
-	SurfaceD2D &operator=(SurfaceD2D &&) = delete;
-	~SurfaceD2D() noexcept override;
-
-	void SetScale(WindowID wid) noexcept;
-	void Init(WindowID wid) override;
-	void Init(SurfaceID sid, WindowID wid) override;
-	std::unique_ptr<Surface> AllocatePixMap(int width, int height) override;
-
-	void SetMode(SurfaceMode mode_) override;
-
-	void Release() noexcept override;
-	int SupportsFeature(Supports feature) noexcept override;
-	bool Initialised() override;
-
-	void D2DPenColourAlpha(ColourRGBA fore) noexcept;
-	int LogPixelsY() override;
-	int PixelDivisions() override;
-	int DeviceHeightFont(int points) override;
-	void LineDraw(Point start, Point end, Stroke stroke) override;
-	static Geometry GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept;
-	void PolyLine(const Point *pts, size_t npts, Stroke stroke) override;
-	void Polygon(const Point *pts, size_t npts, FillStroke fillStroke) override;
-	void RectangleDraw(PRectangle rc, FillStroke fillStroke) override;
-	void RectangleFrame(PRectangle rc, Stroke stroke) override;
-	void FillRectangle(PRectangle rc, Fill fill) override;
-	void FillRectangleAligned(PRectangle rc, Fill fill) override;
-	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
-	void RoundedRectangle(PRectangle rc, FillStroke fillStroke) override;
-	void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) override;
-	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
-	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
-	void Ellipse(PRectangle rc, FillStroke fillStroke) override;
-	void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) override;
-	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;
-
-	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;
-
-	void DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, int codePageOverride, UINT fuOptions);
-
-	void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
-	void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) override;
-	XYPOSITION WidthText(const Font *font_, std::string_view text) override;
-
-	void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
-	void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
-	void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) override;
-	XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) override;
-
-	XYPOSITION Ascent(const Font *font_) override;
-	XYPOSITION Descent(const Font *font_) override;
-	XYPOSITION InternalLeading(const Font *font_) override;
-	XYPOSITION Height(const Font *font_) override;
-	XYPOSITION AverageCharWidth(const Font *font_) override;
-
-	void SetClip(PRectangle rc) override;
-	void PopClip() override;
-	void FlushCachedState() override;
-	void FlushDrawing() override;
-
-	void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) override;
-};
-
-SurfaceD2D::SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
-	const D2D1_SIZE_F desiredSize = D2D1::SizeF(static_cast<float>(width), static_cast<float>(height));
-	D2D1_PIXEL_FORMAT desiredFormat;
-#ifdef __MINGW32__
-	desiredFormat.format = DXGI_FORMAT_UNKNOWN;
-#else
-	desiredFormat = pRenderTargetCompatible->GetPixelFormat();
-#endif
-	desiredFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
-	const HRESULT hr = pRenderTargetCompatible->CreateCompatibleRenderTarget(
-		&desiredSize, nullptr, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, pBitmapRenderTarget.GetAddressOf());
-	if (SUCCEEDED(hr)) {
-		pRenderTarget = pBitmapRenderTarget;
-		SetDeviceScaleFactor(pRenderTarget.Get());
-		pRenderTarget->BeginDraw();
-	}
-	mode = mode_;
-	logPixelsY = logPixelsY_;
-}
-
-SurfaceD2D::~SurfaceD2D() noexcept {
-	Clear();
-}
-
-void SurfaceD2D::Clear() noexcept {
-	pBrush = nullptr;
-	if (pRenderTarget) {
-		while (clipsActive) {
-			pRenderTarget->PopAxisAlignedClip();
-			clipsActive--;
-		}
-		if (pBitmapRenderTarget) {
-			pRenderTarget->EndDraw();
-		}
-	}
-	pRenderTarget = nullptr;
-	pBitmapRenderTarget = nullptr;
-}
-
-void SurfaceD2D::Release() noexcept {
-	Clear();
-}
-
-void SurfaceD2D::SetScale(WindowID wid) noexcept {
-	fontQuality = invalidFontQuality;
-	logPixelsY = DpiForWindow(wid);
-}
-
-int SurfaceD2D::SupportsFeature(Supports feature) noexcept {
-	for (const Supports f : SupportsD2D) {
-		if (f == feature)
-			return 1;
-	}
-	return 0;
-}
-
-bool SurfaceD2D::Initialised() {
-	return pRenderTarget;
-}
-
-void SurfaceD2D::Init(WindowID wid) {
-	Release();
-	SetScale(wid);
-}
-
-void SurfaceD2D::Init(SurfaceID sid, WindowID wid) {
-	Release();
-	SetScale(wid);
-	pRenderTarget = static_cast<ID2D1RenderTarget *>(sid);
-	SetDeviceScaleFactor(pRenderTarget.Get());
-}
-
-std::unique_ptr<Surface> SurfaceD2D::AllocatePixMap(int width, int height) {
-	std::unique_ptr<SurfaceD2D> surf = std::make_unique<SurfaceD2D>(pRenderTarget.Get(), width, height, mode, logPixelsY);
-	surf->SetRenderingParams(renderingParams);
-	return surf;
-}
-
-void SurfaceD2D::SetMode(SurfaceMode mode_) {
-	mode = mode_;
-}
-
-HRESULT SurfaceD2D::GetBitmap(ID2D1Bitmap **ppBitmap) {
-	PLATFORM_ASSERT(pBitmapRenderTarget);
-	return pBitmapRenderTarget->GetBitmap(ppBitmap);
-}
-
-void SurfaceD2D::D2DPenColourAlpha(ColourRGBA fore) noexcept {
-	if (pRenderTarget) {
-		const D2D_COLOR_F col = ColorFromColourAlpha(fore);
-		if (pBrush) {
-			pBrush->SetColor(col);
-		} else {
-			const HRESULT hr = pRenderTarget->CreateSolidColorBrush(col, &pBrush);
-			if (!SUCCEEDED(hr)) {
-				pBrush = nullptr;
-			}
-		}
-	}
-}
-
-void SurfaceD2D::SetFontQuality(FontQuality extraFontFlag) {
-	if ((fontQuality != extraFontFlag) && renderingParams) {
-		fontQuality = extraFontFlag;
-		const D2D1_TEXT_ANTIALIAS_MODE aaMode = DWriteMapFontQuality(extraFontFlag);
-		if (aaMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE && renderingParams->customRenderingParams) {
-			pRenderTarget->SetTextRenderingParams(renderingParams->customRenderingParams.Get());
-		} else if (renderingParams->defaultRenderingParams) {
-			pRenderTarget->SetTextRenderingParams(renderingParams->defaultRenderingParams.Get());
-		}
-		pRenderTarget->SetTextAntialiasMode(aaMode);
+std::optional<DWORD> RegGetDWORD(HKEY hKey, LPCWSTR valueName) noexcept {
+	DWORD value = 0;
+	DWORD type = REG_NONE;
+	DWORD size = sizeof(DWORD);
+	const LSTATUS status = ::RegQueryValueExW(hKey, valueName, nullptr, &type, reinterpret_cast<LPBYTE>(&value), &size);
+	if (status == ERROR_SUCCESS && type == REG_DWORD) {
+		return value;
 	}
+	return {};
 }
 
-int SurfaceD2D::LogPixelsY() {
-	return logPixelsY;
-}
-
-void SurfaceD2D::SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept {
-	FLOAT dpiX = 0.f;
-	FLOAT dpiY = 0.f;
-	pD2D1RenderTarget->GetDpi(&dpiX, &dpiY);
-	deviceScaleFactor = static_cast<int>(dpiX / 96.f);
-}
-
-int SurfaceD2D::PixelDivisions() {
-	return deviceScaleFactor;
-}
-
-int SurfaceD2D::DeviceHeightFont(int points) {
-	return ::MulDiv(points, LogPixelsY(), 72);
-}
-
-void SurfaceD2D::LineDraw(Point start, Point end, Stroke stroke) {
-	D2DPenColourAlpha(stroke.colour);
-
-	D2D1_STROKE_STYLE_PROPERTIES strokeProps {};
-	strokeProps.startCap = D2D1_CAP_STYLE_SQUARE;
-	strokeProps.endCap = D2D1_CAP_STYLE_SQUARE;
-	strokeProps.dashCap = D2D1_CAP_STYLE_FLAT;
-	strokeProps.lineJoin = D2D1_LINE_JOIN_MITER;
-	strokeProps.miterLimit = 4.0f;
-	strokeProps.dashStyle = D2D1_DASH_STYLE_SOLID;
-	strokeProps.dashOffset = 0;
-
-	// get the stroke style to apply
-	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
-		pRenderTarget->DrawLine(
-			DPointFromPoint(start),
-			DPointFromPoint(end), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
-	}
-}
-
-Geometry SurfaceD2D::GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept {
-	Geometry geometry = GeometryCreate();
-	if (geometry) {
-		if (const GeometrySink sink = GeometrySinkCreate(geometry.Get())) {
-			sink->BeginFigure(DPointFromPoint(pts[0]), figureBegin);
-			for (size_t i = 1; i < npts; i++) {
-				sink->AddLine(DPointFromPoint(pts[i]));
-			}
-			sink->EndFigure((figureBegin == D2D1_FIGURE_BEGIN_FILLED) ?
-				D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN);
-			sink->Close();
-		}
-	}
-	return geometry;
-}
-
-void SurfaceD2D::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
-	PLATFORM_ASSERT(pRenderTarget && (npts > 1));
-	if (!pRenderTarget || (npts <= 1)) {
-		return;
-	}
-
-	const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_HOLLOW);
-	PLATFORM_ASSERT(geometry);
-	if (!geometry) {
-		return;
-	}
-
-	D2DPenColourAlpha(stroke.colour);
-	D2D1_STROKE_STYLE_PROPERTIES strokeProps {};
-	strokeProps.startCap = D2D1_CAP_STYLE_ROUND;
-	strokeProps.endCap = D2D1_CAP_STYLE_ROUND;
-	strokeProps.dashCap = D2D1_CAP_STYLE_FLAT;
-	strokeProps.lineJoin = D2D1_LINE_JOIN_MITER;
-	strokeProps.miterLimit = 4.0f;
-	strokeProps.dashStyle = D2D1_DASH_STYLE_SOLID;
-	strokeProps.dashOffset = 0;
-
-	// get the stroke style to apply
-	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
-		pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
-	}
-}
-
-void SurfaceD2D::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
-	PLATFORM_ASSERT(pRenderTarget && (npts > 2));
-	if (pRenderTarget) {
-		const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_FILLED);
-		PLATFORM_ASSERT(geometry);
-		if (geometry) {
-			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillGeometry(geometry.Get(), pBrush.Get());
-			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
-		}
-	}
-}
-
-void SurfaceD2D::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
-	if (!pRenderTarget)
-		return;
-	const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
-	const D2D1_RECT_F rectFill = RectangleInset(rect, fillStroke.stroke.WidthF());
-	const float halfStroke = fillStroke.stroke.WidthF() / 2.0f;
-	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);
-
-	D2DPenColourAlpha(fillStroke.fill.colour);
-	pRenderTarget->FillRectangle(&rectFill, pBrush.Get());
-	D2DPenColourAlpha(fillStroke.stroke.colour);
-	pRenderTarget->DrawRectangle(&rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
-}
-
-void SurfaceD2D::RectangleFrame(PRectangle rc, Stroke stroke) {
-	if (pRenderTarget) {
-		const XYPOSITION halfStroke = stroke.width / 2.0f;
-		const D2D1_RECT_F rectangle1 = RectangleFromPRectangle(rc.Inset(halfStroke));
-		D2DPenColourAlpha(stroke.colour);
-		pRenderTarget->DrawRectangle(&rectangle1, pBrush.Get(), stroke.WidthF());
-	}
-}
-
-void SurfaceD2D::FillRectangle(PRectangle rc, Fill fill) {
-	if (pRenderTarget) {
-		D2DPenColourAlpha(fill.colour);
-		const D2D1_RECT_F rectangle = RectangleFromPRectangle(rc);
-		pRenderTarget->FillRectangle(&rectangle, pBrush.Get());
-	}
-}
-
-void SurfaceD2D::FillRectangleAligned(PRectangle rc, Fill fill) {
-	FillRectangle(PixelAlign(rc, PixelDivisions()), fill);
-}
-
-void SurfaceD2D::FillRectangle(PRectangle rc, Surface &surfacePattern) {
-	SurfaceD2D *psurfOther = dynamic_cast<SurfaceD2D *>(&surfacePattern);
-	PLATFORM_ASSERT(psurfOther);
-	if (!psurfOther) {
-		throw std::runtime_error("SurfaceD2D::FillRectangle: wrong Surface type.");
-	}
-	ComPtr<ID2D1Bitmap> pBitmap;
-	HRESULT hr = psurfOther->GetBitmap(pBitmap.GetAddressOf());
-	if (SUCCEEDED(hr) && pBitmap) {
-		ComPtr<ID2D1BitmapBrush> pBitmapBrush;
-		const D2D1_BITMAP_BRUSH_PROPERTIES brushProperties =
-	        D2D1::BitmapBrushProperties(D2D1_EXTEND_MODE_WRAP, D2D1_EXTEND_MODE_WRAP,
-			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
-		// Create the bitmap brush.
-		hr = pRenderTarget->CreateBitmapBrush(pBitmap.Get(), brushProperties, pBitmapBrush.GetAddressOf());
-		if (SUCCEEDED(hr) && pBitmapBrush) {
-			pRenderTarget->FillRectangle(
-				RectangleFromPRectangle(rc),
-				pBitmapBrush.Get());
-		}
-	}
-}
-
-void SurfaceD2D::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
-	if (pRenderTarget) {
-		const FLOAT minDimension = static_cast<FLOAT>(std::min(rc.Width(), rc.Height())) / 2.0f;
-		const FLOAT radius = std::min(4.0f, minDimension);
-		if (fillStroke.fill.colour == fillStroke.stroke.colour) {
-			const D2D1_ROUNDED_RECT roundedRectFill = {
-				RectangleFromPRectangle(rc),
-				radius, radius };
-			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
-		} else {
-			const D2D1_ROUNDED_RECT roundedRectFill = {
-				RectangleFromPRectangle(rc.Inset(1.0)),
-				radius-1, radius-1 };
-			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
-
-			const D2D1_ROUNDED_RECT roundedRect = {
-				RectangleFromPRectangle(rc.Inset(0.5)),
-				radius, radius };
-			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
-		}
-	}
-}
-
-void SurfaceD2D::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) {
-	const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
-	const D2D1_RECT_F rectFill = RectangleInset(rect, fillStroke.stroke.WidthF());
-	const float halfStroke = fillStroke.stroke.WidthF() / 2.0f;
-	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);
-	if (pRenderTarget) {
-		if (cornerSize == 0) {
-			// When corner size is zero, draw square rectangle to prevent blurry pixels at corners
-			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRectangle(rectFill, pBrush.Get());
-
-			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawRectangle(rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
-		} else {
-			const float cornerSizeF = static_cast<float>(cornerSize);
-			const D2D1_ROUNDED_RECT roundedRectFill = {
-				rectFill, cornerSizeF - 1.0f, cornerSizeF - 1.0f };
-			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
-
-			const D2D1_ROUNDED_RECT roundedRect = {
-				rectOutline, cornerSizeF, cornerSizeF};
-			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
-		}
-	}
-}
-
-void SurfaceD2D::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
-	if (pRenderTarget) {
-		D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lgbp {
-			DPointFromPoint(Point(rc.left, rc.top)), {}
-		};
-		switch (options) {
-		case GradientOptions::leftToRight:
-			lgbp.endPoint = DPointFromPoint(Point(rc.right, rc.top));
-			break;
-		case GradientOptions::topToBottom:
-		default:
-			lgbp.endPoint = DPointFromPoint(Point(rc.left, rc.bottom));
-			break;
-		}
-
-		std::vector<D2D1_GRADIENT_STOP> gradientStops;
-		for (const ColourStop &stop : stops) {
-			gradientStops.push_back({ static_cast<FLOAT>(stop.position), ColorFromColourAlpha(stop.colour) });
-		}
-		ComPtr<ID2D1GradientStopCollection> pGradientStops;
-		HRESULT hr = pRenderTarget->CreateGradientStopCollection(
-			gradientStops.data(), static_cast<UINT32>(gradientStops.size()), pGradientStops.GetAddressOf());
-		if (FAILED(hr) || !pGradientStops) {
-			return;
-		}
-		ComPtr<ID2D1LinearGradientBrush> pBrushLinear;
-		hr = pRenderTarget->CreateLinearGradientBrush(
-			lgbp, pGradientStops.Get(), pBrushLinear.GetAddressOf());
-		if (SUCCEEDED(hr) && pBrushLinear) {
-			const D2D1_RECT_F rectangle = RectangleFromPRectangle(PRectangle(
-				std::round(rc.left), rc.top, std::round(rc.right), rc.bottom));
-			pRenderTarget->FillRectangle(&rectangle, pBrushLinear.Get());
-		}
-	}
-}
-
-void SurfaceD2D::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
-	if (pRenderTarget) {
-		if (rc.Width() > width)
-			rc.left += std::floor((rc.Width() - width) / 2);
-		rc.right = rc.left + width;
-		if (rc.Height() > height)
-			rc.top += std::floor((rc.Height() - height) / 2);
-		rc.bottom = rc.top + height;
-
-		std::vector<unsigned char> image(RGBAImage::bytesPerPixel * height * width);
-		RGBAImage::BGRAFromRGBA(image.data(), pixelsImage, static_cast<ptrdiff_t>(height) * width);
-
-		ComPtr<ID2D1Bitmap> bitmap;
-		const D2D1_SIZE_U size = D2D1::SizeU(width, height);
-		const D2D1_BITMAP_PROPERTIES props = {{DXGI_FORMAT_B8G8R8A8_UNORM,
-		    D2D1_ALPHA_MODE_PREMULTIPLIED}, 72.0, 72.0};
-		const HRESULT hr = pRenderTarget->CreateBitmap(size, image.data(),
-                  width * 4, &props, bitmap.GetAddressOf());
-		if (SUCCEEDED(hr)) {
-			const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
-			pRenderTarget->DrawBitmap(bitmap.Get(), rcDestination);
-		}
-	}
-}
-
-void SurfaceD2D::Ellipse(PRectangle rc, FillStroke fillStroke) {
-	if (!pRenderTarget)
-		return;
-	const D2D1_POINT_2F centre = DPointFromPoint(rc.Centre());
-
-	const FLOAT radiusFill = static_cast<FLOAT>(rc.Width() / 2.0f - fillStroke.stroke.width);
-	const D2D1_ELLIPSE ellipseFill = { centre, radiusFill, radiusFill };
-
-	D2DPenColourAlpha(fillStroke.fill.colour);
-	pRenderTarget->FillEllipse(ellipseFill, pBrush.Get());
-
-	const FLOAT radiusOutline = static_cast<FLOAT>(rc.Width() / 2.0f - fillStroke.stroke.width / 2.0f);
-	const D2D1_ELLIPSE ellipseOutline = { centre, radiusOutline, radiusOutline };
-
-	D2DPenColourAlpha(fillStroke.stroke.colour);
-	pRenderTarget->DrawEllipse(ellipseOutline, pBrush.Get(), fillStroke.stroke.WidthF());
-}
-
-void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
-	if (!pRenderTarget)
-		return;
-	if (rc.Width() < rc.Height()) {
-		// Can't draw nice ends so just draw a rectangle
-		RectangleDraw(rc, fillStroke);
-		return;
-	}
-	const FLOAT radius = static_cast<FLOAT>(rc.Height() / 2.0);
-	const FLOAT radiusFill = radius - fillStroke.stroke.WidthF();
-	const FLOAT halfStroke = fillStroke.stroke.WidthF() / 2.0f;
-	if (ends == Surface::Ends::semiCircles) {
-		const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
-		const D2D1_ROUNDED_RECT roundedRectFill = { RectangleInset(rect, fillStroke.stroke.WidthF()),
-			radiusFill, radiusFill };
-		D2DPenColourAlpha(fillStroke.fill.colour);
-		pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
-
-		const D2D1_ROUNDED_RECT roundedRect = { RectangleInset(rect, halfStroke),
-			radius, radius };
-		D2DPenColourAlpha(fillStroke.stroke.colour);
-		pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
-	} else {
-		const Ends leftSide = static_cast<Ends>(static_cast<int>(ends) & 0xf);
-		const Ends rightSide = static_cast<Ends>(static_cast<int>(ends) & 0xf0);
-		PRectangle rcInner = rc;
-		rcInner.left += radius;
-		rcInner.right -= radius;
-		const Geometry pathGeometry = GeometryCreate();
-		if (!pathGeometry)
-			return;
-		if (const GeometrySink pSink = GeometrySinkCreate(pathGeometry.Get())) {
-			switch (leftSide) {
-				case Ends::leftFlat:
-					pSink->BeginFigure(DPointFromPoint(Point(rc.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
-					pSink->AddLine(DPointFromPoint(Point(rc.left + halfStroke, rc.bottom - halfStroke)));
-					break;
-				case Ends::leftAngle:
-					pSink->BeginFigure(DPointFromPoint(Point(rcInner.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
-					pSink->AddLine(DPointFromPoint(Point(rc.left + halfStroke, rc.Centre().y)));
-					pSink->AddLine(DPointFromPoint(Point(rcInner.left + halfStroke, rc.bottom - halfStroke)));
-					break;
-				case Ends::semiCircles:
-				default: {
-						pSink->BeginFigure(DPointFromPoint(Point(rcInner.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
-						D2D1_ARC_SEGMENT segment{};
-						segment.point = DPointFromPoint(Point(rcInner.left + halfStroke, rc.bottom - halfStroke));
-						segment.size = D2D1::SizeF(radiusFill, radiusFill);
-						segment.rotationAngle = 0.0f;
-						segment.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
-						segment.arcSize = D2D1_ARC_SIZE_SMALL;
-						pSink->AddArc(segment);
-					}
-					break;
-			}
-
-			switch (rightSide) {
-			case Ends::rightFlat:
-				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.bottom - halfStroke)));
-				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.top + halfStroke)));
-				break;
-			case Ends::rightAngle:
-				pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.bottom - halfStroke)));
-				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.Centre().y)));
-				pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.top + halfStroke)));
-				break;
-			case Ends::semiCircles:
-			default: {
-					pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.bottom - halfStroke)));
-					D2D1_ARC_SEGMENT segment{};
-					segment.point = DPointFromPoint(Point(rcInner.right - halfStroke, rc.top + halfStroke));
-					segment.size = D2D1::SizeF(radiusFill, radiusFill);
-					segment.rotationAngle = 0.0f;
-					segment.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
-					segment.arcSize = D2D1_ARC_SIZE_SMALL;
-					pSink->AddArc(segment);
-				}
-				break;
-			}
-
-			pSink->EndFigure(D2D1_FIGURE_END_CLOSED);
-
-			pSink->Close();
-		}
-		D2DPenColourAlpha(fillStroke.fill.colour);
-		pRenderTarget->FillGeometry(pathGeometry.Get(), pBrush.Get());
-		D2DPenColourAlpha(fillStroke.stroke.colour);
-		pRenderTarget->DrawGeometry(pathGeometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
-	}
-}
-
-void SurfaceD2D::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
-	SurfaceD2D &surfOther = dynamic_cast<SurfaceD2D &>(surfaceSource);
-	ComPtr<ID2D1Bitmap> pBitmap;
-	const HRESULT hr = surfOther.GetBitmap(pBitmap.GetAddressOf());
-	if (SUCCEEDED(hr) && pBitmap) {
-		const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
-		const D2D1_RECT_F rcSource = RectangleFromPRectangle(PRectangle(
-			from.x, from.y, from.x + rc.Width(), from.y + rc.Height()));
-		pRenderTarget->DrawBitmap(pBitmap.Get(), rcDestination, 1.0f,
-			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, rcSource);
-	}
-}
-
-class BlobInline final : public IDWriteInlineObject {
-	XYPOSITION width;
-
-	// IUnknown
-	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
-	STDMETHODIMP_(ULONG)AddRef() override;
-	STDMETHODIMP_(ULONG)Release() override;
-
-	// IDWriteInlineObject
-	COM_DECLSPEC_NOTHROW STDMETHODIMP Draw(
-		void *clientDrawingContext,
-		IDWriteTextRenderer *renderer,
-		FLOAT originX,
-		FLOAT originY,
-		BOOL isSideways,
-		BOOL isRightToLeft,
-		IUnknown *clientDrawingEffect
-		) override;
-	COM_DECLSPEC_NOTHROW STDMETHODIMP GetMetrics(DWRITE_INLINE_OBJECT_METRICS *metrics) override;
-	COM_DECLSPEC_NOTHROW STDMETHODIMP GetOverhangMetrics(DWRITE_OVERHANG_METRICS *overhangs) override;
-	COM_DECLSPEC_NOTHROW STDMETHODIMP GetBreakConditions(
-		DWRITE_BREAK_CONDITION *breakConditionBefore,
-		DWRITE_BREAK_CONDITION *breakConditionAfter) override;
-public:
-	explicit BlobInline(XYPOSITION width_=0.0f) noexcept : width(width_) {
-	}
-};
-
-/// Implement IUnknown
-STDMETHODIMP BlobInline::QueryInterface(REFIID riid, PVOID *ppv) {
-	if (!ppv)
-		return E_POINTER;
-	// Never called so not checked.
-	*ppv = nullptr;
-	if (riid == IID_IUnknown)
-		*ppv = this;
-	if (riid == __uuidof(IDWriteInlineObject))
-		*ppv = this;
-	if (!*ppv)
-		return E_NOINTERFACE;
-	return S_OK;
-}
-
-STDMETHODIMP_(ULONG) BlobInline::AddRef() {
-	// Lifetime tied to Platform methods so ignore any reference operations.
-	return 1;
-}
-
-STDMETHODIMP_(ULONG) BlobInline::Release() {
-	// Lifetime tied to Platform methods so ignore any reference operations.
-	return 1;
-}
-
-/// Implement IDWriteInlineObject
-COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::Draw(
-	void*,
-	IDWriteTextRenderer*,
-	FLOAT,
-	FLOAT,
-	BOOL,
-	BOOL,
-	IUnknown*) {
-	// Since not performing drawing, not necessary to implement
-	// Could be implemented by calling back into platform-independent code.
-	// This would allow more of the drawing to be mediated through DirectWrite.
-	return S_OK;
-}
-
-COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetMetrics(
-	DWRITE_INLINE_OBJECT_METRICS *metrics
-) {
-	if (!metrics)
-		return E_POINTER;
-	metrics->width = static_cast<FLOAT>(width);
-	metrics->height = 2;
-	metrics->baseline = 1;
-	metrics->supportsSideways = FALSE;
-	return S_OK;
-}
-
-COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetOverhangMetrics(
-	DWRITE_OVERHANG_METRICS *overhangs
-) {
-	if (!overhangs)
-		return E_POINTER;
-	overhangs->left = 0;
-	overhangs->top = 0;
-	overhangs->right = 0;
-	overhangs->bottom = 0;
-	return S_OK;
-}
-
-COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetBreakConditions(
-	DWRITE_BREAK_CONDITION *breakConditionBefore,
-	DWRITE_BREAK_CONDITION *breakConditionAfter
-) {
-	if (!breakConditionBefore || !breakConditionAfter)
-		return E_POINTER;
-	// Since not performing 2D layout, not necessary to implement
-	*breakConditionBefore = DWRITE_BREAK_CONDITION_NEUTRAL;
-	*breakConditionAfter = DWRITE_BREAK_CONDITION_NEUTRAL;
-	return S_OK;
-}
-
-class ScreenLineLayout : public IScreenLineLayout {
-	TextLayout textLayout;
-	std::string text;
-	std::wstring buffer;
-	std::vector<BlobInline> blobs;
-	static void FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs);
-	static std::wstring ReplaceRepresentation(std::string_view text);
-	static size_t GetPositionInLayout(std::string_view text, size_t position);
-public:
-	explicit ScreenLineLayout(const IScreenLine *screenLine);
-	// Deleted so ScreenLineLayout objects can not be copied
-	ScreenLineLayout(const ScreenLineLayout &) = delete;
-	ScreenLineLayout(ScreenLineLayout &&) = delete;
-	ScreenLineLayout &operator=(const ScreenLineLayout &) = delete;
-	ScreenLineLayout &operator=(ScreenLineLayout &&) = delete;
-	~ScreenLineLayout() noexcept override = default;
-	size_t PositionFromX(XYPOSITION xDistance, bool charPosition) override;
-	XYPOSITION XFromPosition(size_t caretPosition) override;
-	std::vector<Interval> FindRangeIntervals(size_t start, size_t end) override;
-};
-
-// Each char can have its own style, so we fill the textLayout with the textFormat of each char
-
-void ScreenLineLayout::FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs) {
-	// Reserve enough entries up front so they are not moved and the pointers handed
-	// to textLayout remain valid.
-	const ptrdiff_t numRepresentations = screenLine->RepresentationCount();
-	std::string_view text = screenLine->Text();
-	const ptrdiff_t numTabs = std::count(std::begin(text), std::end(text), '\t');
-	blobs.reserve(numRepresentations + numTabs);
-
-	UINT32 layoutPosition = 0;
-
-	for (size_t bytePosition = 0; bytePosition < screenLine->Length();) {
-		const unsigned char uch = screenLine->Text()[bytePosition];
-		const unsigned int byteCount = UTF8BytesOfLead[uch];
-		const UINT32 codeUnits = UTF16LengthFromUTF8ByteCount(byteCount);
-		const DWRITE_TEXT_RANGE textRange = { layoutPosition, codeUnits };
-
-		XYPOSITION representationWidth = screenLine->RepresentationWidth(bytePosition);
-		if ((representationWidth == 0.0f) && (screenLine->Text()[bytePosition] == '\t')) {
-			D2D1_POINT_2F realPt {};
-			DWRITE_HIT_TEST_METRICS realCaretMetrics {};
-			textLayout->HitTestTextPosition(
-				layoutPosition,
-				false, // trailing if false, else leading edge
-				&realPt.x,
-				&realPt.y,
-				&realCaretMetrics
-			);
-
-			const XYPOSITION nextTab = screenLine->TabPositionAfter(realPt.x);
-			representationWidth = nextTab - realPt.x;
-		}
-		if (representationWidth > 0.0f) {
-			blobs.push_back(BlobInline(representationWidth));
-			textLayout->SetInlineObject(&blobs.back(), textRange);
-		};
-
-		const FontDirectWrite *pfm =
-			dynamic_cast<const FontDirectWrite *>(screenLine->FontOfPosition(bytePosition));
-		if (!pfm) {
-			throw std::runtime_error("FillTextLayoutFormats: wrong Font type.");
-		}
-
-		const unsigned int fontFamilyNameSize = pfm->pTextFormat->GetFontFamilyNameLength();
-		std::wstring fontFamilyName(fontFamilyNameSize, 0);
-		const HRESULT hrFamily = pfm->pTextFormat->GetFontFamilyName(fontFamilyName.data(), fontFamilyNameSize + 1);
-		if (SUCCEEDED(hrFamily)) {
-			textLayout->SetFontFamilyName(fontFamilyName.c_str(), textRange);
-		}
-
-		textLayout->SetFontSize(pfm->pTextFormat->GetFontSize(), textRange);
-		textLayout->SetFontWeight(pfm->pTextFormat->GetFontWeight(), textRange);
-		textLayout->SetFontStyle(pfm->pTextFormat->GetFontStyle(), textRange);
-
-		const unsigned int localeNameSize = pfm->pTextFormat->GetLocaleNameLength();
-		std::wstring localeName(localeNameSize, 0);
-		const HRESULT hrLocale = pfm->pTextFormat->GetLocaleName(localeName.data(), localeNameSize + 1);
-		if (SUCCEEDED(hrLocale)) {
-			textLayout->SetLocaleName(localeName.c_str(), textRange);
-		}
-
-		textLayout->SetFontStretch(pfm->pTextFormat->GetFontStretch(), textRange);
-
-		IDWriteFontCollection *fontCollection = nullptr;
-		if (SUCCEEDED(pfm->pTextFormat->GetFontCollection(&fontCollection))) {
-			textLayout->SetFontCollection(fontCollection, textRange);
-		}
-
-		bytePosition += byteCount;
-		layoutPosition += codeUnits;
-	}
-
-}
-
-/* Convert to a wide character string and replace tabs with X to stop DirectWrite tab expansion */
-
-std::wstring ScreenLineLayout::ReplaceRepresentation(std::string_view text) {
-	const TextWide wideText(text, CpUtf8);
-	std::wstring ws(wideText.buffer, wideText.tlen);
-	std::replace(ws.begin(), ws.end(), L'\t', L'X');
-	return ws;
-}
-
-// Finds the position in the wide character version of the text.
-
-size_t ScreenLineLayout::GetPositionInLayout(std::string_view text, size_t position) {
-	const std::string_view textUptoPosition = text.substr(0, position);
-	return UTF16Length(textUptoPosition);
-}
-
-ScreenLineLayout::ScreenLineLayout(const IScreenLine *screenLine) {
-	// If the text is empty, then no need to go through this function
-	if (!screenLine || !screenLine->Length())
-		return;
-
-	text = screenLine->Text();
-
-	// Get textFormat
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(screenLine->FontOfPosition(0));
-	if (!pfm->pTextFormat) {
-		return;
-	}
-
-	// Convert the string to wstring and replace the original control characters with their representative chars.
-	buffer = ReplaceRepresentation(screenLine->Text());
-
-	// Create a text layout
-	textLayout = LayoutCreate(
-		buffer,
-		pfm->pTextFormat.Get(),
-		static_cast<FLOAT>(screenLine->Width()),
-		static_cast<FLOAT>(screenLine->Height()));
-	if (!textLayout) {
-		return;
-	}
-
-	// Fill the textLayout chars with their own formats
-	FillTextLayoutFormats(screenLine, textLayout.Get(), blobs);
-}
-
-// Get the position from the provided x
-
-size_t ScreenLineLayout::PositionFromX(XYPOSITION xDistance, bool charPosition) {
-	if (!textLayout) {
-		return 0;
-	}
-
-	// Returns the text position corresponding to the mouse x,y.
-	// If hitting the trailing side of a cluster, return the
-	// leading edge of the following text position.
-
-	BOOL isTrailingHit = FALSE;
-	BOOL isInside = FALSE;
-	DWRITE_HIT_TEST_METRICS caretMetrics {};
-
-	textLayout->HitTestPoint(
-		static_cast<FLOAT>(xDistance),
-		0.0f,
-		&isTrailingHit,
-		&isInside,
-		&caretMetrics
-	);
-
-	DWRITE_HIT_TEST_METRICS hitTestMetrics {};
-	if (isTrailingHit) {
-		FLOAT caretX = 0.0f;
-		FLOAT caretY = 0.0f;
-
-		// Uses hit-testing to align the current caret position to a whole cluster,
-		// rather than residing in the middle of a base character + diacritic,
-		// surrogate pair, or character + UVS.
-
-		// Align the caret to the nearest whole cluster.
-		textLayout->HitTestTextPosition(
-			caretMetrics.textPosition,
-			false,
-			&caretX,
-			&caretY,
-			&hitTestMetrics
-		);
-	}
-
-	size_t pos;
-	if (charPosition) {
-		pos = isTrailingHit ? hitTestMetrics.textPosition : caretMetrics.textPosition;
-	} else {
-		pos = isTrailingHit ? static_cast<size_t>(hitTestMetrics.textPosition) + hitTestMetrics.length : caretMetrics.textPosition;
-	}
-
-	// Get the character position in original string
-	return UTF8PositionFromUTF16Position(text, pos);
-}
-
-// Finds the point of the caret position
-
-XYPOSITION ScreenLineLayout::XFromPosition(size_t caretPosition) {
-	if (!textLayout) {
-		return 0.0;
-	}
-	// Convert byte positions to wchar_t positions
-	const size_t position = GetPositionInLayout(text, caretPosition);
-
-	// Translate text character offset to point x,y.
-	DWRITE_HIT_TEST_METRICS caretMetrics {};
-	D2D1_POINT_2F pt {};
-
-	textLayout->HitTestTextPosition(
-		static_cast<UINT32>(position),
-		false, // trailing if false, else leading edge
-		&pt.x,
-		&pt.y,
-		&caretMetrics
-	);
-
-	return pt.x;
-}
-
-// Find the selection range rectangles
-
-std::vector<Interval> ScreenLineLayout::FindRangeIntervals(size_t start, size_t end) {
-	std::vector<Interval> ret;
-
-	if (!textLayout || (start == end)) {
-		return ret;
-	}
-
-	// Convert byte positions to wchar_t positions
-	const size_t startPos = GetPositionInLayout(text, start);
-	const size_t endPos = GetPositionInLayout(text, end);
-
-	// Find selection range length
-	const size_t rangeLength = (endPos > startPos) ? (endPos - startPos) : (startPos - endPos);
-
-	// Determine actual number of hit-test ranges
-	UINT32 actualHitTestCount = 0;
-
-	// First try with 2 elements and if more needed, allocate.
-	std::vector<DWRITE_HIT_TEST_METRICS> hitTestMetrics(2);
-	textLayout->HitTestTextRange(
-		static_cast<UINT32>(startPos),
-		static_cast<UINT32>(rangeLength),
-		0, // x
-		0, // y
-		hitTestMetrics.data(),
-		static_cast<UINT32>(hitTestMetrics.size()),
-		&actualHitTestCount
-	);
-
-	if (actualHitTestCount == 0) {
-		return ret;
-	}
-
-	if (hitTestMetrics.size() < actualHitTestCount) {
-		// Allocate enough room to return all hit-test metrics.
-		hitTestMetrics.resize(actualHitTestCount);
-		textLayout->HitTestTextRange(
-			static_cast<UINT32>(startPos),
-			static_cast<UINT32>(rangeLength),
-			0, // x
-			0, // y
-			hitTestMetrics.data(),
-			static_cast<UINT32>(hitTestMetrics.size()),
-			&actualHitTestCount
-		);
-	}
-
-	// Get the selection ranges behind the text.
-
-	for (size_t i = 0; i < actualHitTestCount; ++i) {
-		// Store selection rectangle
-		const DWRITE_HIT_TEST_METRICS &htm = hitTestMetrics[i];
-		const Interval selectionInterval { htm.left, htm.left + htm.width };
-		ret.push_back(selectionInterval);
-	}
-
-	return ret;
-}
-
-std::unique_ptr<IScreenLineLayout> SurfaceD2D::Layout(const IScreenLine *screenLine) {
-	return std::make_unique<ScreenLineLayout>(screenLine);
-}
-
-void SurfaceD2D::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, int codePageOverride, UINT fuOptions) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	if (pfm->pTextFormat && pRenderTarget && pBrush) {
-		// Use Unicode calls
-		const int codePageDraw = codePageOverride ? codePageOverride : pfm->CodePageText(mode.codePage);
-		const TextWide tbuf(text, codePageDraw);
-
-		SetFontQuality(pfm->extraFontFlag);
-		if (fuOptions & ETO_CLIPPED) {
-			const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
-			pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
-		}
-
-		// Explicitly creating a text layout appears a little faster
-		TextLayout pTextLayout = LayoutCreate(
-				tbuf.AsView(),
-				pfm->pTextFormat.Get(),
-				static_cast<FLOAT>(rc.Width()),
-				static_cast<FLOAT>(rc.Height()));
-		if (pTextLayout) {
-			const D2D1_POINT_2F origin = DPointFromPoint(Point(rc.left, ybase - pfm->yAscent));
-			pRenderTarget->DrawTextLayout(origin, pTextLayout.Get(), pBrush.Get(), d2dDrawTextOptions);
-		}
-
-		if (fuOptions & ETO_CLIPPED) {
-			pRenderTarget->PopAxisAlignedClip();
-		}
-	}
-}
-
-void SurfaceD2D::DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	if (pRenderTarget) {
-		FillRectangleAligned(rc, back);
-		D2DPenColourAlpha(fore);
-		DrawTextCommon(rc, font_, ybase, text, 0, ETO_OPAQUE);
-	}
-}
-
-void SurfaceD2D::DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	if (pRenderTarget) {
-		FillRectangleAligned(rc, back);
-		D2DPenColourAlpha(fore);
-		DrawTextCommon(rc, font_, ybase, text, 0, ETO_OPAQUE | ETO_CLIPPED);
-	}
-}
-
-void SurfaceD2D::DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore) {
-	// Avoid drawing spaces in transparent mode
-	for (const char ch : text) {
-		if (ch != ' ') {
-			if (pRenderTarget) {
-				D2DPenColourAlpha(fore);
-				DrawTextCommon(rc, font_, ybase, text, 0, 0);
-			}
-			return;
-		}
-	}
-}
-
-namespace {
-
-HRESULT MeasurePositions(TextPositions &poses, const TextWide &tbuf, IDWriteTextFormat *pTextFormat) {
-	if (!pTextFormat) {
-		// Unexpected failure like no access to DirectWrite so give up.
-		return E_FAIL;
-	}
-
-	// Initialize poses for safety.
-	std::fill(poses.buffer, poses.buffer + tbuf.tlen, 0.0f);
-	// Create a layout
-	TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pTextFormat);
-	if (!pTextLayout) {
-		return E_FAIL;
-	}
-	VarBuffer<DWRITE_CLUSTER_METRICS, stackBufferLength> cm(tbuf.tlen);
-	UINT32 count = 0;
-	const HRESULT hrGetCluster = pTextLayout->GetClusterMetrics(cm.buffer, tbuf.tlen, &count);
-	if (!SUCCEEDED(hrGetCluster)) {
-		return hrGetCluster;
-	}
-	const DWRITE_CLUSTER_METRICS * const clusterMetrics = cm.buffer;
-	// A cluster may be more than one WCHAR, such as for "ffi" which is a ligature in the Candara font
-	XYPOSITION position = 0.0;
-	int ti=0;
-	for (unsigned int ci=0; ci<count; ci++) {
-		for (unsigned int inCluster=0; inCluster<clusterMetrics[ci].length; inCluster++) {
-			poses.buffer[ti++] = position + clusterMetrics[ci].width * (inCluster + 1) / clusterMetrics[ci].length;
-		}
-		position += clusterMetrics[ci].width;
-	}
-	PLATFORM_ASSERT(ti == tbuf.tlen);
-	return S_OK;
-}
-
-}
-
-void SurfaceD2D::MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	const int codePageText = pfm->CodePageText(mode.codePage);
-	const TextWide tbuf(text, codePageText);
-	TextPositions poses(tbuf.tlen);
-	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
-		return;
-	}
-	if (codePageText == CpUtf8) {
-		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
-		size_t i = 0;
-		for (int ui = 0; ui < tbuf.tlen; ui++) {
-			const unsigned char uch = text[i];
-			const unsigned int byteCount = UTF8BytesOfLead[uch];
-			if (byteCount == 4) {	// Non-BMP
-				ui++;
-			}
-			for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui<tbuf.tlen); bytePos++) {
-				positions[i++] = poses.buffer[ui];
-			}
-		}
-		const XYPOSITION lastPos = (i > 0) ? positions[i - 1] : 0.0;
-		while (i<text.length()) {
-			positions[i++] = lastPos;
-		}
-	} else if (!IsDBCSCodePage(codePageText)) {
-
-		// One char per position
-		PLATFORM_ASSERT(text.length() == static_cast<size_t>(tbuf.tlen));
-		for (int kk=0; kk<tbuf.tlen; kk++) {
-			positions[kk] = poses.buffer[kk];
-		}
-
-	} else {
-
-		// May be one or two bytes per position
-		int ui = 0;
-		for (size_t i=0; i<text.length() && ui<tbuf.tlen;) {
-			positions[i] = poses.buffer[ui];
-			if (DBCSIsLeadByte(codePageText, text[i])) {
-				positions[i+1] = poses.buffer[ui];
-				i += 2;
-			} else {
-				i++;
-			}
-
-			ui++;
-		}
-	}
-}
-
-XYPOSITION SurfaceD2D::WidthText(const Font *font_, std::string_view text) {
-	FLOAT width = 1.0;
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	if (pfm->pTextFormat) {
-		const TextWide tbuf(text, pfm->CodePageText(mode.codePage));
-		// Create a layout
-		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
-			DWRITE_TEXT_METRICS textMetrics;
-			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
-				width = textMetrics.widthIncludingTrailingWhitespace;
-		}
-	}
-	return width;
-}
-
-void SurfaceD2D::DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	if (pRenderTarget) {
-		FillRectangleAligned(rc, back);
-		D2DPenColourAlpha(fore);
-		DrawTextCommon(rc, font_, ybase, text, CpUtf8, ETO_OPAQUE);
-	}
-}
-
-void SurfaceD2D::DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore, ColourRGBA back) {
-	if (pRenderTarget) {
-		FillRectangleAligned(rc, back);
-		D2DPenColourAlpha(fore);
-		DrawTextCommon(rc, font_, ybase, text, CpUtf8, ETO_OPAQUE | ETO_CLIPPED);
-	}
-}
-
-void SurfaceD2D::DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
-	ColourRGBA fore) {
-	// Avoid drawing spaces in transparent mode
-	for (const char ch : text) {
-		if (ch != ' ') {
-			if (pRenderTarget) {
-				D2DPenColourAlpha(fore);
-				DrawTextCommon(rc, font_, ybase, text, CpUtf8, 0);
-			}
-			return;
-		}
-	}
-}
-
-void SurfaceD2D::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	const TextWide tbuf(text, CpUtf8);
-	TextPositions poses(tbuf.tlen);
-	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
-		return;
-	}
-	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
-	size_t i = 0;
-	for (int ui = 0; ui < tbuf.tlen; ui++) {
-		const unsigned char uch = text[i];
-		const unsigned int byteCount = UTF8BytesOfLead[uch];
-		if (byteCount == 4) {	// Non-BMP
-			ui++;
-			PLATFORM_ASSERT(ui < tbuf.tlen);
-		}
-		for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui < tbuf.tlen); bytePos++) {
-			positions[i++] = poses.buffer[ui];
-		}
-	}
-	const XYPOSITION lastPos = (i > 0) ? positions[i - 1] : 0.0;
-	while (i < text.length()) {
-		positions[i++] = lastPos;
-	}
-}
-
-XYPOSITION SurfaceD2D::WidthTextUTF8(const Font * font_, std::string_view text) {
-	FLOAT width = 1.0;
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	if (pfm->pTextFormat) {
-		const TextWide tbuf(text, CpUtf8);
-		// Create a layout
-		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
-			DWRITE_TEXT_METRICS textMetrics;
-			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
-				width = textMetrics.widthIncludingTrailingWhitespace;
-		}
-	}
-	return width;
-}
-
-XYPOSITION SurfaceD2D::Ascent(const Font *font_) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	return std::ceil(pfm->yAscent);
-}
-
-XYPOSITION SurfaceD2D::Descent(const Font *font_) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	return std::ceil(pfm->yDescent);
-}
-
-XYPOSITION SurfaceD2D::InternalLeading(const Font *font_) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	return std::floor(pfm->yInternalLeading);
-}
-
-XYPOSITION SurfaceD2D::Height(const Font *font_) {
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	return std::ceil(pfm->yAscent) + std::ceil(pfm->yDescent);
-}
-
-XYPOSITION SurfaceD2D::AverageCharWidth(const Font *font_) {
-	FLOAT width = 1.0;
-	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
-	if (pfm->pTextFormat) {
-		// Create a layout
-		static constexpr std::wstring_view wsvAllAlpha = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-		if (TextLayout pTextLayout = LayoutCreate(wsvAllAlpha, pfm->pTextFormat.Get())) {
-			DWRITE_TEXT_METRICS textMetrics;
-			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
-				width = textMetrics.width / wsvAllAlpha.length();
-		}
-	}
-	return width;
-}
-
-void SurfaceD2D::SetClip(PRectangle rc) {
-	if (pRenderTarget) {
-		const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
-		pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
-		clipsActive++;
-	}
-}
-
-void SurfaceD2D::PopClip() {
-	if (pRenderTarget) {
-		PLATFORM_ASSERT(clipsActive > 0);
-		pRenderTarget->PopAxisAlignedClip();
-		clipsActive--;
-	}
-}
-
-void SurfaceD2D::FlushCachedState() {
-}
-
-void SurfaceD2D::FlushDrawing() {
-	if (pRenderTarget) {
-		pRenderTarget->Flush();
-	}
-}
-
-void SurfaceD2D::SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) {
-	renderingParams = std::move(renderingParams_);
-}
-
-#endif
-
-std::unique_ptr<Surface> Surface::Allocate([[maybe_unused]] Technology technology) {
-#if defined(USE_D2D)
-	if (technology != Technology::Default) {
-		return std::make_unique<SurfaceD2D>();
-	}
-#endif
-	return std::make_unique<SurfaceGDI>();
-}
-
-Window::~Window() noexcept = default;
-
-void Window::Destroy() noexcept {
-	if (wid)
-		::DestroyWindow(HwndFromWindowID(wid));
-	wid = nullptr;
-}
-
-PRectangle Window::GetPosition() const {
-	RECT rc;
-	::GetWindowRect(HwndFromWindowID(wid), &rc);
-	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
-}
-
-void Window::SetPosition(PRectangle rc) {
-	::SetWindowPos(HwndFromWindowID(wid),
-		{}, static_cast<int>(rc.left), static_cast<int>(rc.top),
-		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), SWP_NOZORDER | SWP_NOACTIVATE);
-}
-
-namespace {
-
-RECT RectFromMonitor(HMONITOR hMonitor) noexcept {
-	MONITORINFO mi = {};
-	mi.cbSize = sizeof(mi);
-	if (GetMonitorInfo(hMonitor, &mi)) {
-		return mi.rcWork;
-	}
-	RECT rc = {0, 0, 0, 0};
-	if (::SystemParametersInfoA(SPI_GETWORKAREA, 0, &rc, 0) == 0) {
-		rc.left = 0;
-		rc.top = 0;
-		rc.right = 0;
-		rc.bottom = 0;
-	}
-	return rc;
-}
-
-}
-
-void Window::SetPositionRelative(PRectangle rc, const Window *relativeTo) {
-	const DWORD style = GetWindowStyle(HwndFromWindowID(wid));
-	if (style & WS_POPUP) {
-		POINT ptOther = {0, 0};
-		::ClientToScreen(HwndFromWindow(*relativeTo), &ptOther);
-		rc.Move(static_cast<XYPOSITION>(ptOther.x), static_cast<XYPOSITION>(ptOther.y));
-
-		const RECT rcMonitor = RectFromPRectangle(rc);
-
-		HMONITOR hMonitor = MonitorFromRect(&rcMonitor, MONITOR_DEFAULTTONEAREST);
-		// If hMonitor is NULL, that's just the main screen anyways.
-		const RECT rcWork = RectFromMonitor(hMonitor);
-
-		if (rcWork.left < rcWork.right) {
-			// Now clamp our desired rectangle to fit inside the work area
-			// This way, the menu will fit wholly on one screen. An improvement even
-			// if you don't have a second monitor on the left... Menu's appears half on
-			// one screen and half on the other are just U.G.L.Y.!
-			if (rc.right > rcWork.right)
-				rc.Move(rcWork.right - rc.right, 0);
-			if (rc.bottom > rcWork.bottom)
-				rc.Move(0, rcWork.bottom - rc.bottom);
-			if (rc.left < rcWork.left)
-				rc.Move(rcWork.left - rc.left, 0);
-			if (rc.top < rcWork.top)
-				rc.Move(0, rcWork.top - rc.top);
-		}
-	}
-	SetPosition(rc);
-}
-
-PRectangle Window::GetClientPosition() const {
-	RECT rc={0,0,0,0};
-	if (wid)
-		::GetClientRect(HwndFromWindowID(wid), &rc);
-	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
-}
-
-void Window::Show(bool show) {
-	if (show)
-		::ShowWindow(HwndFromWindowID(wid), SW_SHOWNOACTIVATE);
-	else
-		::ShowWindow(HwndFromWindowID(wid), SW_HIDE);
-}
-
-void Window::InvalidateAll() {
-	::InvalidateRect(HwndFromWindowID(wid), nullptr, FALSE);
-}
-
-void Window::InvalidateRectangle(PRectangle rc) {
-	const RECT rcw = RectFromPRectangle(rc);
-	::InvalidateRect(HwndFromWindowID(wid), &rcw, FALSE);
-}
-
-namespace {
-
-std::optional<DWORD> RegGetDWORD(HKEY hKey, LPCWSTR valueName) noexcept {
-	DWORD value = 0;
-	DWORD type = REG_NONE;
-	DWORD size = sizeof(DWORD);
-	const LSTATUS status = ::RegQueryValueExW(hKey, valueName, nullptr, &type, reinterpret_cast<LPBYTE>(&value), &size);
-	if (status == ERROR_SUCCESS && type == REG_DWORD) {
-		return value;
-	}
-	return {};
-}
-
-class CursorHelper {
-	HDC hMemDC {};
-	HBITMAP hBitmap {};
-	HBITMAP hOldBitmap {};
-	DWORD *pixels = nullptr;
-	const int width;
-	const int height;
-
-	static constexpr float arrow[][2] = {
-		{ 32.0f - 12.73606f,32.0f - 19.04075f },
-		{ 32.0f - 7.80159f, 32.0f - 19.04075f },
-		{ 32.0f - 9.82813f, 32.0f - 14.91828f },
-		{ 32.0f - 6.88341f, 32.0f - 13.42515f },
-		{ 32.0f - 4.62301f, 32.0f - 18.05872f },
-		{ 32.0f - 1.26394f, 32.0f - 14.78295f },
-		{ 32.0f - 1.26394f, 32.0f - 30.57485f },
-	};
-
-public:
-	~CursorHelper() {
-		if (hOldBitmap) {
-			SelectBitmap(hMemDC, hOldBitmap);
-		}
-		if (hBitmap) {
-			::DeleteObject(hBitmap);
-		}
-		if (hMemDC) {
-			::DeleteDC(hMemDC);
-		}
-	}
-
-	CursorHelper(int width_, int height_) noexcept : width{width_}, height{height_} {
-		hMemDC = ::CreateCompatibleDC({});
-		if (!hMemDC) {
-			return;
-		}
-
-		// https://learn.microsoft.com/en-us/windows/win32/menurc/using-cursors#creating-a-cursor
-		BITMAPV5HEADER bi {};
-		bi.bV5Size = sizeof(BITMAPV5HEADER);
-		bi.bV5Width = width;
-		bi.bV5Height = height;
-		bi.bV5Planes = 1;
-		bi.bV5BitCount = 32;
-		bi.bV5Compression = BI_BITFIELDS;
-		// The following mask specification specifies a supported 32 BPP alpha format for Windows XP.
-		bi.bV5RedMask   = 0x00FF0000U;
-		bi.bV5GreenMask = 0x0000FF00U;
-		bi.bV5BlueMask  = 0x000000FFU;
-		bi.bV5AlphaMask = 0xFF000000U;
-
-		// Create the DIB section with an alpha channel.
-		hBitmap = CreateDIBSection(hMemDC, reinterpret_cast<BITMAPINFO *>(&bi), DIB_RGB_COLORS, reinterpret_cast<void **>(&pixels), nullptr, 0);
-		if (hBitmap) {
-			hOldBitmap = SelectBitmap(hMemDC, hBitmap);
-		}
-	}
-
-	[[nodiscard]] bool HasBitmap() const noexcept {
-		return hOldBitmap != nullptr;
-	}
-
-	HCURSOR Create() noexcept {
-		HCURSOR cursor {};
-		// Create an empty mask bitmap.
-		HBITMAP hMonoBitmap = ::CreateBitmap(width, height, 1, 1, nullptr);
-		if (hMonoBitmap) {
-			// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-createiconindirect
-			// hBitmap should not already be selected into a device context
-			SelectBitmap(hMemDC, hOldBitmap);
-			hOldBitmap = {};
-			ICONINFO info = {false, static_cast<DWORD>(width - 1), 0, hMonoBitmap, hBitmap};
-			cursor = ::CreateIconIndirect(&info);
-			::DeleteObject(hMonoBitmap);
-		}
-		return cursor;
-	}
-
-#if defined(USE_D2D)
-
-	bool DrawD2D(COLORREF fillColour, COLORREF strokeColour) noexcept {
-		if (!LoadD2D()) {
-			return false;
-		}
-
-		D2D1_RENDER_TARGET_PROPERTIES drtp {};
-		drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
-		drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
-		drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
-		drtp.dpiX = 96.f;
-		drtp.dpiY = 96.f;
-		drtp.pixelFormat = D2D1::PixelFormat(
-			DXGI_FORMAT_B8G8R8A8_UNORM,
-			D2D1_ALPHA_MODE_PREMULTIPLIED
-		);
-
-		DCRenderTarget pTarget;
-		HRESULT hr = CreateDCRenderTarget(&drtp, pTarget);
-		if (FAILED(hr) || !pTarget) {
-			return false;
-		}
-
-		const RECT rc = {0, 0, width, height};
-		hr = pTarget->BindDC(hMemDC, &rc);
-		if (FAILED(hr)) {
-			return false;
-		}
-
-		pTarget->BeginDraw();
-
-		// Draw something on the bitmap section.
-		constexpr size_t nPoints = std::size(arrow);
-		D2D1_POINT_2F points[nPoints]{};
-		const FLOAT scale = width/32.0f;
-		for (size_t i = 0; i < nPoints; i++) {
-			points[i].x = arrow[i][0] * scale;
-			points[i].y = arrow[i][1] * scale;
-		}
-
-		const Geometry geometry = GeometryCreate();
-		if (!geometry) {
-			return false;
-		}
-
-		const GeometrySink sink = GeometrySinkCreate(geometry.Get());
-		if (!sink) {
-			return false;
-		}
-
-		sink->BeginFigure(points[0], D2D1_FIGURE_BEGIN_FILLED);
-		for (size_t i = 1; i < nPoints; i++) {
-			sink->AddLine(points[i]);
-		}
-		sink->EndFigure(D2D1_FIGURE_END_CLOSED);
-		hr = sink->Close();
-		if (FAILED(hr)) {
-			return false;
-		}
-
-		if (const BrushSolid pBrushFill = BrushSolidCreate(pTarget.Get(), fillColour)) {
-			pTarget->FillGeometry(geometry.Get(), pBrushFill.Get());
-		}
-
-		if (const BrushSolid pBrushStroke = BrushSolidCreate(pTarget.Get(), strokeColour)) {
-			pTarget->DrawGeometry(geometry.Get(), pBrushStroke.Get(), scale);
-		}
-
-		hr = pTarget->EndDraw();
-		return SUCCEEDED(hr);
-	}
-#endif
-
-	void Draw(COLORREF fillColour, COLORREF strokeColour) noexcept {
-#if defined(USE_D2D)
-		if (DrawD2D(fillColour, strokeColour)) {
-			return;
-		}
-#endif
-
-		// Draw something on the DIB section.
-		constexpr size_t nPoints = std::size(arrow);
-		POINT points[nPoints]{};
-		const float scale = width/32.0f;
-		for (size_t i = 0; i < nPoints; i++) {
-			points[i].x = std::lround(arrow[i][0] * scale);
-			points[i].y = std::lround(arrow[i][1] * scale);
-		}
-
-		const DWORD penWidth = std::lround(scale);
-		HPEN pen{};
-		if (penWidth > 1) {
-			const LOGBRUSH brushParameters { BS_SOLID, strokeColour, 0 };
-			pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
-				penWidth,
-				&brushParameters,
-				0,
-				nullptr);
-		} else {
-			pen = ::CreatePen(PS_INSIDEFRAME, 1, strokeColour);
-		}
-
-		HPEN penOld = SelectPen(hMemDC, pen);
-		HBRUSH brush = ::CreateSolidBrush(fillColour);
-		HBRUSH brushOld = SelectBrush(hMemDC, brush);
-		::Polygon(hMemDC, points, static_cast<int>(nPoints));
-		SelectPen(hMemDC, penOld);
-		SelectBrush(hMemDC, brushOld);
-		::DeleteObject(pen);
-		::DeleteObject(brush);
-
-		// Set the alpha values for each pixel in the cursor.
-		for (int i = 0; i < width*height; i++) {
-			if (*pixels != 0) {
-				*pixels |= 0xFF000000U;
-			}
-			pixels++;
-		}
-	}
-};
-
-void ChooseCursor(LPCTSTR cursor) noexcept {
-	::SetCursor(::LoadCursor({}, cursor));
-}
-
-void ChooseCursor(Window::Cursor curs) noexcept {
-	switch (curs) {
-	case Window::Cursor::text:
-		ChooseCursor(IDC_IBEAM);
-		break;
-	case Window::Cursor::up:
-		ChooseCursor(IDC_UPARROW);
-		break;
-	case Window::Cursor::wait:
-		ChooseCursor(IDC_WAIT);
-		break;
-	case Window::Cursor::horizontal:
-		ChooseCursor(IDC_SIZEWE);
-		break;
-	case Window::Cursor::vertical:
-		ChooseCursor(IDC_SIZENS);
-		break;
-	case Window::Cursor::hand:
-		ChooseCursor(IDC_HAND);
-		break;
-	case Window::Cursor::reverseArrow:
-	case Window::Cursor::arrow:
-	case Window::Cursor::invalid:	// Should not occur, but just in case.
-	default:
-		ChooseCursor(IDC_ARROW);
-		break;
-	}
-}
-
-}
-
-HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept {
-	// https://learn.microsoft.com/en-us/answers/questions/815036/windows-cursor-size
-	constexpr DWORD defaultCursorBaseSize = 32;
-	constexpr DWORD maxCursorBaseSize = 16*(1 + 15); // 16*(1 + CursorSize)
-	DWORD cursorBaseSize = 0;
-	HKEY hKey {};
-	LSTATUS status = ::RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\Cursors", 0, KEY_QUERY_VALUE, &hKey);
-	if (status == ERROR_SUCCESS) {
-		if (std::optional<DWORD> baseSize = RegGetDWORD(hKey, L"CursorBaseSize")) {
-			// CursorBaseSize is multiple of 16
-			cursorBaseSize = std::min(*baseSize & ~15, maxCursorBaseSize);
-		}
-		::RegCloseKey(hKey);
-	}
-
-	int width = 0;
-	int height = 0;
-	if (cursorBaseSize > defaultCursorBaseSize) {
-		width = ::MulDiv(cursorBaseSize, dpi, USER_DEFAULT_SCREEN_DPI);
-		height = width;
-	} else {
-		width = SystemMetricsForDpi(SM_CXCURSOR, dpi);
-		height = SystemMetricsForDpi(SM_CYCURSOR, dpi);
-		PLATFORM_ASSERT(width == height);
-	}
-
-	CursorHelper cursorHelper(width, height);
-	if (!cursorHelper.HasBitmap()) {
-		return {};
-	}
-
-	COLORREF fillColour = RGB(0xff, 0xff, 0xfe);
-	COLORREF strokeColour = RGB(0, 0, 1);
-	status = ::RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Accessibility", 0, KEY_QUERY_VALUE, &hKey);
-	if (status == ERROR_SUCCESS) {
-		if (std::optional<DWORD> cursorType = RegGetDWORD(hKey, L"CursorType")) {
-			switch (*cursorType) {
-			case 1: // black
-			case 4: // black
-				std::swap(fillColour, strokeColour);
-				break;
-			case 6: // custom
-				if (std::optional<DWORD> cursorColor = RegGetDWORD(hKey, L"CursorColor")) {
-					fillColour = *cursorColor;
-				}
-				break;
-			default: // 0, 3 white, 2, 5 invert
-				break;
-			}
-		}
-		::RegCloseKey(hKey);
-	}
-
-	cursorHelper.Draw(fillColour, strokeColour);
-	HCURSOR cursor = cursorHelper.Create();
-	return cursor;
-}
-
-void Window::SetCursor(Cursor curs) {
-	ChooseCursor(curs);
-}
-
-/* Returns rectangle of monitor pt is on, both rect and pt are in Window's
-   coordinates */
-PRectangle Window::GetMonitorRect(Point pt) {
-	const PRectangle rcPosition = GetPosition();
-	const POINT ptDesktop = {static_cast<LONG>(pt.x + rcPosition.left),
-		static_cast<LONG>(pt.y + rcPosition.top)};
-	HMONITOR hMonitor = MonitorFromPoint(ptDesktop, MONITOR_DEFAULTTONEAREST);
-
-	const RECT rcWork = RectFromMonitor(hMonitor);
-	if (rcWork.left < rcWork.right) {
-		PRectangle rcMonitor(
-			rcWork.left - rcPosition.left,
-			rcWork.top - rcPosition.top,
-			rcWork.right - rcPosition.left,
-			rcWork.bottom - rcPosition.top);
-		return rcMonitor;
-	}
-	return PRectangle();
-}
-
-struct ListItemData {
-	const char *text;
-	int pixId;
-};
-
-class LineToItem {
-	std::vector<char> words;
-
-	std::vector<ListItemData> data;
-
-public:
-	void Clear() noexcept {
-		words.clear();
-		data.clear();
-	}
-
-	[[nodiscard]] ListItemData Get(size_t index) const noexcept {
-		if (index < data.size()) {
-			return data[index];
-		}
-		ListItemData missing = {"", -1};
-		return missing;
-	}
-	[[nodiscard]] int Count() const noexcept {
-		return static_cast<int>(data.size());
-	}
-
-	void AllocItem(const char *text, int pixId) {
-		const ListItemData lid = { text, pixId };
-		data.push_back(lid);
-	}
-
-	char *SetWords(const char *s) {
-		words = std::vector<char>(s, s+strlen(s)+1);
-		return &words[0];
-	}
-};
-
-const TCHAR ListBoxX_ClassName[] = TEXT("ListBoxX");
-
-ListBox::ListBox() noexcept = default;
-
-ListBox::~ListBox() noexcept = default;
-
-class ListBoxX : public ListBox {
-	int lineHeight = 10;
-	HFONT fontCopy {};
-	Technology technology = Technology::Default;
-	RGBAImageSet images;
-	LineToItem lti;
-	HWND lb {};
-	bool unicodeMode = false;
-	int desiredVisibleRows = 9;
-	unsigned int maxItemCharacters = 0;
-	unsigned int aveCharWidth = 8;
-	Window *parent = nullptr;
-	int ctrlID = 0;
-	UINT dpi = USER_DEFAULT_SCREEN_DPI;
-	IListBoxDelegate *delegate = nullptr;
-	const char *widestItem = nullptr;
-	unsigned int maxCharWidth = 1;
-	WPARAM resizeHit = 0;
-	PRectangle rcPreSize;
-	Point dragOffset;
-	Point location;	// Caret location at which the list is opened
-	MouseWheelDelta wheelDelta;
-	ListOptions options;
-	DWORD frameStyle = WS_THICKFRAME;
-
-	HWND GetHWND() const noexcept;
-	void AppendListItem(const char *text, const char *numword);
-	void AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept;
-	int ItemHeight() const noexcept;
-	int MinClientWidth() const noexcept;
-	int TextOffset() const noexcept;
-	POINT GetClientExtent() const noexcept;
-	POINT MinTrackSize() const noexcept;
-	POINT MaxTrackSize() const noexcept;
-	void SetRedraw(bool on) noexcept;
-	void OnDoubleClick();
-	void OnSelChange();
-	void ResizeToCursor();
-	void StartResize(WPARAM);
-	LRESULT NcHitTest(WPARAM, LPARAM) const;
-	void CentreItem(int n);
-	void Paint(HDC);
-	static LRESULT PASCAL ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
-
-	static constexpr POINT ItemInset {0, 0};	// Padding around whole item
-	static constexpr POINT TextInset {2, 0};	// Padding around text
-	static constexpr POINT ImageInset {1, 0};	// Padding around image
-
-public:
-	ListBoxX() = default;
-	ListBoxX(const ListBoxX &) = delete;
-	ListBoxX(ListBoxX &&) = delete;
-	ListBoxX &operator=(const ListBoxX &) = delete;
-	ListBoxX &operator=(ListBoxX &&) = delete;
-	~ListBoxX() noexcept override {
-		if (fontCopy) {
-			::DeleteObject(fontCopy);
-			fontCopy = {};
-		}
-	}
-	void SetFont(const Font *font) override;
-	void Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, Technology technology_) override;
-	void SetAverageCharWidth(int width) override;
-	void SetVisibleRows(int rows) override;
-	int GetVisibleRows() const override;
-	PRectangle GetDesiredRect() override;
-	int CaretFromEdge() override;
-	void Clear() noexcept override;
-	void Append(char *s, int type) override;
-	int Length() override;
-	void Select(int n) override;
-	int GetSelection() override;
-	int Find(const char *prefix) override;
-	std::string GetValue(int n) override;
-	void RegisterImage(int type, const char *xpm_data) override;
-	void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) override;
-	void ClearRegisteredImages() override;
-	void SetDelegate(IListBoxDelegate *lbDelegate) override;
-	void SetList(const char *list, char separator, char typesep) override;
-	void SetOptions(ListOptions options_) override;
-	void Draw(DRAWITEMSTRUCT *pDrawItem);
-	LRESULT WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
-	static LRESULT PASCAL StaticWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
-};
-
-std::unique_ptr<ListBox> ListBox::Allocate() {
-	return std::make_unique<ListBoxX>();
-}
-
-void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, Technology technology_) {
-	parent = &parent_;
-	ctrlID = ctrlID_;
-	location = location_;
-	lineHeight = lineHeight_;
-	unicodeMode = unicodeMode_;
-	technology = technology_;
-	HWND hwndParent = HwndFromWindow(*parent);
-	HINSTANCE hinstanceParent = GetWindowInstance(hwndParent);
-	// Window created as popup so not clipped within parent client area
-	wid = ::CreateWindowEx(
-		WS_EX_WINDOWEDGE, ListBoxX_ClassName, TEXT(""),
-		WS_POPUP | frameStyle,
-		100,100, 150,80, hwndParent,
-		{},
-		hinstanceParent,
-		this);
-
-	dpi = DpiForWindow(hwndParent);
-	POINT locationw = POINTFromPoint(location);
-	::MapWindowPoints(hwndParent, {}, &locationw, 1);
-	location = PointFromPOINT(locationw);
-}
-
-void ListBoxX::SetFont(const Font *font) {
-	const FontWin *pfm = dynamic_cast<const FontWin *>(font);
-	if (pfm) {
-		if (fontCopy) {
-			::DeleteObject(fontCopy);
-			fontCopy = {};
-		}
-		fontCopy = pfm->HFont();
-		SetWindowFont(lb, fontCopy, 0);
-	}
-}
-
-void ListBoxX::SetAverageCharWidth(int width) {
-	aveCharWidth = width;
-}
-
-void ListBoxX::SetVisibleRows(int rows) {
-	desiredVisibleRows = rows;
-}
-
-int ListBoxX::GetVisibleRows() const {
-	return desiredVisibleRows;
-}
-
-HWND ListBoxX::GetHWND() const noexcept {
-	return HwndFromWindowID(GetID());
-}
-
-PRectangle ListBoxX::GetDesiredRect() {
-	PRectangle rcDesired = GetPosition();
-
-	int rows = Length();
-	if ((rows == 0) || (rows > desiredVisibleRows))
-		rows = desiredVisibleRows;
-	rcDesired.bottom = rcDesired.top + ItemHeight() * rows;
-
-	int width = MinClientWidth();
-	HDC hdc = ::GetDC(lb);
-	HFONT oldFont = SelectFont(hdc, fontCopy);
-	SIZE textSize = {0, 0};
-	int len = 0;
-	if (widestItem) {
-		len = static_cast<int>(strlen(widestItem));
-		if (unicodeMode) {
-			const TextWide tbuf(widestItem, CpUtf8);
-			::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &textSize);
-		} else {
-			::GetTextExtentPoint32A(hdc, widestItem, len, &textSize);
-		}
-	}
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	maxCharWidth = tm.tmMaxCharWidth;
-	SelectFont(hdc, oldFont);
-	::ReleaseDC(lb, hdc);
-
-	const int widthDesired = std::max(textSize.cx, (len + 1) * tm.tmAveCharWidth);
-	if (width < widthDesired)
-		width = widthDesired;
-
-	rcDesired.right = rcDesired.left + TextOffset() + width + (TextInset.x * 2);
-	if (Length() > rows)
-		rcDesired.right += SystemMetricsForDpi(SM_CXVSCROLL, dpi);
-
-	AdjustWindowRect(&rcDesired, dpi);
-	return rcDesired;
-}
-
-int ListBoxX::TextOffset() const noexcept {
-	const int pixWidth = images.GetWidth();
-	return pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2);
-}
-
-int ListBoxX::CaretFromEdge() {
-	PRectangle rc;
-	AdjustWindowRect(&rc, dpi);
-	return TextOffset() + static_cast<int>(TextInset.x + (0 - rc.left) - 1);
-}
-
-void ListBoxX::Clear() noexcept {
-	ListBox_ResetContent(lb);
-	maxItemCharacters = 0;
-	widestItem = nullptr;
-	lti.Clear();
-}
-
-void ListBoxX::Append(char *, int) {
-	// This method is no longer called in Scintilla
-	PLATFORM_ASSERT(false);
-}
-
-int ListBoxX::Length() {
-	return lti.Count();
-}
-
-void ListBoxX::Select(int n) {
-	// We are going to scroll to centre on the new selection and then select it, so disable
-	// redraw to avoid flicker caused by a painting new selection twice in unselected and then
-	// selected states
-	SetRedraw(false);
-	CentreItem(n);
-	ListBox_SetCurSel(lb, n);
-	OnSelChange();
-	SetRedraw(true);
-}
-
-int ListBoxX::GetSelection() {
-	return ListBox_GetCurSel(lb);
-}
-
-// This is not actually called at present
-int ListBoxX::Find(const char *) {
-	return LB_ERR;
-}
-
-std::string ListBoxX::GetValue(int n) {
-	const ListItemData item = lti.Get(n);
-	return item.text;
-}
-
-void ListBoxX::RegisterImage(int type, const char *xpm_data) {
-	XPM xpmImage(xpm_data);
-	images.AddImage(type, std::make_unique<RGBAImage>(xpmImage));
-}
-
-void ListBoxX::RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) {
-	images.AddImage(type, std::make_unique<RGBAImage>(width, height, 1.0f, pixelsImage));
-}
-
-void ListBoxX::ClearRegisteredImages() {
-	images.Clear();
-}
-
-namespace {
-
-int ColourOfElement(std::optional<ColourRGBA> colour, int nIndex) {
-	if (colour.has_value()) {
-		return colour.value().OpaqueRGB();
-	}
-	return ::GetSysColor(nIndex);
-}
-
-void FillRectColour(HDC hdc, const RECT *lprc, int colour) noexcept {
-	const HBRUSH brush = ::CreateSolidBrush(colour);
-	::FillRect(hdc, lprc, brush);
-	::DeleteObject(brush);
-}
-
-}
-
-void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
-	if ((pDrawItem->itemAction == ODA_SELECT) || (pDrawItem->itemAction == ODA_DRAWENTIRE)) {
-		RECT rcBox = pDrawItem->rcItem;
-		rcBox.left += TextOffset();
-		if (pDrawItem->itemState & ODS_SELECTED) {
-			RECT rcImage = pDrawItem->rcItem;
-			rcImage.right = rcBox.left;
-			// The image is not highlighted
-			FillRectColour(pDrawItem->hDC, &rcImage, ColourOfElement(options.back, COLOR_WINDOW));
-			FillRectColour(pDrawItem->hDC, &rcBox, ColourOfElement(options.backSelected, COLOR_HIGHLIGHT));
-			::SetBkColor(pDrawItem->hDC, ColourOfElement(options.backSelected, COLOR_HIGHLIGHT));
-			::SetTextColor(pDrawItem->hDC, ColourOfElement(options.foreSelected, COLOR_HIGHLIGHTTEXT));
-		} else {
-			FillRectColour(pDrawItem->hDC, &pDrawItem->rcItem, ColourOfElement(options.back, COLOR_WINDOW));
-			::SetBkColor(pDrawItem->hDC, ColourOfElement(options.back, COLOR_WINDOW));
-			::SetTextColor(pDrawItem->hDC, ColourOfElement(options.fore, COLOR_WINDOWTEXT));
-		}
-
-		const ListItemData item = lti.Get(pDrawItem->itemID);
-		const int pixId = item.pixId;
-		const char *text = item.text;
-		const int len = static_cast<int>(strlen(text));
-
-		RECT rcText = rcBox;
-		::InsetRect(&rcText, TextInset.x, TextInset.y);
-
-		if (unicodeMode) {
-			const TextWide tbuf(text, CpUtf8);
-			::DrawTextW(pDrawItem->hDC, tbuf.buffer, tbuf.tlen, &rcText, DT_NOPREFIX|DT_END_ELLIPSIS|DT_SINGLELINE|DT_NOCLIP);
-		} else {
-			::DrawTextA(pDrawItem->hDC, text, len, &rcText, DT_NOPREFIX|DT_END_ELLIPSIS|DT_SINGLELINE|DT_NOCLIP);
-		}
-
-		// Draw the image, if any
-		const RGBAImage *pimage = images.Get(pixId);
-		if (pimage) {
-			std::unique_ptr<Surface> surfaceItem(Surface::Allocate(technology));
-			if (technology == Technology::Default) {
-				surfaceItem->Init(pDrawItem->hDC, pDrawItem->hwndItem);
-				const long left = pDrawItem->rcItem.left + ItemInset.x + ImageInset.x;
-				const PRectangle rcImage = PRectangle::FromInts(left, pDrawItem->rcItem.top,
-					left + images.GetWidth(), pDrawItem->rcItem.bottom);
-				surfaceItem->DrawRGBAImage(rcImage,
-					pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
-				::SetTextAlign(pDrawItem->hDC, TA_TOP);
-			} else {
-#if defined(USE_D2D)
-				const D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
-					D2D1_RENDER_TARGET_TYPE_DEFAULT,
-					D2D1::PixelFormat(
-						DXGI_FORMAT_B8G8R8A8_UNORM,
-						D2D1_ALPHA_MODE_IGNORE),
-					0,
-					0,
-					D2D1_RENDER_TARGET_USAGE_NONE,
-					D2D1_FEATURE_LEVEL_DEFAULT
-					);
-				DCRenderTarget pDCRT;
-				HRESULT hr = CreateDCRenderTarget(&props, pDCRT);
-				if (SUCCEEDED(hr) && pDCRT) {
-					const long left = pDrawItem->rcItem.left + ItemInset.x + ImageInset.x;
-
-					RECT rcItem = pDrawItem->rcItem;
-					rcItem.left = left;
-					rcItem.right = rcItem.left + images.GetWidth();
-
-					hr = pDCRT->BindDC(pDrawItem->hDC, &rcItem);
-					if (SUCCEEDED(hr)) {
-						surfaceItem->Init(pDCRT.Get(), pDrawItem->hwndItem);
-						pDCRT->BeginDraw();
-						const PRectangle rcImage = PRectangle::FromInts(0, 0, images.GetWidth(), rcItem.bottom - rcItem.top);
-						surfaceItem->DrawRGBAImage(rcImage,
-							pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
-						pDCRT->EndDraw();
-					}
-				}
-#endif
-			}
-		}
-	}
-}
-
-void ListBoxX::AppendListItem(const char *text, const char *numword) {
-	int pixId = -1;
-	if (numword) {
-		pixId = 0;
-		char ch;
-		while ((ch = *++numword) != '\0') {
-			pixId = 10 * pixId + (ch - '0');
-		}
-	}
-
-	lti.AllocItem(text, pixId);
-	const unsigned int len = static_cast<unsigned int>(strlen(text));
-	if (maxItemCharacters < len) {
-		maxItemCharacters = len;
-		widestItem = text;
-	}
-}
-
-void ListBoxX::SetDelegate(IListBoxDelegate *lbDelegate) {
-	delegate = lbDelegate;
-}
-
-void ListBoxX::SetList(const char *list, char separator, char typesep) {
-	// Turn off redraw while populating the list - this has a significant effect, even if
-	// the listbox is not visible.
-	SetRedraw(false);
-	Clear();
-	const size_t size = strlen(list);
-	char *words = lti.SetWords(list);
-	const char *startword = words;
-	char *numword = nullptr;
-	for (size_t i=0; i < size; i++) {
-		if (words[i] == separator) {
-			words[i] = '\0';
-			if (numword)
-				*numword = '\0';
-			AppendListItem(startword, numword);
-			startword = words + i + 1;
-			numword = nullptr;
-		} else if (words[i] == typesep) {
-			numword = words + i;
-		}
-	}
-	if (startword) {
-		if (numword)
-			*numword = '\0';
-		AppendListItem(startword, numword);
-	}
-
-	// Finally populate the listbox itself with the correct number of items
-	const int count = lti.Count();
-	::SendMessage(lb, LB_INITSTORAGE, count, 0);
-	for (intptr_t j=0; j<count; j++) {
-		ListBox_AddItemData(lb, j+1);
-	}
-	SetRedraw(true);
-}
-
-void ListBoxX::SetOptions(ListOptions options_) {
-	options = options_;
-	frameStyle = FlagSet(options.options, AutoCompleteOption::FixedSize) ? WS_BORDER : WS_THICKFRAME;
-}
-
-void ListBoxX::AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept {
-	RECT rcw = RectFromPRectangle(*rc);
-	if (fnAdjustWindowRectExForDpi) {
-		fnAdjustWindowRectExForDpi(&rcw, frameStyle, false, WS_EX_WINDOWEDGE, dpiAdjust);
-	} else {
-		::AdjustWindowRectEx(&rcw, frameStyle, false, WS_EX_WINDOWEDGE);
-	}
-	*rc = PRectangle::FromInts(rcw.left, rcw.top, rcw.right, rcw.bottom);
-}
-
-int ListBoxX::ItemHeight() const noexcept {
-	int itemHeight = lineHeight + (TextInset.y * 2);
-	const int pixHeight = images.GetHeight() + (ImageInset.y * 2);
-	if (itemHeight < pixHeight) {
-		itemHeight = pixHeight;
-	}
-	return itemHeight;
-}
-
-int ListBoxX::MinClientWidth() const noexcept {
-	return 12 * (aveCharWidth+aveCharWidth/3);
-}
-
-POINT ListBoxX::MinTrackSize() const noexcept {
-	PRectangle rc = PRectangle::FromInts(0, 0, MinClientWidth(), ItemHeight());
-	AdjustWindowRect(&rc, dpi);
-	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
-	return ret;
-}
-
-POINT ListBoxX::MaxTrackSize() const noexcept {
-	PRectangle rc = PRectangle::FromInts(0, 0,
-		std::max<int>(static_cast<unsigned int>(MinClientWidth()),
-		maxCharWidth * maxItemCharacters + TextInset.x * 2 +
-		 TextOffset() + SystemMetricsForDpi(SM_CXVSCROLL, dpi)),
-		ItemHeight() * lti.Count());
-	AdjustWindowRect(&rc, dpi);
-	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
-	return ret;
-}
-
-void ListBoxX::SetRedraw(bool on) noexcept {
-	::SendMessage(lb, WM_SETREDRAW, on, 0);
-	if (on)
-		::InvalidateRect(lb, nullptr, TRUE);
-}
-
-void ListBoxX::ResizeToCursor() {
-	PRectangle rc = GetPosition();
-	POINT ptw;
-	::GetCursorPos(&ptw);
-	const Point pt = PointFromPOINT(ptw) + dragOffset;
-
-	switch (resizeHit) {
-		case HTLEFT:
-			rc.left = pt.x;
-			break;
-		case HTRIGHT:
-			rc.right = pt.x;
-			break;
-		case HTTOP:
-			rc.top = pt.y;
-			break;
-		case HTTOPLEFT:
-			rc.top = pt.y;
-			rc.left = pt.x;
-			break;
-		case HTTOPRIGHT:
-			rc.top = pt.y;
-			rc.right = pt.x;
-			break;
-		case HTBOTTOM:
-			rc.bottom = pt.y;
-			break;
-		case HTBOTTOMLEFT:
-			rc.bottom = pt.y;
-			rc.left = pt.x;
-			break;
-		case HTBOTTOMRIGHT:
-			rc.bottom = pt.y;
-			rc.right = pt.x;
-			break;
-		default:
-			break;
-	}
-
-	const POINT ptMin = MinTrackSize();
-	const POINT ptMax = MaxTrackSize();
-	// We don't allow the left edge to move at present, but just in case
-	rc.left = std::clamp(rc.left, rcPreSize.right - ptMax.x, rcPreSize.right - ptMin.x);
-	rc.top = std::clamp(rc.top, rcPreSize.bottom - ptMax.y, rcPreSize.bottom - ptMin.y);
-	rc.right = std::clamp(rc.right, rcPreSize.left + ptMin.x, rcPreSize.left + ptMax.x);
-	rc.bottom = std::clamp(rc.bottom, rcPreSize.top + ptMin.y, rcPreSize.top + ptMax.y);
-
-	SetPosition(rc);
-}
-
-void ListBoxX::StartResize(WPARAM hitCode) {
-	rcPreSize = GetPosition();
-	POINT cursorPos;
-	::GetCursorPos(&cursorPos);
-
-	switch (hitCode) {
-		case HTRIGHT:
-		case HTBOTTOM:
-		case HTBOTTOMRIGHT:
-			dragOffset.x = rcPreSize.right - cursorPos.x;
-			dragOffset.y = rcPreSize.bottom - cursorPos.y;
-			break;
-
-		case HTTOPRIGHT:
-			dragOffset.x = rcPreSize.right - cursorPos.x;
-			dragOffset.y = rcPreSize.top - cursorPos.y;
-			break;
-
-		// Note that the current hit test code prevents the left edge cases ever firing
-		// as we don't want the left edge to be movable
-		case HTLEFT:
-		case HTTOP:
-		case HTTOPLEFT:
-			dragOffset.x = rcPreSize.left - cursorPos.x;
-			dragOffset.y = rcPreSize.top - cursorPos.y;
-			break;
-		case HTBOTTOMLEFT:
-			dragOffset.x = rcPreSize.left - cursorPos.x;
-			dragOffset.y = rcPreSize.bottom - cursorPos.y;
-			break;
-
-		default:
-			return;
-	}
-
-	::SetCapture(GetHWND());
-	resizeHit = hitCode;
-}
-
-LRESULT ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
-	const PRectangle rc = GetPosition();
-
-	LRESULT hit = ::DefWindowProc(GetHWND(), WM_NCHITTEST, wParam, lParam);
-	// There is an apparent bug in the DefWindowProc hit test code whereby it will
-	// return HTTOPXXX if the window in question is shorter than the default
-	// window caption height + frame, even if one is hovering over the bottom edge of
-	// the frame, so workaround that here
-	if (hit >= HTTOP && hit <= HTTOPRIGHT) {
-		const int minHeight = SystemMetricsForDpi(SM_CYMINTRACK, dpi);
-		const int yPos = GET_Y_LPARAM(lParam);
-		if ((rc.Height() < minHeight) && (yPos > ((rc.top + rc.bottom)/2))) {
-			hit += HTBOTTOM - HTTOP;
-		}
-	}
-
-	// Never permit resizing that moves the left edge. Allow movement of top or bottom edge
-	// depending on whether the list is above or below the caret
-	switch (hit) {
-		case HTLEFT:
-		case HTTOPLEFT:
-		case HTBOTTOMLEFT:
-			hit = HTERROR;
-			break;
-
-		case HTTOP:
-		case HTTOPRIGHT: {
-				// Valid only if caret below list
-				if (location.y < rc.top)
-					hit = HTERROR;
-			}
-			break;
+class CursorHelper {
+	GDIBitMap bm;
+	DWORD *pixels = nullptr;
+	const int width;
+	const int height;
+	const float scale;
+	static constexpr float baseSize = 32.0f;
 
-		case HTBOTTOM:
-		case HTBOTTOMRIGHT: {
-				// Valid only if caret above list
-				if (rc.bottom <= location.y)
-					hit = HTERROR;
-			}
-			break;
-		default:
-			break;
-	}
+	static constexpr float arrow[][2] = {
+		{ 32.0f - 12.73606f,32.0f - 19.04075f },
+		{ 32.0f - 7.80159f, 32.0f - 19.04075f },
+		{ 32.0f - 9.82813f, 32.0f - 14.91828f },
+		{ 32.0f - 6.88341f, 32.0f - 13.42515f },
+		{ 32.0f - 4.62301f, 32.0f - 18.05872f },
+		{ 32.0f - 1.26394f, 32.0f - 14.78295f },
+		{ 32.0f - 1.26394f, 32.0f - 30.57485f },
+	};
 
-	return hit;
-}
+public:
+	~CursorHelper() = default;
 
-void ListBoxX::OnDoubleClick() {
-	if (delegate) {
-		ListBoxEvent event(ListBoxEvent::EventType::doubleClick);
-		delegate->ListNotify(&event);
+	CursorHelper(int width_, int height_) noexcept : width{width_}, height{height_}, scale{ static_cast<float>(width) / baseSize } {
+		// https://learn.microsoft.com/en-us/windows/win32/menurc/using-cursors#creating-a-cursor
+		bm.Create({}, width, height, &pixels);
 	}
-}
 
-void ListBoxX::OnSelChange() {
-	if (delegate) {
-		ListBoxEvent event(ListBoxEvent::EventType::selectionChange);
-		delegate->ListNotify(&event);
+	[[nodiscard]] explicit operator bool() const noexcept {
+		return static_cast<bool>(bm);
 	}
-}
-
-POINT ListBoxX::GetClientExtent() const noexcept {
-	RECT rc;
-	::GetWindowRect(HwndFromWindowID(wid), &rc);
-	POINT ret { rc.right - rc.left, rc.bottom - rc.top };
-	return ret;
-}
 
-void ListBoxX::CentreItem(int n) {
-	// If below mid point, scroll up to centre, but with more items below if uneven
-	if (n >= 0) {
-		const POINT extent = GetClientExtent();
-		const int visible = extent.y/ItemHeight();
-		if (visible < Length()) {
-			const int top = ListBox_GetTopIndex(lb);
-			const int half = (visible - 1) / 2;
-			if (n > (top + half))
-				ListBox_SetTopIndex(lb, n - half);
+	HCURSOR Create() noexcept {
+		HCURSOR cursor {};
+		// Create an empty mask bitmap.
+		HBITMAP hMonoBitmap = ::CreateBitmap(width, height, 1, 1, nullptr);
+		if (hMonoBitmap) {
+			// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-createiconindirect
+			// hBitmap should not already be selected into a device context
+			HBITMAP hBitmap = bm.Extract();
+			ICONINFO info = {false, static_cast<DWORD>(width - 1), 0, hMonoBitmap, hBitmap};
+			cursor = ::CreateIconIndirect(&info);
+			::DeleteObject(hMonoBitmap);
 		}
+		return cursor;
 	}
-}
-
-// Performs a double-buffered paint operation to avoid flicker
-void ListBoxX::Paint(HDC hDC) {
-	const POINT extent = GetClientExtent();
-	HBITMAP hBitmap = ::CreateCompatibleBitmap(hDC, extent.x, extent.y);
-	HDC bitmapDC = ::CreateCompatibleDC(hDC);
-	HBITMAP hBitmapOld = SelectBitmap(bitmapDC, hBitmap);
-	// The list background is mainly erased during painting, but can be a small
-	// unpainted area when at the end of a non-integrally sized list with a
-	// vertical scroll bar
-	const RECT rc = { 0, 0, extent.x, extent.y };
-	FillRectColour(bitmapDC, &rc, ColourOfElement(options.back, COLOR_WINDOWTEXT));
-	// Paint the entire client area and vertical scrollbar
-	::SendMessage(lb, WM_PRINT, reinterpret_cast<WPARAM>(bitmapDC), PRF_CLIENT|PRF_NONCLIENT);
-	::BitBlt(hDC, 0, 0, extent.x, extent.y, bitmapDC, 0, 0, SRCCOPY);
-	// Select a stock brush to prevent warnings from BoundsChecker
-	SelectBrush(bitmapDC, GetStockBrush(WHITE_BRUSH));
-	SelectBitmap(bitmapDC, hBitmapOld);
-	::DeleteDC(bitmapDC);
-	::DeleteObject(hBitmap);
-}
 
-LRESULT PASCAL ListBoxX::ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
-	try {
-		ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(::GetParent(hWnd)));
-		switch (iMessage) {
-		case WM_ERASEBKGND:
-			return TRUE;
-
-		case WM_PAINT: {
-				PAINTSTRUCT ps;
-				HDC hDC = ::BeginPaint(hWnd, &ps);
-				if (lbx) {
-					lbx->Paint(hDC);
-				}
-				::EndPaint(hWnd, &ps);
-			}
-			return 0;
+#if defined(USE_D2D)
 
-		case WM_MOUSEACTIVATE:
-			// This prevents the view activating when the scrollbar is clicked
-			return MA_NOACTIVATE;
+	bool DrawD2D(COLORREF fillColour, COLORREF strokeColour) noexcept {
+		if (!LoadD2D()) {
+			return false;
+		}
 
-		case WM_LBUTTONDOWN: {
-				// We must take control of selection to prevent the ListBox activating
-				// the popup
-				const LRESULT lResult = ::SendMessage(hWnd, LB_ITEMFROMPOINT, 0, lParam);
-				if (HIWORD(lResult) == 0) {
-					ListBox_SetCurSel(hWnd, LOWORD(lResult));
-					if (lbx) {
-						lbx->OnSelChange();
-					}
-				}
-			}
-			return 0;
+		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
+			D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED });
 
-		case WM_LBUTTONUP:
-			return 0;
+		DCRenderTarget pTarget;
+		HRESULT hr = CreateDCRenderTarget(&drtp, pTarget);
+		if (FAILED(hr) || !pTarget) {
+			return false;
+		}
 
-		case WM_LBUTTONDBLCLK: {
-				if (lbx) {
-					lbx->OnDoubleClick();
-				}
-			}
-			return 0;
+		const RECT rc = {0, 0, width, height};
+		hr = pTarget->BindDC(bm.DC(), &rc);
+		if (FAILED(hr)) {
+			return false;
+		}
 
-		case WM_MBUTTONDOWN:
-			// disable the scroll wheel button click action
-			return 0;
+		pTarget->BeginDraw();
 
-		default:
-			break;
+		// Draw something on the bitmap section.
+		constexpr size_t nPoints = std::size(arrow);
+		D2D1_POINT_2F points[nPoints]{};
+		for (size_t i = 0; i < nPoints; i++) {
+			points[i].x = arrow[i][0] * scale;
+			points[i].y = arrow[i][1] * scale;
 		}
 
-		WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
-		if (prevWndProc) {
-			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
+		const Geometry geometry = GeometryCreate();
+		if (!geometry) {
+			return false;
 		}
-		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-	} catch (...) {
-	}
-	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-}
 
-LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
-	switch (iMessage) {
-	case WM_CREATE: {
-			HINSTANCE hinstanceParent = GetWindowInstance(HwndFromWindow(*parent));
-			// Note that LBS_NOINTEGRALHEIGHT is specified to fix cosmetic issue when resizing the list
-			// but has useful side effect of speeding up list population significantly
-			lb = ::CreateWindowEx(
-				0, TEXT("listbox"), TEXT(""),
-				WS_CHILD | WS_VSCROLL | WS_VISIBLE |
-				LBS_OWNERDRAWFIXED | LBS_NODATA | LBS_NOINTEGRALHEIGHT,
-				0, 0, 150,80, hWnd,
-				reinterpret_cast<HMENU>(static_cast<ptrdiff_t>(ctrlID)),
-				hinstanceParent,
-				nullptr);
-			WNDPROC prevWndProc = SubclassWindow(lb, ControlWndProc);
-			::SetWindowLongPtr(lb, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(prevWndProc));
+		const GeometrySink sink = GeometrySinkCreate(geometry.Get());
+		if (!sink) {
+			return false;
 		}
-		break;
 
-	case WM_SIZE:
-		if (lb) {
-			SetRedraw(false);
-			::SetWindowPos(lb, {}, 0, 0, LOWORD(lParam), HIWORD(lParam), SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
-			// Ensure the selection remains visible
-			CentreItem(GetSelection());
-			SetRedraw(true);
+		sink->BeginFigure(points[0], D2D1_FIGURE_BEGIN_FILLED);
+		for (size_t i = 1; i < nPoints; i++) {
+			sink->AddLine(points[i]);
 		}
-		break;
-
-	case WM_PAINT: {
-			PAINTSTRUCT ps;
-			::BeginPaint(hWnd, &ps);
-			::EndPaint(hWnd, &ps);
+		sink->EndFigure(D2D1_FIGURE_END_CLOSED);
+		hr = sink->Close();
+		if (FAILED(hr)) {
+			return false;
 		}
-		break;
 
-	case WM_COMMAND:
-		// This is not actually needed now - the registered double click action is used
-		// directly to action a choice from the list.
-		::SendMessage(HwndFromWindow(*parent), iMessage, wParam, lParam);
-		break;
-
-	case WM_MEASUREITEM: {
-			MEASUREITEMSTRUCT *pMeasureItem = reinterpret_cast<MEASUREITEMSTRUCT *>(lParam);
-			pMeasureItem->itemHeight = ItemHeight();
+		if (const BrushSolid pBrushFill = BrushSolidCreate(pTarget.Get(), fillColour)) {
+			pTarget->FillGeometry(geometry.Get(), pBrushFill.Get());
 		}
-		break;
-
-	case WM_DRAWITEM:
-		Draw(reinterpret_cast<DRAWITEMSTRUCT *>(lParam));
-		break;
 
-	case WM_DESTROY:
-		lb = {};
-		SetWindowPointer(hWnd, nullptr);
-		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+		if (const BrushSolid pBrushStroke = BrushSolidCreate(pTarget.Get(), strokeColour)) {
+			pTarget->DrawGeometry(geometry.Get(), pBrushStroke.Get(), scale);
+		}
 
-	case WM_ERASEBKGND:
-		// To reduce flicker we can elide background erasure since this window is
-		// completely covered by its child.
-		return TRUE;
+		hr = pTarget->EndDraw();
+		return SUCCEEDED(hr);
+	}
+#endif
 
-	case WM_GETMINMAXINFO: {
-			MINMAXINFO *minMax = reinterpret_cast<MINMAXINFO*>(lParam);
-			minMax->ptMaxTrackSize = MaxTrackSize();
-			minMax->ptMinTrackSize = MinTrackSize();
+	void Draw(COLORREF fillColour, COLORREF strokeColour) noexcept {
+#if defined(USE_D2D)
+		if (DrawD2D(fillColour, strokeColour)) {
+			return;
 		}
-		break;
+#endif
 
-	case WM_MOUSEACTIVATE:
-		return MA_NOACTIVATE;
+		// Draw something on the DIB section.
+		constexpr size_t nPoints = std::size(arrow);
+		POINT points[nPoints]{};
+		for (size_t i = 0; i < nPoints; i++) {
+			points[i].x = std::lround(arrow[i][0] * scale);
+			points[i].y = std::lround(arrow[i][1] * scale);
+		}
 
-	case WM_NCHITTEST:
-		return NcHitTest(wParam, lParam);
+		const DWORD penWidth = std::lround(scale);
+		HPEN pen{};
+		if (penWidth > 1) {
+			const LOGBRUSH brushParameters { BS_SOLID, strokeColour, 0 };
+			pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
+				penWidth,
+				&brushParameters,
+				0,
+				nullptr);
+		} else {
+			pen = ::CreatePen(PS_INSIDEFRAME, 1, strokeColour);
+		}
 
-	case WM_NCLBUTTONDOWN:
-		// We have to implement our own window resizing because the DefWindowProc
-		// implementation insists on activating the resized window
-		StartResize(wParam);
-		return 0;
+		HPEN penOld = SelectPen(bm.DC(), pen);
+		HBRUSH brush = ::CreateSolidBrush(fillColour);
+		HBRUSH brushOld = SelectBrush(bm.DC(), brush);
+		::Polygon(bm.DC(), points, static_cast<int>(nPoints));
+		SelectPen(bm.DC(), penOld);
+		SelectBrush(bm.DC(), brushOld);
+		::DeleteObject(pen);
+		::DeleteObject(brush);
 
-	case WM_MOUSEMOVE: {
-			if (resizeHit == 0) {
-				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+		// Set the alpha values for each pixel in the cursor.
+		constexpr DWORD opaque = 0xFF000000U;
+		for (int i = 0; i < width*height; i++) {
+			if (*pixels != 0) {
+				*pixels |= opaque;
 			}
-			ResizeToCursor();
+			pixels++;
 		}
-		break;
+	}
+};
 
-	case WM_LBUTTONUP:
-	case WM_CANCELMODE:
-		if (resizeHit != 0) {
-			resizeHit = 0;
-			::ReleaseCapture();
-		}
-		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-	case WM_MOUSEWHEEL:
-		if (wheelDelta.Accumulate(wParam)) {
-			const int nRows = GetVisibleRows();
-			int linesToScroll = std::clamp(nRows - 1, 1, 3);
-			linesToScroll *= wheelDelta.Actions();
-			int top = ListBox_GetTopIndex(lb) + linesToScroll;
-			if (top < 0) {
-				top = 0;
-			}
-			ListBox_SetTopIndex(lb, top);
-		}
-		break;
+void ChooseCursor(LPCTSTR cursor) noexcept {
+	::SetCursor(::LoadCursor({}, cursor));
+}
 
+void ChooseCursor(Window::Cursor curs) noexcept {
+	switch (curs) {
+	case Window::Cursor::text:
+		ChooseCursor(IDC_IBEAM);
+		break;
+	case Window::Cursor::up:
+		ChooseCursor(IDC_UPARROW);
+		break;
+	case Window::Cursor::wait:
+		ChooseCursor(IDC_WAIT);
+		break;
+	case Window::Cursor::horizontal:
+		ChooseCursor(IDC_SIZEWE);
+		break;
+	case Window::Cursor::vertical:
+		ChooseCursor(IDC_SIZENS);
+		break;
+	case Window::Cursor::hand:
+		ChooseCursor(IDC_HAND);
+		break;
+	case Window::Cursor::reverseArrow:
+	case Window::Cursor::arrow:
+	case Window::Cursor::invalid:	// Should not occur, but just in case.
 	default:
-		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+		ChooseCursor(IDC_ARROW);
+		break;
 	}
+}
 
-	return 0;
 }
 
-LRESULT PASCAL ListBoxX::StaticWndProc(
-    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
-	if (iMessage == WM_CREATE) {
-		CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT *>(lParam);
-		SetWindowPointer(hWnd, pCreate->lpCreateParams);
+HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept {
+	// https://learn.microsoft.com/en-us/answers/questions/815036/windows-cursor-size
+	constexpr DWORD defaultCursorBaseSize = 32;
+	constexpr DWORD maxCursorBaseSize = 16*(1 + 15); // 16*(1 + CursorSize)
+	DWORD cursorBaseSize = 0;
+	HKEY hKey {};
+	LSTATUS status = ::RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\Cursors", 0, KEY_QUERY_VALUE, &hKey);
+	if (status == ERROR_SUCCESS) {
+		if (std::optional<DWORD> baseSize = RegGetDWORD(hKey, L"CursorBaseSize")) {
+			// CursorBaseSize is multiple of 16
+			cursorBaseSize = std::min(*baseSize & ~15, maxCursorBaseSize);
+		}
+		::RegCloseKey(hKey);
 	}
-	// Find C++ object associated with window.
-	ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd));
-	if (lbx) {
-		return lbx->WndProc(hWnd, iMessage, wParam, lParam);
+
+	int width = 0;
+	int height = 0;
+	if (cursorBaseSize > defaultCursorBaseSize) {
+		width = ::MulDiv(cursorBaseSize, dpi, USER_DEFAULT_SCREEN_DPI);
+		height = width;
+	} else {
+		width = SystemMetricsForDpi(SM_CXCURSOR, dpi);
+		height = SystemMetricsForDpi(SM_CYCURSOR, dpi);
+		PLATFORM_ASSERT(width == height);
 	}
-	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-}
 
-namespace {
+	CursorHelper cursorHelper(width, height);
+	if (!cursorHelper) {
+		return {};
+	}
 
-bool ListBoxX_Register() noexcept {
-	WNDCLASSEX wndclassc {};
-	wndclassc.cbSize = sizeof(wndclassc);
-	// We need CS_HREDRAW and CS_VREDRAW because of the ellipsis that might be drawn for
-	// truncated items in the list and the appearance/disappearance of the vertical scroll bar.
-	// The list repaint is double-buffered to avoid the flicker this would otherwise cause.
-	wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-	wndclassc.cbWndExtra = sizeof(ListBoxX *);
-	wndclassc.hInstance = hinstPlatformRes;
-	wndclassc.lpfnWndProc = ListBoxX::StaticWndProc;
-	wndclassc.hCursor = ::LoadCursor({}, IDC_ARROW);
-	wndclassc.lpszClassName = ListBoxX_ClassName;
+	COLORREF fillColour = RGB(0xff, 0xff, 0xfe);
+	COLORREF strokeColour = RGB(0, 0, 1);
+	status = ::RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Accessibility", 0, KEY_QUERY_VALUE, &hKey);
+	if (status == ERROR_SUCCESS) {
+		if (std::optional<DWORD> cursorType = RegGetDWORD(hKey, L"CursorType")) {
+			switch (*cursorType) {
+			case 1: // black
+			case 4: // black
+				std::swap(fillColour, strokeColour);
+				break;
+			case 6: // custom
+				if (std::optional<DWORD> cursorColor = RegGetDWORD(hKey, L"CursorColor")) {
+					fillColour = *cursorColor;
+				}
+				break;
+			default: // 0, 3 white, 2, 5 invert
+				break;
+			}
+		}
+		::RegCloseKey(hKey);
+	}
 
-	return ::RegisterClassEx(&wndclassc) != 0;
+	cursorHelper.Draw(fillColour, strokeColour);
+	HCURSOR cursor = cursorHelper.Create();
+	return cursor;
 }
 
-void ListBoxX_Unregister() noexcept {
-	if (hinstPlatformRes) {
-		::UnregisterClass(ListBoxX_ClassName, hinstPlatformRes);
-	}
+void Window::SetCursor(Cursor curs) {
+	ChooseCursor(curs);
 }
 
+/* Returns rectangle of monitor pt is on, both rect and pt are in Window's
+   coordinates */
+PRectangle Window::GetMonitorRect(Point pt) {
+	const PRectangle rcPosition = GetPosition();
+	const POINT ptDesktop = {static_cast<LONG>(pt.x + rcPosition.left),
+		static_cast<LONG>(pt.y + rcPosition.top)};
+	HMONITOR hMonitor = MonitorFromPoint(ptDesktop, MONITOR_DEFAULTTONEAREST);
+
+	const RECT rcWork = RectFromMonitor(hMonitor);
+	if (rcWork.left < rcWork.right) {
+		PRectangle rcMonitor(
+			rcWork.left - rcPosition.left,
+			rcWork.top - rcPosition.top,
+			rcWork.right - rcPosition.left,
+			rcWork.bottom - rcPosition.top);
+		return rcMonitor;
+	}
+	return PRectangle();
 }
 
 Menu::Menu() noexcept : mid{} {
@@ -4108,12 +696,17 @@ void Menu::Show(Point pt, const Window &w) {
 	Destroy();
 }
 
+ColourRGBA ColourFromSys(int nIndex) noexcept {
+	const DWORD colourValue = ::GetSysColor(nIndex);
+	return ColourRGBA::FromRGB(colourValue);
+}
+
 ColourRGBA Platform::Chrome() {
-	return ColourRGBA::FromRGB(static_cast<int>(::GetSysColor(COLOR_3DFACE)));
+	return ColourFromSys(COLOR_3DFACE);
 }
 
 ColourRGBA Platform::ChromeHighlight() {
-	return ColourRGBA::FromRGB(static_cast<int>(::GetSysColor(COLOR_3DHIGHLIGHT)));
+	return ColourFromSys(COLOR_3DHIGHLIGHT);
 }
 
 const char *Platform::DefaultFont() {
@@ -4148,7 +741,11 @@ void Platform::DebugPrintf(const char *, ...) noexcept {
 }
 #endif
 
-static bool assertionPopUps = true;
+namespace {
+
+bool assertionPopUps = true;
+
+}
 
 bool Platform::ShowAssertionPopUps(bool assertionPopUps_) noexcept {
 	const bool ret = assertionPopUps;
@@ -4182,25 +779,10 @@ void Platform_Initialise(void *hInstance) noexcept {
 	ListBoxX_Register();
 }
 
-namespace {
-
-void ReleaseLibrary(HMODULE &hLib) noexcept {
-	if (hLib) {
-		FreeLibrary(hLib);
-		hLib = {};
-	}
-}
-
-}
-
 void Platform_Finalise(bool fromDllMain) noexcept {
 	if (!fromDllMain) {
 #if defined(USE_D2D)
-		ReleaseUnknown(pIDWriteFactory);
-		ReleaseUnknown(pD2DFactory);
-		ReleaseLibrary(hDLLDWrite);
-		ReleaseLibrary(hDLLD3D);
-		ReleaseLibrary(hDLLD2D);
+		ReleaseD2D();
 #endif
 		ReleaseLibrary(hDLLShcore);
 	}
diff --git a/src/scintilla/win32/PlatWin.h b/src/scintilla/win32/PlatWin.h
index 86022a0cd..1edad6044 100644
--- a/src/scintilla/win32/PlatWin.h
+++ b/src/scintilla/win32/PlatWin.h
@@ -13,6 +13,10 @@ namespace Scintilla::Internal {
 #ifndef USER_DEFAULT_SCREEN_DPI
 #define USER_DEFAULT_SCREEN_DPI		96
 #endif
+constexpr FLOAT dpiDefault = USER_DEFAULT_SCREEN_DPI;
+
+// Used for defining font size with LOGFONT
+constexpr int pointsPerInch = 72;
 
 extern void Platform_Initialise(void *hInstance) noexcept;
 
@@ -24,6 +28,10 @@ constexpr RECT RectFromPRectangle(PRectangle prc) noexcept {
 	return rc;
 }
 
+constexpr PRectangle PRectangleFromRECT(RECT rc) noexcept {
+	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
+}
+
 constexpr POINT POINTFromPoint(Point pt) noexcept {
 	return POINT{ static_cast<LONG>(pt.x), static_cast<LONG>(pt.y) };
 }
@@ -36,6 +44,8 @@ constexpr SIZE SizeOfRect(RECT rc) noexcept {
 	return { rc.right - rc.left, rc.bottom - rc.top };
 }
 
+ColourRGBA ColourFromSys(int nIndex) noexcept;
+
 constexpr HWND HwndFromWindowID(WindowID wid) noexcept {
 	return static_cast<HWND>(wid);
 }
@@ -44,6 +54,10 @@ inline HWND HwndFromWindow(const Window &w) noexcept {
 	return HwndFromWindowID(w.GetID());
 }
 
+extern HINSTANCE hinstPlatformRes;
+
+UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept;
+
 void *PointerFromWindow(HWND hWnd) noexcept;
 void SetWindowPointer(HWND hWnd, void *ptr) noexcept;
 
@@ -54,8 +68,22 @@ float GetDeviceScaleFactorWhenGdiScalingActive(HWND hWnd) noexcept;
 
 int SystemMetricsForDpi(int nIndex, UINT dpi) noexcept;
 
+void AdjustWindowRectForDpi(LPRECT lpRect, DWORD dwStyle, UINT dpi) noexcept;
+
 HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept;
 
+// Encapsulate WM_PAINT handling so that EndPaint is always called even with unexpected returns or exceptions.
+struct Painter {
+	HWND hWnd{};
+	PAINTSTRUCT ps{};
+	explicit Painter(HWND hWnd_) noexcept : hWnd(hWnd_) {
+		::BeginPaint(hWnd, &ps);
+	}
+	~Painter() {
+		::EndPaint(hWnd, &ps);
+	}
+};
+
 class MouseWheelDelta {
 	int wheelDelta = 0;
 public:
@@ -70,29 +98,89 @@ class MouseWheelDelta {
 	}
 };
 
-#if defined(USE_D2D)
-extern bool LoadD2D() noexcept;
-extern ID2D1Factory1 *pD2DFactory;
-extern IDWriteFactory1 *pIDWriteFactory;
-
-using DCRenderTarget = ComPtr<ID2D1DCRenderTarget>;
-
-using D3D11Device = ComPtr<ID3D11Device1>;
-
-HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept;
-extern HRESULT CreateD3D(D3D11Device &device) noexcept;
+// Both GDI and DirectWrite can produce a HFONT for use in list boxes
+struct FontWin : public Font {
+	[[nodiscard]] virtual HFONT HFont() const noexcept = 0;
+	[[nodiscard]] virtual std::unique_ptr<FontWin> Duplicate() const = 0;
+	[[nodiscard]] virtual CharacterSet GetCharacterSet() const noexcept = 0;
+};
 
-using WriteRenderingParams = ComPtr<IDWriteRenderingParams1>;
+// Buffer to hold strings and string position arrays without always allocating on heap.
+// May sometimes have string too long to allocate on stack. So use a fixed stack-allocated buffer
+// when less than safe size otherwise allocate on heap and free automatically.
+template<typename T, int lengthStandard>
+class VarBuffer {
+	T bufferStandard[lengthStandard];
+public:
+	T *buffer;
+	explicit VarBuffer(size_t length) : buffer(nullptr) {
+		if (length > lengthStandard) {
+			buffer = new T[length];
+		} else {
+			buffer = bufferStandard;
+		}
+	}
+	// Deleted so VarBuffer objects can not be copied.
+	VarBuffer(const VarBuffer &) = delete;
+	VarBuffer(VarBuffer &&) = delete;
+	VarBuffer &operator=(const VarBuffer &) = delete;
+	VarBuffer &operator=(VarBuffer &&) = delete;
+
+	~VarBuffer() noexcept {
+		if (buffer != bufferStandard) {
+			delete[]buffer;
+			buffer = nullptr;
+		}
+	}
+};
 
-struct RenderingParams {
-	WriteRenderingParams defaultRenderingParams;
-	WriteRenderingParams customRenderingParams;
+constexpr int stackBufferLength = 400;
+class TextWide : public VarBuffer<wchar_t, stackBufferLength> {
+public:
+	int tlen;	// Using int instead of size_t as most Win32 APIs take int.
+	TextWide(std::string_view text, int codePage) :
+		VarBuffer<wchar_t, stackBufferLength>(text.length()) {
+		if (codePage == CpUtf8) {
+			tlen = static_cast<int>(UTF16FromUTF8(text, buffer, text.length()));
+		} else {
+			// Support Asian string display in 9x English
+			tlen = ::MultiByteToWideChar(codePage, 0, text.data(), static_cast<int>(text.length()),
+				buffer, static_cast<int>(text.length()));
+		}
+	}
+	[[nodiscard]] std::wstring_view AsView() const noexcept {
+		return std::wstring_view(buffer, tlen);
+	}
 };
+using TextPositions = VarBuffer<XYPOSITION, stackBufferLength>;
+
+// Manage the lifetime of a memory HBITMAP and its HDC so there are no leaks.
+class GDIBitMap {
+	HDC hdc{};
+	HBITMAP hbm{};
+	HBITMAP hbmOriginal{};
 
-struct ISetRenderingParams {
-	virtual void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) = 0;
+public:
+	GDIBitMap() noexcept = default;
+	// Deleted so GDIBitMap objects can not be copied.
+	GDIBitMap(const GDIBitMap &) = delete;
+	GDIBitMap(GDIBitMap &&) = delete;
+	// Move would be OK but not needed yet
+	GDIBitMap &operator=(const GDIBitMap &) = delete;
+	GDIBitMap &operator=(GDIBitMap &&) = delete;
+	~GDIBitMap() noexcept;
+
+	void Create(HDC hdcBase, int width, int height, DWORD **pixels) noexcept;
+	void Release() noexcept;
+	HBITMAP Extract() noexcept;
+
+	[[nodiscard]] HDC DC() const noexcept {
+		return hdc;
+	}
+	[[nodiscard]] explicit operator bool() const noexcept {
+		return hdc && hbm;
+	}
 };
-#endif
 
 }
 
diff --git a/src/scintilla/win32/ScintRes.rc b/src/scintilla/win32/ScintRes.rc
index afc5a683a..069195ea9 100644
--- a/src/scintilla/win32/ScintRes.rc
+++ b/src/scintilla/win32/ScintRes.rc
@@ -4,8 +4,8 @@
 
 #include <windows.h>
 
-#define VERSION_SCINTILLA "5.5.5"
-#define VERSION_WORDS 5, 5, 5, 0
+#define VERSION_SCINTILLA "5.5.7"
+#define VERSION_WORDS 5, 5, 7, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
diff --git a/src/scintilla/win32/Scintilla.vcxproj b/src/scintilla/win32/Scintilla.vcxproj
index 82aa9b710..1fc1312ba 100644
--- a/src/scintilla/win32/Scintilla.vcxproj
+++ b/src/scintilla/win32/Scintilla.vcxproj
@@ -169,6 +169,9 @@
     <ClCompile Include="..\src\*.cxx" />
     <ClCompile Include="..\win32\HanjaDic.cxx" />
     <ClCompile Include="..\win32\PlatWin.cxx" />
+    <ClCompile Include="..\win32\ListBox.cxx" />
+    <ClCompile Include="..\win32\SurfaceGDI.cxx" />
+    <ClCompile Include="..\win32\SurfaceD2D.cxx" />
     <ClCompile Include="..\win32\ScintillaWin.cxx" />
     <ClCompile Include="..\win32\ScintillaDLL.cxx" />
   </ItemGroup>
diff --git a/src/scintilla/win32/ScintillaWin.cxx b/src/scintilla/win32/ScintillaWin.cxx
index ad3691859..b4c268562 100644
--- a/src/scintilla/win32/ScintillaWin.cxx
+++ b/src/scintilla/win32/ScintillaWin.cxx
@@ -19,6 +19,7 @@
 #include <string>
 #include <string_view>
 #include <vector>
+#include <array>
 #include <map>
 #include <set>
 #include <optional>
@@ -66,6 +67,7 @@ using Microsoft::WRL::ComPtr;
 #include "Geometry.h"
 #include "Platform.h"
 
+#include "CharacterType.h"
 #include "CharacterCategoryMap.h"
 #include "Position.h"
 #include "UniqueString.h"
@@ -86,6 +88,7 @@ using Microsoft::WRL::ComPtr;
 #include "Document.h"
 #include "CaseConvert.h"
 #include "UniConversion.h"
+#include "DBCS.h"
 #include "Selection.h"
 #include "PositionCache.h"
 #include "EditModel.h"
@@ -99,6 +102,9 @@ using Microsoft::WRL::ComPtr;
 
 #include "WinTypes.h"
 #include "PlatWin.h"
+#if defined(USE_D2D)
+#include "SurfaceD2D.h"
+#endif
 #include "HanjaDic.h"
 #include "ScintillaWin.h"
 
@@ -119,12 +125,7 @@ constexpr UINT SC_WIN_IDLE = 5001;
 // and delivering SCN_UPDATEUI
 constexpr UINT SC_WORK_IDLE = 5002;
 
-constexpr int IndicatorInput = static_cast<int>(Scintilla::IndicatorNumbers::Ime);
-constexpr int IndicatorTarget = IndicatorInput + 1;
-constexpr int IndicatorConverted = IndicatorInput + 2;
-constexpr int IndicatorUnknown = IndicatorInput + 3;
-
-typedef UINT_PTR (WINAPI *SetCoalescableTimerSig)(HWND hwnd, UINT_PTR nIDEvent,
+using SetCoalescableTimerSig = UINT_PTR (WINAPI *)(HWND hwnd, UINT_PTR nIDEvent,
 	UINT uElapse, TIMERPROC lpTimerFunc, ULONG uToleranceDelay);
 
 }
@@ -260,43 +261,103 @@ class DropTarget final : public IDropTarget {
 
 class IMContext {
 	HWND hwnd;
-public:
 	HIMC hIMC;
-	IMContext(HWND hwnd_) noexcept :
+public:
+
+	explicit IMContext(HWND hwnd_) noexcept :
 		hwnd(hwnd_), hIMC(::ImmGetContext(hwnd_)) {
 	}
+
 	// Deleted so IMContext objects can not be copied.
 	IMContext(const IMContext &) = delete;
 	IMContext(IMContext &&) = delete;
 	IMContext &operator=(const IMContext &) = delete;
 	IMContext &operator=(IMContext &&) = delete;
+
 	~IMContext() {
 		if (hIMC)
 			::ImmReleaseContext(hwnd, hIMC);
 	}
 
-	unsigned int GetImeCaretPos() const noexcept {
-		return ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, nullptr, 0);
+	[[nodiscard]] explicit operator bool() const noexcept {
+		return hIMC != HIMC{};
 	}
 
-	std::vector<BYTE> GetImeAttributes() const {
+	[[nodiscard]] unsigned int GetImeCaretPos() const noexcept {
+		return ::ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, nullptr, 0);
+	}
+
+	[[nodiscard]] std::vector<BYTE> GetImeAttributes() const {
 		const int attrLen = ::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, nullptr, 0);
 		std::vector<BYTE> attr(attrLen, 0);
-		::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, &attr[0], static_cast<DWORD>(attr.size()));
+		::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, attr.data(), static_cast<DWORD>(attr.size()));
 		return attr;
 	}
 
-	LONG GetCompositionStringLength(DWORD dwIndex) const noexcept {
+	[[nodiscard]] LONG GetCompositionStringLength(DWORD dwIndex) const noexcept {
 		const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, nullptr, 0);
 		return byteLen / sizeof(wchar_t);
 	}
 
-	std::wstring GetCompositionString(DWORD dwIndex) const {
+	[[nodiscard]] std::wstring GetCompositionString(DWORD dwIndex) const {
 		const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, nullptr, 0);
 		std::wstring wcs(byteLen / 2, 0);
-		::ImmGetCompositionStringW(hIMC, dwIndex, &wcs[0], byteLen);
+		::ImmGetCompositionStringW(hIMC, dwIndex, wcs.data(), byteLen);
 		return wcs;
 	}
+
+	BOOL SetCompositionString(DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen) const noexcept {
+		return ::ImmSetCompositionStringW(hIMC, dwIndex, lpComp, dwCompLen, nullptr, 0);
+	}
+
+	void SetCompositionWindow(Point pos) const noexcept {
+		COMPOSITIONFORM CompForm{};
+		CompForm.dwStyle = CFS_POINT;
+		CompForm.ptCurrentPos = POINTFromPoint(pos);
+		::ImmSetCompositionWindow(hIMC, &CompForm);
+	}
+
+	void SetCandidateWindowPos(Point pos, PRectangle rcClient, int lineHeight) const noexcept {
+		CANDIDATEFORM CandForm{};
+		CandForm.dwIndex = 0;
+		CandForm.dwStyle = CFS_EXCLUDE;
+		CandForm.ptCurrentPos.x = static_cast<int>(pos.x);
+		CandForm.ptCurrentPos.y = static_cast<int>(pos.y + std::max(4, lineHeight / 4));
+		// Exclude the area of the whole caret line
+		CandForm.rcArea.top = static_cast<int>(pos.y);
+		CandForm.rcArea.bottom = static_cast<int>(pos.y + lineHeight);
+		CandForm.rcArea.left = static_cast<int>(rcClient.left);
+		CandForm.rcArea.right = static_cast<int>(rcClient.right);
+		::ImmSetCandidateWindow(hIMC, &CandForm);
+	}
+
+	void SetCompositionFont(const ViewStyle &vs, int style, UINT dpi) const {
+		LOGFONTW lf{};
+		int sizeZoomed = vs.styles[style].size + (vs.zoomLevel * FontSizeMultiplier);
+		if (sizeZoomed <= 2 * FontSizeMultiplier)	// Hangs if sizeZoomed <= 1
+			sizeZoomed = 2 * FontSizeMultiplier;
+		// The negative is to allow for leading
+		lf.lfHeight = -::MulDiv(sizeZoomed, dpi, pointsPerInch * FontSizeMultiplier);
+		lf.lfWeight = static_cast<LONG>(vs.styles[style].weight);
+		lf.lfItalic = vs.styles[style].italic ? 1 : 0;
+		lf.lfCharSet = DEFAULT_CHARSET;
+		lf.lfFaceName[0] = L'\0';
+		if (vs.styles[style].fontName) {
+			const char *fontName = vs.styles[style].fontName;
+			UTF16FromUTF8(std::string_view(fontName), lf.lfFaceName, LF_FACESIZE);
+		}
+
+		::ImmSetCompositionFontW(hIMC, &lf);
+	}
+
+	void Notify(bool complete) const noexcept {
+		::ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, complete ? CPS_COMPLETE : CPS_CANCEL, 0);
+	}
+
+	LRESULT Escape(HKL hkl, UINT uEscape, LPVOID lpv) const noexcept {
+		return ::ImmEscapeW(hkl, hIMC, uEscape, lpv);
+	}
+
 };
 
 class GlobalMemory;
@@ -306,7 +367,7 @@ class ReverseArrowCursor {
 	bool valid = false;
 
 public:
-	ReverseArrowCursor() noexcept {}
+	ReverseArrowCursor() noexcept = default;
 	// Deleted so ReverseArrowCursor objects can not be copied.
 	ReverseArrowCursor(const ReverseArrowCursor &) = delete;
 	ReverseArrowCursor(ReverseArrowCursor &&) = delete;
@@ -480,7 +541,7 @@ class ScintillaWin :
 	static ATOM callClassAtom;
 
 	float deviceScaleFactor = 1.f;
-	int GetFirstIntegralMultipleDeviceScaleFactor() const noexcept {
+	[[nodiscard]] int GetFirstIntegralMultipleDeviceScaleFactor() const noexcept {
 		 return static_cast<int>(std::ceil(deviceScaleFactor));
 	}
 
@@ -494,12 +555,6 @@ class ScintillaWin :
 #endif
 
 	explicit ScintillaWin(HWND hwnd);
-	// Deleted so ScintillaWin objects can not be copied.
-	ScintillaWin(const ScintillaWin &) = delete;
-	ScintillaWin(ScintillaWin &&) = delete;
-	ScintillaWin &operator=(const ScintillaWin &) = delete;
-	ScintillaWin &operator=(ScintillaWin &&) = delete;
-	// ~ScintillaWin() in public section
 
 	void Finalise() override;
 #if defined(USE_D2D)
@@ -511,7 +566,7 @@ class ScintillaWin :
 	void EnsureRenderTarget(HDC hdc);
 #endif
 	void DropRenderTarget() noexcept;
-	HWND MainHWND() const noexcept;
+	[[nodiscard]] HWND MainHWND() const noexcept;
 
 	static sptr_t DirectFunction(
 		    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam);
@@ -519,6 +574,9 @@ class ScintillaWin :
 		    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam, int *pStatus);
 	static LRESULT PASCAL SWndProc(
 		    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+
+	void CTPaint(HWND hWnd);
+	LRESULT CTProcessMessage(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
 	static LRESULT PASCAL CTWndProc(
 		    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
 
@@ -541,22 +599,20 @@ class ScintillaWin :
 	void ImeStartComposition();
 	void ImeEndComposition();
 	LRESULT ImeOnReconvert(LPARAM lParam);
-	LRESULT ImeOnDocumentFeed(LPARAM lParam) const;
+	[[nodiscard]] LRESULT ImeOnDocumentFeed(LPARAM lParam) const;
 	sptr_t HandleCompositionWindowed(uptr_t wParam, sptr_t lParam);
 	sptr_t HandleCompositionInline(uptr_t wParam, sptr_t lParam);
 	static bool KoreanIME() noexcept;
-	void MoveImeCarets(Sci::Position offset) noexcept;
-	void DrawImeIndicator(int indicator, Sci::Position len);
-	void SetCandidateWindowPos();
+	void SetCandidateWindowPos(const IMContext &imc);
 	void SelectionToHangul();
 	void EscapeHanja();
 	void ToggleHanja();
 	void AddWString(std::wstring_view wsv, CharacterSource charSource);
 
-	UINT CodePageOfDocument() const noexcept;
-	bool ValidCodePage(int codePage) const override;
-	std::string UTF8FromEncoded(std::string_view encoded) const override;
-	std::string EncodedFromUTF8(std::string_view utf8) const override;
+	[[nodiscard]] UINT CodePageOfDocument() const noexcept;
+	[[nodiscard]] bool ValidCodePage(int codePage) const override;
+	[[nodiscard]] std::string UTF8FromEncoded(std::string_view encoded) const override;
+	[[nodiscard]] std::string EncodedFromUTF8(std::string_view utf8) const override;
 
 	std::string EncodeWString(std::wstring_view wsv);
 	sptr_t DefWndProc(Message iMessage, uptr_t wParam, sptr_t lParam) override;
@@ -579,7 +635,7 @@ class ScintillaWin :
 	void SetVerticalScrollPos() override;
 	void SetHorizontalScrollPos() override;
 	void HorizontalScrollToClamped(int xPos);
-	HorizontalScrollRange GetHorizontalScrollRange() const;
+	[[nodiscard]] HorizontalScrollRange GetHorizontalScrollRange() const;
 	bool ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) override;
 	void NotifyChange() override;
 	void NotifyFocus(bool focus) override;
@@ -604,9 +660,9 @@ class ScintillaWin :
 	void FullPaint();
 	void FullPaintDC(HDC hdc);
 	bool IsCompatibleDC(HDC hOtherDC) noexcept;
-	DWORD EffectFromState(DWORD grfKeyState) const noexcept;
+	[[nodiscard]] DWORD EffectFromState(DWORD grfKeyState) const noexcept;
 
-	bool IsVisible() const noexcept;
+	[[nodiscard]] bool IsVisible() const noexcept;
 	int SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) noexcept;
 	bool GetScrollInfo(int nBar, LPSCROLLINFO lpsi) noexcept;
 	bool ChangeScrollRange(int nBar, int nMin, int nMax, UINT nPage) noexcept;
@@ -615,7 +671,7 @@ class ScintillaWin :
 	sptr_t GetText(uptr_t wParam, sptr_t lParam);
 	Window::Cursor ContextCursor(Point pt);
 	sptr_t ShowContextMenu(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
-	PRectangle GetClientRectangle() const override;
+	[[nodiscard]] PRectangle GetClientRectangle() const override;
 	void SizeWindow();
 	sptr_t MouseMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 	sptr_t KeyMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
@@ -626,6 +682,11 @@ class ScintillaWin :
 	sptr_t SciMessage(Message iMessage, uptr_t wParam, sptr_t lParam);
 
 public:
+	// Deleted so ScintillaWin objects can not be copied.
+	ScintillaWin(const ScintillaWin &) = delete;
+	ScintillaWin(ScintillaWin &&) = delete;
+	ScintillaWin &operator=(const ScintillaWin &) = delete;
+	ScintillaWin &operator=(ScintillaWin &&) = delete;
 	~ScintillaWin() override;
 
 	// Public for benefit of Scintilla_DirectFunction
@@ -651,13 +712,13 @@ class ScintillaWin :
 	static bool Register(HINSTANCE hInstance_) noexcept;
 	static bool Unregister() noexcept;
 
-	bool DragIsRectangularOK(CLIPFORMAT fmt) const noexcept {
+	[[nodiscard]] bool DragIsRectangularOK(CLIPFORMAT fmt) const noexcept {
 		return drag.rectangular && (fmt == cfColumnSelect);
 	}
 
 private:
 	// For use in creating a system caret
-	bool HasCaretSizeChanged() const noexcept;
+	[[nodiscard]] bool HasCaretSizeChanged() const noexcept;
 	BOOL CreateSystemCaret();
 	BOOL DestroySystemCaret() noexcept;
 	HBITMAP sysCaretBitmap;
@@ -830,20 +891,14 @@ HRESULT ScintillaWin::Create3D() noexcept {
 
 void ScintillaWin::CreateRenderTarget() {
 	HWND hw = MainHWND();
-	const RECT rc = GetClientRect(hw);
 
 	// Create a Direct2D render target.
-	D2D1_RENDER_TARGET_PROPERTIES drtp{};
-	drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
-	drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
-	drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
 
 	if (technology == Technology::DirectWriteDC) {
-		drtp.dpiX = 96.f;
-		drtp.dpiY = 96.f;
-		// Explicit pixel format needed.
-		drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM,
-			D2D1_ALPHA_MODE_IGNORE);
+		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
+			D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE },
+			dpiDefault, dpiDefault);
 
 		const HRESULT hr = CreateDCRenderTarget(&drtp, targets.pDCRT);
 		if (FAILED(hr)) {
@@ -868,18 +923,25 @@ void ScintillaWin::CreateRenderTarget() {
 		}
 
 	} else { // DirectWrite or DirectWriteRetain
+
+		const RECT rc = GetClientRect(hw);
+
 		const int integralDeviceScaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
-		drtp.dpiX = 96.f * integralDeviceScaleFactor;
-		drtp.dpiY = 96.f * integralDeviceScaleFactor;
-		drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN,
-			D2D1_ALPHA_MODE_UNKNOWN);
-
-		D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp{};
-		dhrtp.hwnd = hw;
-		dhrtp.pixelSize = ::GetSizeUFromRect(rc, integralDeviceScaleFactor);
-		dhrtp.presentOptions = (technology == Technology::DirectWriteRetain) ?
+		const FLOAT dpiTarget = dpiDefault * static_cast<float>(integralDeviceScaleFactor);
+
+		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
+			D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			{ DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_UNKNOWN },
+			dpiTarget, dpiTarget);
+
+		const D2D1_PRESENT_OPTIONS presentOptions = (technology == Technology::DirectWriteRetain) ?
 			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
 
+		const D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp = D2D1::HwndRenderTargetProperties(
+			hw,
+			::GetSizeUFromRect(rc, integralDeviceScaleFactor),
+			presentOptions);
+
 		const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, targets.pHwndRT);
 		if (FAILED(hr)) {
 			Platform::DebugPrintf("Failed CreateHwndRenderTarget 0x%lx\n", hr);
@@ -957,7 +1019,7 @@ HRESULT ScintillaWin::CreateSwapChain(HWND hwnd) {
 	if (FAILED(hr))
 		return hr;
 
-	// All successful so export swap chain for later presentation 
+	// All successful so export swap chain for later presentation
 	pDXGISwapChain = std::move(pSwapChain);
 	return S_OK;
 }
@@ -1000,7 +1062,7 @@ void ScintillaWin::DisplayCursor(Window::Cursor c) {
 		c = static_cast<Window::Cursor>(cursorMode);
 	}
 	if (c == Window::Cursor::reverseArrow) {
-		::SetCursor(reverseArrowCursor.Load(static_cast<UINT>(dpi * deviceScaleFactor)));
+		::SetCursor(reverseArrowCursor.Load(static_cast<UINT>(static_cast<float>(dpi) * deviceScaleFactor)));
 	} else {
 		wMain.SetCursor(c);
 	}
@@ -1134,7 +1196,7 @@ int WideCharLenFromMultiByte(UINT codePage, std::string_view sv) noexcept {
 }
 
 std::string StringEncode(std::wstring_view wsv, int codePage) {
-	const int cchMulti = wsv.length() ? MultiByteLenFromWideChar(codePage, wsv) : 0;
+	const int cchMulti = wsv.empty() ? 0 : MultiByteLenFromWideChar(codePage, wsv);
 	std::string sMulti(cchMulti, 0);
 	if (cchMulti) {
 		MultiByteFromWideChar(codePage, wsv, sMulti.data(), cchMulti);
@@ -1143,7 +1205,7 @@ std::string StringEncode(std::wstring_view wsv, int codePage) {
 }
 
 std::wstring StringDecode(std::string_view sv, int codePage) {
-	const int cchWide = sv.length() ? WideCharLenFromMultiByte(codePage, sv) : 0;
+	const int cchWide = sv.empty() ? 0 : WideCharLenFromMultiByte(codePage, sv);
 	std::wstring sWide(cchWide, 0);
 	if (cchWide) {
 		WideCharFromMultiByte(codePage, sv, sWide.data(), cchWide);
@@ -1195,20 +1257,19 @@ Sci::Position ScintillaWin::EncodedFromUTF8(const char *utf8, char *encoded) con
 			memcpy(encoded, utf8, inputLength);
 		}
 		return inputLength;
-	} else {
-		// Need to convert
-		const std::string_view utf8Input(utf8, inputLength);
-		const int charsLen = WideCharLenFromMultiByte(CpUtf8, utf8Input);
-		std::wstring characters(charsLen, L'\0');
-		WideCharFromMultiByte(CpUtf8, utf8Input, &characters[0], charsLen);
+	}
+	// Need to convert
+	const std::string_view utf8Input(utf8, inputLength);
+	const int charsLen = WideCharLenFromMultiByte(CpUtf8, utf8Input);
+	std::wstring characters(charsLen, L'\0');
+	WideCharFromMultiByte(CpUtf8, utf8Input, characters.data(), charsLen);
 
-		const int encodedLen = MultiByteLenFromWideChar(CodePageOfDocument(), characters);
-		if (encoded) {
-			MultiByteFromWideChar(CodePageOfDocument(), characters, encoded, encodedLen);
-			encoded[encodedLen] = '\0';
-		}
-		return encodedLen;
+	const int encodedLen = MultiByteLenFromWideChar(CodePageOfDocument(), characters);
+	if (encoded) {
+		MultiByteFromWideChar(CodePageOfDocument(), characters, encoded, encodedLen);
+		encoded[encodedLen] = '\0';
 	}
+	return encodedLen;
 }
 
 void ScintillaWin::SetRenderingParams([[maybe_unused]] Surface *psurf) const {
@@ -1271,25 +1332,24 @@ sptr_t ScintillaWin::WndPaint() {
 	// Redirect assertions to debug output and save current state
 	const bool assertsPopup = Platform::ShowAssertionPopUps(false);
 	paintState = PaintState::painting;
-	PAINTSTRUCT ps = {};
 
 	// Removed since this interferes with reporting other assertions as it occurs repeatedly
 	//PLATFORM_ASSERT(hRgnUpdate == NULL);
 	hRgnUpdate = ::CreateRectRgn(0, 0, 0, 0);
 	::GetUpdateRgn(MainHWND(), hRgnUpdate, FALSE);
-	::BeginPaint(MainHWND(), &ps);
-	rcPaint = PRectangle::FromInts(ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom);
-	const PRectangle rcClient = GetClientRectangle();
-	paintingAllText = BoundsContains(rcPaint, hRgnUpdate, rcClient);
-	if (!PaintDC(ps.hdc)) {
-		paintState = PaintState::abandoned;
+	{
+		Painter painter(MainHWND());
+		rcPaint = PRectangleFromRECT(painter.ps.rcPaint);
+		const PRectangle rcClient = GetClientRectangle();
+		paintingAllText = BoundsContains(rcPaint, hRgnUpdate, rcClient);
+		if (!PaintDC(painter.ps.hdc)) {
+			paintState = PaintState::abandoned;
+		}
 	}
 	if (hRgnUpdate) {
 		::DeleteRgn(hRgnUpdate);
 		hRgnUpdate = {};
 	}
-
-	::EndPaint(MainHWND(), &ps);
 	if (paintState == PaintState::abandoned) {
 		// Painting area was insufficient to cover new styling or brace highlight positions
 		FullPaint();
@@ -1306,16 +1366,11 @@ sptr_t ScintillaWin::WndPaint() {
 
 sptr_t ScintillaWin::HandleCompositionWindowed(uptr_t wParam, sptr_t lParam) {
 	if (lParam & GCS_RESULTSTR) {
-		IMContext imc(MainHWND());
-		if (imc.hIMC) {
+		if (IMContext imc{ MainHWND() }) {
 			AddWString(imc.GetCompositionString(GCS_RESULTSTR), CharacterSource::ImeResult);
 
 			// Set new position after converted
-			const Point pos = PointMainCaret();
-			COMPOSITIONFORM CompForm {};
-			CompForm.dwStyle = CFS_POINT;
-			CompForm.ptCurrentPos = POINTFromPoint(pos);
-			::ImmSetCompositionWindow(imc.hIMC, &CompForm);
+			imc.SetCompositionWindow(PointMainCaret());
 		}
 		return 0;
 	}
@@ -1324,49 +1379,11 @@ sptr_t ScintillaWin::HandleCompositionWindowed(uptr_t wParam, sptr_t lParam) {
 
 bool ScintillaWin::KoreanIME() noexcept {
 	const int codePage = InputCodePage();
-	return codePage == 949 || codePage == 1361;
+	return codePage == cp949 || codePage == cp1361;
 }
 
-void ScintillaWin::MoveImeCarets(Sci::Position offset) noexcept {
-	// Move carets relatively by bytes.
-	for (size_t r=0; r<sel.Count(); r++) {
-		const Sci::Position positionInsert = sel.Range(r).Start().Position();
-		sel.Range(r) = SelectionRange(positionInsert + offset);
-	}
-}
-
-void ScintillaWin::DrawImeIndicator(int indicator, Sci::Position len) {
-	// Emulate the visual style of IME characters with indicators.
-	// Draw an indicator on the character before caret by the character bytes of len
-	// so it should be called after InsertCharacter().
-	// It does not affect caret positions.
-	if (indicator < 8 || indicator > IndicatorMax) {
-		return;
-	}
-	pdoc->DecorationSetCurrentIndicator(indicator);
-	for (size_t r=0; r<sel.Count(); r++) {
-		const Sci::Position positionInsert = sel.Range(r).Start().Position();
-		pdoc->DecorationFillRange(positionInsert - len, 1, len);
-	}
-}
-
-void ScintillaWin::SetCandidateWindowPos() {
-	IMContext imc(MainHWND());
-	if (imc.hIMC) {
-		const Point pos = PointMainCaret();
-		const PRectangle rcClient = GetTextRectangle();
-		CANDIDATEFORM CandForm{};
-		CandForm.dwIndex = 0;
-		CandForm.dwStyle = CFS_EXCLUDE;
-		CandForm.ptCurrentPos.x = static_cast<int>(pos.x);
-		CandForm.ptCurrentPos.y = static_cast<int>(pos.y + std::max(4, vs.lineHeight/4));
-		// Exclude the area of the whole caret line
-		CandForm.rcArea.top = static_cast<int>(pos.y);
-		CandForm.rcArea.bottom = static_cast<int>(pos.y + vs.lineHeight);
-		CandForm.rcArea.left = static_cast<int>(rcClient.left);
-		CandForm.rcArea.right = static_cast<int>(rcClient.right);
-		::ImmSetCandidateWindow(imc.hIMC, &CandForm);
-	}
+void ScintillaWin::SetCandidateWindowPos(const IMContext &imc) {
+	imc.SetCandidateWindowPos(PointMainCaret(), GetTextRectangle(), vs.lineHeight);
 }
 
 void ScintillaWin::SelectionToHangul() {
@@ -1377,17 +1394,16 @@ void ScintillaWin::SelectionToHangul() {
 	const Sci::Position utf16Len = pdoc->CountUTF16(selStart, selEnd);
 
 	if (utf16Len > 0) {
-		std::string documentStr(documentStrLen, '\0');
-		pdoc->GetCharRange(&documentStr[0], selStart, documentStrLen);
+		const std::string documentStr = RangeText(selStart, selStart + documentStrLen);
 
 		std::wstring uniStr = StringDecode(documentStr, CodePageOfDocument());
 		const bool converted = HanjaDict::GetHangulOfHanja(uniStr);
 
 		if (converted) {
-			documentStr = StringEncode(uniStr, CodePageOfDocument());
+			const std::string hangul = StringEncode(uniStr, CodePageOfDocument());
 			UndoGroup ug(pdoc);
 			ClearSelection();
-			InsertPaste(&documentStr[0], documentStr.size());
+			InsertPaste(hangul.data(), hangul.size());
 		}
 	}
 }
@@ -1396,9 +1412,7 @@ void ScintillaWin::EscapeHanja() {
 	// The candidate box pops up to user to select a hanja.
 	// It comes into WM_IME_COMPOSITION with GCS_RESULTSTR.
 	// The existing hangul or hanja is replaced with it.
-	if (sel.Count() > 1) {
-		return; // Do not allow multi carets.
-	}
+
 	const Sci::Position currentPos = CurrentPosition();
 	const int oneCharLen = pdoc->LenChar(currentPos);
 
@@ -1406,20 +1420,18 @@ void ScintillaWin::EscapeHanja() {
 		return; // No need to handle SBCS.
 	}
 
-	// ImmEscapeW() may overwrite uniChar[] with a null terminated string.
-	// So enlarge it enough to Maximum 4 as in UTF-8.
-	constexpr size_t safeLength = UTF8MaxBytes + 1;
-	std::string oneChar(safeLength, '\0');
-	pdoc->GetCharRange(&oneChar[0], currentPos, oneCharLen);
+	const std::string oneChar = RangeText(currentPos, currentPos + oneCharLen);
 
 	std::wstring uniChar = StringDecode(oneChar, CodePageOfDocument());
+	// ImmEscapeW() may overwrite uniChar[] with a null terminated string.
+	// So enlarge it enough to Maximum 4 as in UTF-8.
+	uniChar.resize(UTF8MaxBytes);
 
-	IMContext imc(MainHWND());
-	if (imc.hIMC) {
+	if (IMContext imc{ MainHWND() }) {
 		// Set the candidate box position since IME may show it.
-		SetCandidateWindowPos();
+		SetCandidateWindowPos(imc);
 		// IME_ESC_HANJA_MODE appears to receive the first character only.
-		if (::ImmEscapeW(GetKeyboardLayout(0), imc.hIMC, IME_ESC_HANJA_MODE, &uniChar[0])) {
+		if (imc.Escape(GetKeyboardLayout(0), IME_ESC_HANJA_MODE, uniChar.data())) {
 			SetSelection(currentPos, currentPos + oneCharLen);
 		}
 	}
@@ -1484,10 +1496,10 @@ sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
 	// Great thanks for my foreruners, jiniya and BLUEnLIVE.
 
 	IMContext imc(MainHWND());
-	if (!imc.hIMC)
+	if (!imc)
 		return 0;
 	if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
-		::ImmNotifyIME(imc.hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
+		imc.Notify(false);
 		return 0;
 	}
 
@@ -1519,7 +1531,7 @@ sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
 		}
 
 		// Set candidate window left aligned to beginning of preedit string.
-		SetCandidateWindowPos();
+		SetCandidateWindowPos(imc);
 		pdoc->TentativeStart(); // TentativeActive from now on.
 
 		std::vector<int> imeIndicator = MapImeIndicators(imc.GetImeAttributes());
@@ -1598,10 +1610,19 @@ Message SciMessageFromEM(unsigned int iMessage) noexcept {
 	return static_cast<Message>(iMessage);
 }
 
+constexpr bool IsVisualCharacter(wchar_t charCode) noexcept {
+	constexpr wchar_t lastAscii = INT8_MAX;
+	return (charCode > lastAscii) || !IsControl(charCode);
+}
+
 }
 
 namespace Scintilla::Internal {
 
+// Removing 'magic' numbers here would not help here.
+
+// NOLINTBEGIN(*-magic-numbers)
+
 UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept {
 	if (documentCodePage == CpUtf8) {
 		return CpUtf8;
@@ -1634,6 +1655,8 @@ UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexc
 	return documentCodePage;
 }
 
+// NOLINTEND(*-magic-numbers)
+
 }
 
 UINT ScintillaWin::CodePageOfDocument() const noexcept {
@@ -1646,30 +1669,28 @@ std::string ScintillaWin::EncodeWString(std::wstring_view wsv) {
 		std::string putf(len, 0);
 		UTF8FromUTF16(wsv, putf.data(), len);
 		return putf;
-	} else {
-		// Not in Unicode mode so convert from Unicode to current Scintilla code page
-		return StringEncode(wsv, CodePageOfDocument());
 	}
+	// Not in Unicode mode so convert from Unicode to current Scintilla code page
+	return StringEncode(wsv, CodePageOfDocument());
 }
 
 sptr_t ScintillaWin::GetTextLength() {
 	if (pdoc->dbcsCodePage == 0 || pdoc->dbcsCodePage == CpUtf8) {
 		return pdoc->CountUTF16(0, pdoc->Length());
-	} else {
-		// Count the number of UTF-16 code units line by line
-		const UINT cpSrc = CodePageOfDocument();
-		const Sci::Line lines = pdoc->LinesTotal();
-		Sci::Position codeUnits = 0;
-		std::string lineBytes;
-		for (Sci::Line line = 0; line < lines; line++) {
-			const Sci::Position start = pdoc->LineStart(line);
-			const Sci::Position width = pdoc->LineStart(line+1) - start;
-			lineBytes.resize(width);
-			pdoc->GetCharRange(lineBytes.data(), start, width);
-			codeUnits += WideCharLenFromMultiByte(cpSrc, lineBytes);
-		}
-		return codeUnits;
 	}
+	// Count the number of UTF-16 code units line by line
+	const UINT cpSrc = CodePageOfDocument();
+	const Sci::Line lines = pdoc->LinesTotal();
+	Sci::Position codeUnits = 0;
+	std::string lineBytes;
+	for (Sci::Line line = 0; line < lines; line++) {
+		const Sci::Position start = pdoc->LineStart(line);
+		const Sci::Position width = pdoc->LineStart(line+1) - start;
+		lineBytes.resize(width);
+		pdoc->GetCharRange(lineBytes.data(), start, width);
+		codeUnits += WideCharLenFromMultiByte(cpSrc, lineBytes);
+	}
+	return codeUnits;
 }
 
 sptr_t ScintillaWin::GetText(uptr_t wParam, sptr_t lParam) {
@@ -1692,53 +1713,51 @@ sptr_t ScintillaWin::GetText(uptr_t wParam, sptr_t lParam) {
 			sizeRequestedRange = pdoc->Length();
 		}
 		std::string docBytes(sizeRequestedRange, '\0');
-		pdoc->GetCharRange(&docBytes[0], 0, sizeRequestedRange);
+		pdoc->GetCharRange(docBytes.data(), 0, sizeRequestedRange);
 		const size_t uLen = UTF16FromUTF8(docBytes, ptr, lengthWanted);
 		ptr[uLen] = L'\0';
 		return uLen;
-	} else {
-		// Not Unicode mode
-		// Convert to Unicode using the current Scintilla code page
-		// Retrieve as UTF-16 line by line
-		const UINT cpSrc = CodePageOfDocument();
-		const Sci::Line lines = pdoc->LinesTotal();
-		Sci::Position codeUnits = 0;
-		std::string lineBytes;
-		std::wstring lineAsUTF16;
-		for (Sci::Line line = 0; line < lines && codeUnits < lengthWanted; line++) {
-			const Sci::Position start = pdoc->LineStart(line);
-			const Sci::Position width = pdoc->LineStart(line + 1) - start;
-			lineBytes.resize(width);
-			pdoc->GetCharRange(lineBytes.data(), start, width);
-			const Sci::Position codeUnitsLine = WideCharLenFromMultiByte(cpSrc, lineBytes);
-			lineAsUTF16.resize(codeUnitsLine);
-			const Sci::Position lengthLeft = lengthWanted - codeUnits;
-			WideCharFromMultiByte(cpSrc, lineBytes, lineAsUTF16.data(), lineAsUTF16.length());
-			const Sci::Position lengthToCopy = std::min(lengthLeft, codeUnitsLine);
-			lineAsUTF16.copy(ptr + codeUnits, lengthToCopy);
-			codeUnits += lengthToCopy;
-		}
-		ptr[codeUnits] = L'\0';
-		return codeUnits;
 	}
+	// Not Unicode mode
+	// Convert to Unicode using the current Scintilla code page
+	// Retrieve as UTF-16 line by line
+	const UINT cpSrc = CodePageOfDocument();
+	const Sci::Line lines = pdoc->LinesTotal();
+	Sci::Position codeUnits = 0;
+	std::string lineBytes;
+	std::wstring lineAsUTF16;
+	for (Sci::Line line = 0; line < lines && codeUnits < lengthWanted; line++) {
+		const Sci::Position start = pdoc->LineStart(line);
+		const Sci::Position width = pdoc->LineStart(line + 1) - start;
+		lineBytes.resize(width);
+		pdoc->GetCharRange(lineBytes.data(), start, width);
+		const Sci::Position codeUnitsLine = WideCharLenFromMultiByte(cpSrc, lineBytes);
+		lineAsUTF16.resize(codeUnitsLine);
+		const Sci::Position lengthLeft = lengthWanted - codeUnits;
+		WideCharFromMultiByte(cpSrc, lineBytes, lineAsUTF16.data(), lineAsUTF16.length());
+		const Sci::Position lengthToCopy = std::min(lengthLeft, codeUnitsLine);
+		lineAsUTF16.copy(ptr + codeUnits, lengthToCopy);
+		codeUnits += lengthToCopy;
+	}
+	ptr[codeUnits] = L'\0';
+	return codeUnits;
 }
 
 Window::Cursor ScintillaWin::ContextCursor(Point pt) {
 	if (inDragDrop == DragDrop::dragging) {
 		return Window::Cursor::up;
-	} else {
-		// Display regular (drag) cursor over selection
-		if (PointInSelMargin(pt)) {
-			return GetMarginCursor(pt);
-		} else if (!SelectionEmpty() && PointInSelection(pt)) {
-			return Window::Cursor::arrow;
-		} else if (PointIsHotspot(pt)) {
+	}
+	// Display regular (drag) cursor over selection
+	if (PointInSelMargin(pt)) {
+		return GetMarginCursor(pt);
+	} else if (!SelectionEmpty() && PointInSelection(pt)) {
+		return Window::Cursor::arrow;
+	} else if (PointIsHotspot(pt)) {
+		return Window::Cursor::hand;
+	} else if (hoverIndicatorPos != Sci::invalidPosition) {
+		const Sci::Position pos = PositionFromLocation(pt, true, true);
+		if (pos != Sci::invalidPosition) {
 			return Window::Cursor::hand;
-		} else if (hoverIndicatorPos != Sci::invalidPosition) {
-			const Sci::Position pos = PositionFromLocation(pt, true, true);
-			if (pos != Sci::invalidPosition) {
-				return Window::Cursor::hand;
-			}
 		}
 	}
 	return Window::Cursor::text;
@@ -1784,7 +1803,7 @@ void ScintillaWin::SizeWindow() {
 	}
 	if ((technology == Technology::DirectWrite1) && pDXGISwapChain && targets.pDeviceContext &&
 		(paintState == PaintState::notPainting)) {
-		targets.pDeviceContext->SetTarget(NULL);	// ResizeBuffers fails if bitmap still owned by swap chain
+		targets.pDeviceContext->SetTarget(nullptr);	// ResizeBuffers fails if bitmap still owned by swap chain
 		hrResize = pDXGISwapChain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
 		if (SUCCEEDED(hrResize)) {
 			hrResize = SetBackBuffer(MainHWND(), pDXGISwapChain.Get());
@@ -1806,21 +1825,14 @@ void ScintillaWin::SizeWindow() {
 
 sptr_t ScintillaWin::MouseMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	switch (iMessage) {
-	case WM_LBUTTONDOWN: {
-			// For IME, set the composition string as the result string.
-			IMContext imc(MainHWND());
-			if (imc.hIMC) {
-				::ImmNotifyIME(imc.hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
-			}
-			//
-			//Platform::DebugPrintf("Buttdown %d %x %x %x %x %x\n",iMessage, wParam, lParam,
-			//	KeyboardIsKeyDown(VK_SHIFT),
-			//	KeyboardIsKeyDown(VK_CONTROL),
-			//	KeyboardIsKeyDown(VK_MENU));
-			::SetFocus(MainHWND());
-			ButtonDownWithModifiers(PointFromLParam(lParam), ::GetMessageTime(),
-						MouseModifiers(wParam));
+	case WM_LBUTTONDOWN:
+		// For IME, set the composition string as the result string.
+		if (IMContext imc{ MainHWND() }) {
+			imc.Notify(true);
 		}
+		::SetFocus(MainHWND());
+		ButtonDownWithModifiers(PointFromLParam(lParam), ::GetMessageTime(),
+					MouseModifiers(wParam));
 		break;
 
 	case WM_LBUTTONUP:
@@ -1961,20 +1973,19 @@ sptr_t ScintillaWin::KeyMessage(unsigned int iMessage, uptr_t wParam, sptr_t lPa
 
 	case WM_CHAR:
 		HideCursorIfPreferred();
-		if (((wParam >= 128) || !iscntrl(static_cast<int>(wParam))) || !lastKeyDownConsumed) {
-			wchar_t wcs[3] = { static_cast<wchar_t>(wParam), 0 };
-			unsigned int wclen = 1;
-			if (IS_HIGH_SURROGATE(wcs[0])) {
+		if (const wchar_t charCode = static_cast<wchar_t>(wParam);
+			IsVisualCharacter(charCode) || !lastKeyDownConsumed) {
+			if (IS_HIGH_SURROGATE(charCode)) {
 				// If this is a high surrogate character, we need a second one
-				lastHighSurrogateChar = wcs[0];
-				return 0;
-			} else if (IS_LOW_SURROGATE(wcs[0])) {
-				wcs[1] = wcs[0];
-				wcs[0] = lastHighSurrogateChar;
+				lastHighSurrogateChar = charCode;
+			} else {
+				std::wstring wcs({ charCode });
+				if (IS_LOW_SURROGATE(charCode)) {
+					wcs.insert(wcs.begin(), lastHighSurrogateChar);
+				}
+				AddWString(wcs, CharacterSource::DirectInput);
 				lastHighSurrogateChar = 0;
-				wclen = 2;
 			}
-			AddWString(std::wstring_view(wcs, wclen), CharacterSource::DirectInput);
 		}
 		return 0;
 
@@ -2006,9 +2017,8 @@ sptr_t ScintillaWin::FocusMessage(unsigned int iMessage, uptr_t wParam, sptr_t)
 			DestroySystemCaret();
 		}
 		// Explicitly complete any IME composition
-		IMContext imc(MainHWND());
-		if (imc.hIMC) {
-			::ImmNotifyIME(imc.hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
+		if (IMContext imc{ MainHWND() }) {
+			imc.Notify(true);
 		}
 		break;
 	}
@@ -2033,6 +2043,7 @@ sptr_t ScintillaWin::IMEMessage(unsigned int iMessage, uptr_t wParam, sptr_t lPa
 
 	case WM_IME_KEYDOWN: {
 			if (wParam == VK_HANJA) {
+				// On US keyboards with Korean Microsoft IME, VK_HANJA is right Ctrl
 				ToggleHanja();
 			}
 			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
@@ -2098,10 +2109,10 @@ sptr_t ScintillaWin::EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lP
 
 	case EM_GETSEL:
 		if (wParam) {
-			*reinterpret_cast<DWORD *>(wParam) = static_cast<DWORD>(SelectionStart().Position());
+			*static_cast<DWORD *>(PtrFromUPtr(wParam)) = static_cast<DWORD>(SelectionStart().Position());
 		}
 		if (lParam) {
-			*reinterpret_cast<DWORD *>(lParam) = static_cast<DWORD>(SelectionEnd().Position());
+			*static_cast<DWORD *>(PtrFromSPtr(lParam)) = static_cast<DWORD>(SelectionEnd().Position());
 		}
 		return MAKELRESULT(SelectionStart().Position(), SelectionEnd().Position());
 
@@ -2109,7 +2120,7 @@ sptr_t ScintillaWin::EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lP
 			if (lParam == 0) {
 				return 0;
 			}
-			CHARRANGE *pCR = reinterpret_cast<CHARRANGE *>(lParam);
+			CHARRANGE *pCR = static_cast<CHARRANGE *>(PtrFromSPtr(lParam));
 			pCR->cpMin = static_cast<LONG>(SelectionStart().Position());
 			pCR->cpMax = static_cast<LONG>(SelectionEnd().Position());
 		}
@@ -2133,7 +2144,7 @@ sptr_t ScintillaWin::EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lP
 			if (lParam == 0) {
 				return 0;
 			}
-			const CHARRANGE *pCR = reinterpret_cast<const CHARRANGE *>(lParam);
+			const CHARRANGE *pCR = static_cast<const CHARRANGE *>(PtrFromSPtr(lParam));
 			sel.selType = Selection::SelTypes::stream;
 			if (pCR->cpMin == 0 && pCR->cpMax == -1) {
 				SetSelection(pCR->cpMin, pdoc->Length());
@@ -2487,29 +2498,25 @@ sptr_t ScintillaWin::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 }
 
 bool ScintillaWin::ValidCodePage(int codePage) const {
-	return codePage == 0 || codePage == CpUtf8 ||
-	       codePage == 932 || codePage == 936 || codePage == 949 ||
-	       codePage == 950 || codePage == 1361;
+	return codePage == 0 || codePage == CpUtf8 || IsDBCSCodePage(codePage);
 }
 
 std::string ScintillaWin::UTF8FromEncoded(std::string_view encoded) const {
 	if (IsUnicodeMode()) {
 		return std::string(encoded);
-	} else {
-		// Pivot through wide string
-		std::wstring ws = StringDecode(encoded, CodePageOfDocument());
-		return StringEncode(ws, CpUtf8);
 	}
+	// Pivot through wide string
+	std::wstring ws = StringDecode(encoded, CodePageOfDocument());
+	return StringEncode(ws, CpUtf8);
 }
 
 std::string ScintillaWin::EncodedFromUTF8(std::string_view utf8) const {
 	if (IsUnicodeMode()) {
 		return std::string(utf8);
-	} else {
-		// Pivot through wide string
-		std::wstring ws = StringDecode(utf8, CpUtf8);
-		return StringEncode(ws, CodePageOfDocument());
 	}
+	// Pivot through wide string
+	std::wstring ws = StringDecode(utf8, CpUtf8);
+	return StringEncode(ws, CodePageOfDocument());
 }
 
 sptr_t ScintillaWin::DefWndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
@@ -2546,13 +2553,14 @@ bool ScintillaWin::SetIdle(bool on) {
 	// and are only posted when the message queue is empty, i.e. during idle time.
 	if (idler.state != on) {
 		if (on) {
-			idler.idlerID = ::SetTimer(MainHWND(), idleTimerID, 10, nullptr)
-				? reinterpret_cast<IdlerID>(idleTimerID) : 0;
+			constexpr UINT waitTimeMillis = 10;
+			idler.idlerID = ::SetTimer(MainHWND(), idleTimerID, waitTimeMillis, nullptr)
+				? reinterpret_cast<IdlerID>(idleTimerID) : nullptr;
 		} else {
 			::KillTimer(MainHWND(), reinterpret_cast<uptr_t>(idler.idlerID));
-			idler.idlerID = 0;
+			idler.idlerID = nullptr;
 		}
-		idler.state = idler.idlerID != 0;
+		idler.state = idler.idlerID != nullptr;
 	}
 	return idler.state;
 }
@@ -2603,7 +2611,7 @@ void ScintillaWin::SetTrackMouseLeaveEvent(bool on) noexcept {
 void ScintillaWin::HideCursorIfPreferred() noexcept {
 	// SPI_GETMOUSEVANISH from OS.
 	if (typingWithoutCursor && !cursorIsHidden) {
-		::SetCursor(NULL);
+		::SetCursor({});
 		cursorIsHidden = true;
 	}
 }
@@ -2618,7 +2626,7 @@ void ScintillaWin::UpdateBaseElements() {
 	};
 	bool changed = false;
 	for (const ElementToIndex &ei : eti) {
-		changed = vs.SetElementBase(ei.element, ColourRGBA::FromRGB(static_cast<int>(::GetSysColor(ei.nIndex)))) || changed;
+		changed = vs.SetElementBase(ei.element, ColourFromSys(ei.nIndex)) || changed;
 	}
 	if (changed) {
 		Redraw();
@@ -2670,7 +2678,7 @@ int ScintillaWin::SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) noex
 }
 
 bool ScintillaWin::GetScrollInfo(int nBar, LPSCROLLINFO lpsi) noexcept {
-	return ::GetScrollInfo(MainHWND(), nBar, lpsi) ? true : false;
+	return ::GetScrollInfo(MainHWND(), nBar, lpsi);
 }
 
 // Change the scroll position but avoid repaint if changing to same value
@@ -2692,6 +2700,7 @@ void ScintillaWin::ChangeScrollPos(int barType, Sci::Position pos) {
 }
 
 void ScintillaWin::SetVerticalScrollPos() {
+	Editor::SetVerticalScrollPos();
 	ChangeScrollPos(SB_VERT, topLine);
 }
 
@@ -2792,63 +2801,85 @@ void ScintillaWin::NotifyDoubleClick(Point pt, KeyMod modifiers) {
 
 namespace {
 
+constexpr unsigned int safeFoldingSize = 20;
+constexpr int highByteFirst = 0x80;
+constexpr int highByteLast = 0xFF;
+constexpr int minTrailByte = 0x30;
+
+// CreateFoldMap creates a fold map by calling platform APIs so will differ between platforms.
+void CreateFoldMap(int codePage, FoldMap *foldingMap) {
+	for (unsigned char byte1 = highByteLast; byte1 >= highByteFirst; byte1--) {
+		const char ch1 = byte1;
+		if (DBCSIsLeadByte(codePage, ch1)) {
+			for (unsigned char byte2 = highByteLast; byte2 >= minTrailByte; byte2--) {
+				const char ch2 = byte2;
+				if (DBCSIsTrailByte(codePage, ch2)) {
+					const DBCSPair pair{ ch1, ch2 };
+					const uint16_t index = DBCSIndex(ch1, ch2);
+					(*foldingMap)[index] = pair;
+					const std::string_view svBytes(pair.chars, 2);
+					const int lenUni = WideCharLenFromMultiByte(codePage, svBytes);
+					if (lenUni == 1) {
+						// DBCS pair must produce a single Unicode BMP code point
+						wchar_t codePoint = 0;
+						WideCharFromMultiByte(codePage, svBytes, &codePoint, 1);
+						if (codePoint) {
+							// Could create a DBCS -> Unicode conversion map here
+							const char *foldedUTF8 = CaseConvert(codePoint, CaseConversion::fold);
+							if (foldedUTF8) {
+								wchar_t wFolded[safeFoldingSize]{};
+								const size_t charsConverted = UTF16FromUTF8(foldedUTF8, wFolded, std::size(wFolded));
+								char back[safeFoldingSize]{};
+								const int lengthBack = MultiByteFromWideChar(codePage, std::wstring(wFolded, charsConverted),
+									back, std::size(back));
+								if (lengthBack == 2) {
+									// Only allow cases where input length and folded length are both 2
+									(*foldingMap)[index] = { back[0], back[1] };
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
 class CaseFolderDBCS : public CaseFolderTable {
 	// Allocate the expandable storage here so that it does not need to be reallocated
 	// for each call to Fold.
-	std::vector<wchar_t> utf16Mixed;
-	std::vector<wchar_t> utf16Folded;
+	const FoldMap *foldingMap;
 	UINT cp;
 public:
 	explicit CaseFolderDBCS(UINT cp_) : cp(cp_) {
+		if (!DBCSHasFoldMap(cp)) {
+			CreateFoldMap(cp, DBCSGetMutableFoldMap(cp));
+		}
+		foldingMap = DBCSGetFoldMap(cp);
 	}
-	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override {
-		if ((lenMixed == 1) && (sizeFolded > 0)) {
-			folded[0] = mapping[static_cast<unsigned char>(mixed[0])];
-			return 1;
-		} else {
-			if (lenMixed > utf16Mixed.size()) {
-				utf16Mixed.resize(lenMixed + 8);
-			}
-			const size_t nUtf16Mixed = WideCharFromMultiByte(cp,
-				std::string_view(mixed, lenMixed),
-				&utf16Mixed[0],
-				utf16Mixed.size());
-
-			if (nUtf16Mixed == 0) {
-				// Failed to convert -> bad input
-				folded[0] = '\0';
-				return 1;
-			}
-
-			size_t lenFlat = 0;
-			for (size_t mixIndex=0; mixIndex < nUtf16Mixed; mixIndex++) {
-				if ((lenFlat + 20) > utf16Folded.size())
-					utf16Folded.resize(lenFlat + 60);
-				const char *foldedUTF8 = CaseConvert(utf16Mixed[mixIndex], CaseConversion::fold);
-				if (foldedUTF8) {
-					// Maximum length of a case conversion is 6 bytes, 3 characters
-					wchar_t wFolded[20];
-					const size_t charsConverted = UTF16FromUTF8(std::string_view(foldedUTF8),
-							wFolded, std::size(wFolded));
-					for (size_t j=0; j<charsConverted; j++)
-						utf16Folded[lenFlat++] = wFolded[j];
-				} else {
-					utf16Folded[lenFlat++] = utf16Mixed[mixIndex];
-				}
-			}
-
-			const std::wstring_view wsvFolded(&utf16Folded[0], lenFlat);
-			const size_t lenOut = MultiByteLenFromWideChar(cp, wsvFolded);
+	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
+};
 
-			if (lenOut < sizeFolded) {
-				MultiByteFromWideChar(cp, wsvFolded, folded, lenOut);
-				return lenOut;
-			} else {
-				return 0;
-			}
+size_t CaseFolderDBCS::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
+	// This loop outputs the same length as input as for each char 1-byte -> 1-byte; 2-byte -> 2-byte
+	size_t lenOut = 0;
+	for (size_t i = 0; i < lenMixed; i++) {
+		const ptrdiff_t lenLeft = lenMixed - i;
+		const char ch = mixed[i];
+		if ((lenLeft >= 2) && DBCSIsLeadByte(cp, ch) && ((lenOut + 2) <= sizeFolded)) {
+			i++;
+			const char ch2 = mixed[i];
+			const uint16_t ind = DBCSIndex(ch, ch2);
+			const char *pair = foldingMap->at(ind).chars;
+			folded[lenOut++] = pair[0];
+			folded[lenOut++] = pair[1];
+		} else if ((lenOut + 1) <= sizeFolded) {
+			const unsigned char uch = ch;
+			folded[lenOut++] = mapping[uch];
 		}
 	}
-};
+	return lenOut;
+}
 
 }
 
@@ -2856,43 +2887,41 @@ std::unique_ptr<CaseFolder> ScintillaWin::CaseFolderForEncoding() {
 	const UINT cpDest = CodePageOfDocument();
 	if (cpDest == CpUtf8) {
 		return std::make_unique<CaseFolderUnicode>();
-	} else {
-		if (pdoc->dbcsCodePage == 0) {
-			std::unique_ptr<CaseFolderTable> pcf = std::make_unique<CaseFolderTable>();
-			// Only for single byte encodings
-			for (int i=0x80; i<0x100; i++) {
-				char sCharacter[2] = "A";
-				sCharacter[0] = static_cast<char>(i);
-				wchar_t wCharacter[20];
-				const unsigned int lengthUTF16 = WideCharFromMultiByte(cpDest, sCharacter,
-					wCharacter, std::size(wCharacter));
-				if (lengthUTF16 == 1) {
-					const char *caseFolded = CaseConvert(wCharacter[0], CaseConversion::fold);
-					if (caseFolded) {
-						wchar_t wLower[20];
-						const size_t charsConverted = UTF16FromUTF8(std::string_view(caseFolded),
-							wLower, std::size(wLower));
-						if (charsConverted == 1) {
-							char sCharacterLowered[20];
-							const unsigned int lengthConverted = MultiByteFromWideChar(cpDest,
-								std::wstring_view(wLower, charsConverted),
-								sCharacterLowered, std::size(sCharacterLowered));
-							if ((lengthConverted == 1) && (sCharacter[0] != sCharacterLowered[0])) {
-								pcf->SetTranslation(sCharacter[0], sCharacterLowered[0]);
-							}
-						}
+	}
+	if (pdoc->dbcsCodePage) {
+		return std::make_unique<CaseFolderDBCS>(cpDest);
+	}
+	std::unique_ptr<CaseFolderTable> pcf = std::make_unique<CaseFolderTable>();
+	// Only for single byte encodings
+	for (int i=highByteFirst; i<=highByteLast; i++) {
+		char sCharacter[2] = "A";
+		sCharacter[0] = static_cast<char>(i);
+		wchar_t wCharacter[safeFoldingSize];
+		const unsigned int lengthUTF16 = WideCharFromMultiByte(cpDest, sCharacter,
+			wCharacter, std::size(wCharacter));
+		if (lengthUTF16 == 1) {
+			const char *caseFolded = CaseConvert(wCharacter[0], CaseConversion::fold);
+			if (caseFolded) {
+				wchar_t wLower[safeFoldingSize];
+				const size_t charsConverted = UTF16FromUTF8(std::string_view(caseFolded),
+					wLower, std::size(wLower));
+				if (charsConverted == 1) {
+					char sCharacterLowered[safeFoldingSize];
+					const unsigned int lengthConverted = MultiByteFromWideChar(cpDest,
+						std::wstring_view(wLower, charsConverted),
+						sCharacterLowered, std::size(sCharacterLowered));
+					if ((lengthConverted == 1) && (sCharacter[0] != sCharacterLowered[0])) {
+						pcf->SetTranslation(sCharacter[0], sCharacterLowered[0]);
 					}
 				}
 			}
-			return pcf;
-		} else {
-			return std::make_unique<CaseFolderDBCS>(cpDest);
 		}
 	}
+	return pcf;
 }
 
 std::string ScintillaWin::CaseMapString(const std::string &s, CaseMapping caseMapping) {
-	if ((s.size() == 0) || (caseMapping == CaseMapping::same))
+	if (s.empty() || (caseMapping == CaseMapping::same))
 		return s;
 
 	const UINT cpDoc = CodePageOfDocument();
@@ -2936,8 +2965,7 @@ class GlobalMemory {
 	HGLOBAL hand {};
 public:
 	void *ptr {};
-	GlobalMemory() noexcept {
-	}
+	GlobalMemory() noexcept = default;
 	explicit GlobalMemory(HGLOBAL hand_) noexcept : hand(hand_) {
 		if (hand) {
 			ptr = ::GlobalLock(hand);
@@ -2970,10 +2998,10 @@ class GlobalMemory {
 	void SetClip(UINT uFormat) noexcept {
 		::SetClipboardData(uFormat, Unlock());
 	}
-	operator bool() const noexcept {
+	explicit operator bool() const noexcept {
 		return ptr != nullptr;
 	}
-	SIZE_T Size() const noexcept {
+	[[nodiscard]] SIZE_T Size() const noexcept {
 		return ::GlobalSize(hand);
 	}
 };
@@ -2982,7 +3010,8 @@ class GlobalMemory {
 // Try up to 8 times, with an initial delay of 1 ms and an exponential back off
 // for a maximum total delay of 127 ms (1+2+4+8+16+32+64).
 bool OpenClipboardRetry(HWND hwnd) noexcept {
-	for (int attempt=0; attempt<8; attempt++) {
+	constexpr int attempts = 8;
+	for (int attempt=0; attempt<attempts; attempt++) {
 		if (attempt > 0) {
 			::Sleep(1 << (attempt-1));
 		}
@@ -2997,7 +3026,7 @@ bool OpenClipboardRetry(HWND hwnd) noexcept {
 class Clipboard {
 	bool opened = false;
 public:
-	Clipboard(HWND hwnd) noexcept : opened(::OpenClipboardRetry(hwnd)) {
+	explicit Clipboard(HWND hwnd) noexcept : opened(::OpenClipboardRetry(hwnd)) {
 	}
 	// Deleted so Clipboard objects can not be copied.
 	Clipboard(const Clipboard &) = delete;
@@ -3009,7 +3038,7 @@ class Clipboard {
 			::CloseClipboard();
 		}
 	}
-	constexpr operator bool() const noexcept {
+	explicit constexpr operator bool() const noexcept {
 		return opened;
 	}
 };
@@ -3063,7 +3092,7 @@ void ScintillaWin::CreateCallTipWindow(PRectangle) {
 	if (!ct.wCallTip.Created()) {
 		HWND wnd = ::CreateWindow(callClassName, TEXT("ACallTip"),
 					     WS_POPUP, 100, 100, 150, 20,
-					     MainHWND(), 0,
+					     MainHWND(), {},
 					     GetWindowInstance(MainHWND()),
 					     this);
 		ct.wCallTip = wnd;
@@ -3136,7 +3165,7 @@ STDMETHODIMP FormatEnumerator::Reset() {
 STDMETHODIMP FormatEnumerator::Clone(IEnumFORMATETC **ppenum) {
 	FormatEnumerator *pfe;
 	try {
-		pfe = new FormatEnumerator(pos, &formats[0], formats.size());
+		pfe = new FormatEnumerator(pos, formats.data(), formats.size());
 	} catch (...) {
 		return E_OUTOFMEMORY;
 	}
@@ -3199,11 +3228,7 @@ STDMETHODIMP DataObject::QueryGetData(FORMATETC *pFE) {
 		return S_OK;
 	}
 
-	if (SupportedFormat(pFE)) {
-		return S_OK;
-	} else {
-		return S_FALSE;
-	}
+	return SupportedFormat(pFE) ? S_OK : S_FALSE;
 }
 
 STDMETHODIMP DataObject::GetCanonicalFormatEtc(FORMATETC *, FORMATETC *pFEOut) {
@@ -3310,34 +3335,16 @@ void ScintillaWin::ImeStartComposition() {
 	if (caret.active) {
 		// Move IME Window to current caret position
 		IMContext imc(MainHWND());
-		const Point pos = PointMainCaret();
-		COMPOSITIONFORM CompForm {};
-		CompForm.dwStyle = CFS_POINT;
-		CompForm.ptCurrentPos = POINTFromPoint(pos);
+		if (!imc)
+			return;
 
-		::ImmSetCompositionWindow(imc.hIMC, &CompForm);
+		imc.SetCompositionWindow(PointMainCaret());
 
 		// Set font of IME window to same as surrounded text.
 		if (stylesValid) {
 			// Since the style creation code has been made platform independent,
 			// The logfont for the IME is recreated here.
-			const int styleHere = pdoc->StyleIndexAt(sel.MainCaret());
-			LOGFONTW lf = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, L""};
-			int sizeZoomed = vs.styles[styleHere].size + vs.zoomLevel * FontSizeMultiplier;
-			if (sizeZoomed <= 2 * FontSizeMultiplier)	// Hangs if sizeZoomed <= 1
-				sizeZoomed = 2 * FontSizeMultiplier;
-			// The negative is to allow for leading
-			lf.lfHeight = -::MulDiv(sizeZoomed, dpi, 72*FontSizeMultiplier);
-			lf.lfWeight = static_cast<LONG>(vs.styles[styleHere].weight);
-			lf.lfItalic = vs.styles[styleHere].italic ? 1 : 0;
-			lf.lfCharSet = DEFAULT_CHARSET;
-			lf.lfFaceName[0] = L'\0';
-			if (vs.styles[styleHere].fontName) {
-				const char* fontName = vs.styles[styleHere].fontName;
-				UTF16FromUTF8(std::string_view(fontName), lf.lfFaceName, LF_FACESIZE);
-			}
-
-			::ImmSetCompositionFontW(imc.hIMC, &lf);
+			imc.SetCompositionFont(vs, pdoc->StyleIndexAt(sel.MainCaret()), dpi);
 		}
 		// Caret is displayed in IME window. So, caret in Scintilla is useless.
 		DropCaret();
@@ -3375,7 +3382,7 @@ LRESULT ScintillaWin::ImeOnReconvert(LPARAM lParam) {
 		return rcSize; // Immediately be back with rcSize of memory block.
 
 	wchar_t *rcFeedStart = reinterpret_cast<wchar_t*>(rc + 1);
-	memcpy(rcFeedStart, &rcFeed[0], rcFeedLen);
+	memcpy(rcFeedStart, rcFeed.data(), rcFeedLen);
 
 	std::string rcCompString = RangeText(mainStart, mainEnd);
 	std::wstring rcCompWstring = StringDecode(rcCompString, codePage);
@@ -3393,15 +3400,15 @@ LRESULT ScintillaWin::ImeOnReconvert(LPARAM lParam) {
 	rc->dwTargetStrOffset =rc->dwCompStrOffset;
 
 	IMContext imc(MainHWND());
-	if (!imc.hIMC)
+	if (!imc)
 		return 0;
 
-	if (!::ImmSetCompositionStringW(imc.hIMC, SCS_QUERYRECONVERTSTRING, rc, rcSize, nullptr, 0))
+	if (!imc.SetCompositionString(SCS_QUERYRECONVERTSTRING, rc, rcSize))
 		return 0;
 
 	// No selection asks IME to fill target fields with its own value.
-	const int tgWlen = rc->dwTargetStrLen;
-	const int tgWstart = rc->dwTargetStrOffset / sizeof(wchar_t);
+	const size_t tgWlen = rc->dwTargetStrLen;
+	const size_t tgWstart = rc->dwTargetStrOffset / sizeof(wchar_t);
 
 	std::string tgCompStart = StringEncode(rcFeed.substr(0, tgWstart), codePage);
 	std::string tgComp = StringEncode(rcFeed.substr(tgWstart, tgWlen), codePage);
@@ -3453,10 +3460,10 @@ LRESULT ScintillaWin::ImeOnDocumentFeed(LPARAM lParam) const {
 		return rcSize;
 
 	wchar_t *rcFeedStart = reinterpret_cast<wchar_t*>(rc + 1);
-	memcpy(rcFeedStart, &rcFeed[0], rcFeedLen);
+	memcpy(rcFeedStart, rcFeed.data(), rcFeedLen);
 
 	IMContext imc(MainHWND());
-	if (!imc.hIMC)
+	if (!imc)
 		return 0;
 
 	DWORD compStrLen = 0;
@@ -3531,7 +3538,7 @@ void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
 	}
 
 	if (selectedText.rectangular) {
-		::SetClipboardData(cfColumnSelect, 0);
+		::SetClipboardData(cfColumnSelect, {});
 
 		GlobalMemory borlandSelection;
 		borlandSelection.Allocate(1);
@@ -3542,8 +3549,8 @@ void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
 	}
 
 	if (selectedText.lineCopy) {
-		::SetClipboardData(cfLineSelect, 0);
-		::SetClipboardData(cfVSLineTag, 0);
+		::SetClipboardData(cfLineSelect, {});
+		::SetClipboardData(cfVSLineTag, {});
 	}
 }
 
@@ -3582,12 +3589,13 @@ void ScintillaWin::HorizontalScrollMessage(WPARAM wParam) {
 	int xPos = xOffset;
 	const PRectangle rcText = GetTextRectangle();
 	const int pageWidth = static_cast<int>(rcText.Width() * 2 / 3);
+	constexpr int pixelsPerArrow = 20;
 	switch (LOWORD(wParam)) {
 	case SB_LINEUP:
-		xPos -= 20;
+		xPos -= pixelsPerArrow;
 		break;
 	case SB_LINEDOWN:	// May move past the logical end
-		xPos += 20;
+		xPos += pixelsPerArrow;
 		break;
 	case SB_PAGEUP:
 		xPos -= pageWidth;
@@ -3809,7 +3817,7 @@ STDMETHODIMP ScintillaWin::GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) {
 
 	GlobalMemory uniText;
 	CopyToGlobal(uniText, drag);
-	pSTM->hGlobal = uniText ? uniText.Unlock() : 0;
+	pSTM->hGlobal = uniText ? uniText.Unlock() : HGLOBAL{};
 	pSTM->pUnkForRelease = nullptr;
 	return S_OK;
 }
@@ -3824,7 +3832,7 @@ void ScintillaWin::Prepare() noexcept {
 	wndclassc.cbWndExtra = sizeof(ScintillaWin *);
 	wndclassc.hInstance = hInstance;
 	wndclassc.lpfnWndProc = ScintillaWin::CTWndProc;
-	wndclassc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
+	wndclassc.hCursor = ::LoadCursor({}, IDC_ARROW);
 	wndclassc.lpszClassName = callClassName;
 
 	callClassAtom = ::RegisterClassEx(&wndclassc);
@@ -3867,13 +3875,9 @@ bool ScintillaWin::Unregister() noexcept {
 }
 
 bool ScintillaWin::HasCaretSizeChanged() const noexcept {
-	if (
-		( (0 != vs.caret.width) && (sysCaretWidth != vs.caret.width) )
-		|| ((0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight))
-		) {
-		return true;
-	}
-	return false;
+	return
+		((0 != vs.caret.width) && (sysCaretWidth != vs.caret.width))
+		|| ((0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight));
 }
 
 BOOL ScintillaWin::CreateSystemCaret() {
@@ -3886,7 +3890,7 @@ BOOL ScintillaWin::CreateSystemCaret() {
 		sysCaretHeight;
 	std::vector<BYTE> bits(bitmapSize);
 	sysCaretBitmap = ::CreateBitmap(sysCaretWidth, sysCaretHeight, 1,
-		1, &bits[0]);
+		1, bits.data());
 	const BOOL retval = ::CreateCaret(
 		MainHWND(), sysCaretBitmap,
 		sysCaretWidth, sysCaretHeight);
@@ -3907,115 +3911,123 @@ BOOL ScintillaWin::DestroySystemCaret() noexcept {
 	return retval;
 }
 
-LRESULT PASCAL ScintillaWin::CTWndProc(
-	HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
-	// Find C++ object associated with window.
-	ScintillaWin *sciThis = static_cast<ScintillaWin *>(PointerFromWindow(hWnd));
-	try {
-		// ctp will be zero if WM_CREATE not seen yet
-		if (sciThis == nullptr) {
-			if (iMessage == WM_CREATE) {
-				// Associate CallTip object with window
-				CREATESTRUCT *pCreate = static_cast<CREATESTRUCT *>(PtrFromSPtr(lParam));
-				SetWindowPointer(hWnd, pCreate->lpCreateParams);
-				return 0;
-			} else {
-				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-			}
-		} else {
-			if (iMessage == WM_NCDESTROY) {
-				SetWindowPointer(hWnd, nullptr);
-				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-			} else if (iMessage == WM_PAINT) {
-				PAINTSTRUCT ps;
-				::BeginPaint(hWnd, &ps);
-				std::unique_ptr<Surface> surfaceWindow(Surface::Allocate(sciThis->technology));
+void ScintillaWin::CTPaint(HWND hWnd) {
+	Painter painter(hWnd);
+	std::unique_ptr<Surface> surfaceWindow(Surface::Allocate(technology));
 #if defined(USE_D2D)
-				HwndRenderTarget pCTRenderTarget;
+	HwndRenderTarget pCTRenderTarget;
 #endif
-				const RECT rc = GetClientRect(hWnd);
-				if (sciThis->technology == Technology::Default) {
-					surfaceWindow->Init(ps.hdc, hWnd);
-				} else {
+	const RECT rc = GetClientRect(hWnd);
+	if (technology == Technology::Default) {
+		surfaceWindow->Init(painter.ps.hdc, hWnd);
+	} else {
 #if defined(USE_D2D)
-					const int scaleFactor = sciThis->GetFirstIntegralMultipleDeviceScaleFactor();
-
-					// Create a Direct2D render target.
-					D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp {};
-					dhrtp.hwnd = hWnd;
-					dhrtp.pixelSize = ::GetSizeUFromRect(rc, scaleFactor);
-					dhrtp.presentOptions = (sciThis->technology == Technology::DirectWriteRetain) ?
-						D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
-
-					D2D1_RENDER_TARGET_PROPERTIES drtp {};
-					drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
-					drtp.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
-					drtp.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
-					drtp.dpiX = 96.f * scaleFactor;
-					drtp.dpiY = 96.f * scaleFactor;
-					drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
-					drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
-
-					const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, pCTRenderTarget);
-					if (!SUCCEEDED(hr)) {
-						surfaceWindow->Release();
-						::EndPaint(hWnd, &ps);
-						return 0;
-					}
-					// If above SUCCEEDED, then pCTRenderTarget not nullptr
-					assert(pCTRenderTarget);
-					if (pCTRenderTarget) {
-						surfaceWindow->Init(pCTRenderTarget.Get(), hWnd);
-						pCTRenderTarget->BeginDraw();
-					}
+		const int scaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
+
+		// Create a Direct2D render target.
+
+		const FLOAT dpiTarget = dpiDefault * static_cast<float>(scaleFactor);
+
+		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
+			D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			{ DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_UNKNOWN },
+			dpiTarget, dpiTarget);
+
+		const D2D1_PRESENT_OPTIONS presentOptions = (technology == Technology::DirectWriteRetain) ?
+			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
+
+		const D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp = D2D1::HwndRenderTargetProperties(
+			hWnd,
+			::GetSizeUFromRect(rc, scaleFactor),
+			presentOptions);
+
+		const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, pCTRenderTarget);
+		if (!SUCCEEDED(hr)) {
+			surfaceWindow->Release();
+			return;
+		}
+		// If above SUCCEEDED, then pCTRenderTarget not nullptr
+		assert(pCTRenderTarget);
+		if (pCTRenderTarget) {
+			surfaceWindow->Init(pCTRenderTarget.Get(), hWnd);
+			pCTRenderTarget->BeginDraw();
+		}
 #endif
-				}
-				surfaceWindow->SetMode(sciThis->CurrentSurfaceMode());
-				sciThis->SetRenderingParams(surfaceWindow.get());
-				sciThis->ct.PaintCT(surfaceWindow.get());
+	}
+	surfaceWindow->SetMode(CurrentSurfaceMode());
+	SetRenderingParams(surfaceWindow.get());
+	ct.PaintCT(surfaceWindow.get());
 #if defined(USE_D2D)
-				if (pCTRenderTarget)
-					pCTRenderTarget->EndDraw();
+	if (pCTRenderTarget)
+		pCTRenderTarget->EndDraw();
 #endif
-				surfaceWindow->Release();
-				::EndPaint(hWnd, &ps);
-				return 0;
-			} else if ((iMessage == WM_NCLBUTTONDOWN) || (iMessage == WM_NCLBUTTONDBLCLK)) {
+	surfaceWindow->Release();
+}
+
+LRESULT ScintillaWin::CTProcessMessage(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	try {
+		switch (iMessage) {
+		case WM_NCDESTROY:
+			SetWindowPointer(hWnd, nullptr);
+			break;
+		case WM_PAINT:
+			CTPaint(hWnd);
+			return 0;
+		case WM_NCLBUTTONDOWN:
+		case WM_NCLBUTTONDBLCLK: {
 				POINT pt = POINTFromLParam(lParam);
 				::ScreenToClient(hWnd, &pt);
-				sciThis->ct.MouseClick(PointFromPOINT(pt));
-				sciThis->CallTipClick();
+				ct.MouseClick(PointFromPOINT(pt));
+				CallTipClick();
 				return 0;
-			} else if (iMessage == WM_LBUTTONDOWN) {
-				// This does not fire due to the hit test code
-				sciThis->ct.MouseClick(PointFromLParam(lParam));
-				sciThis->CallTipClick();
-				return 0;
-			} else if (iMessage == WM_SETCURSOR) {
-				::SetCursor(::LoadCursor(NULL, IDC_ARROW));
-				return 0;
-			} else if (iMessage == WM_NCHITTEST) {
-				return HTCAPTION;
-			} else {
-				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 			}
+		case WM_LBUTTONDOWN:
+			// This does not fire due to the hit test code
+			ct.MouseClick(PointFromLParam(lParam));
+			CallTipClick();
+			return 0;
+		case WM_SETCURSOR:
+			::SetCursor(::LoadCursor({}, IDC_ARROW));
+			return 0;
+		case WM_NCHITTEST:
+			return HTCAPTION;
+		default:
+			break;
 		}
 	} catch (...) {
-		sciThis->errorStatus = Status::Failure;
+		errorStatus = Status::Failure;
 	}
+
 	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 }
 
+LRESULT PASCAL ScintillaWin::CTWndProc(
+	HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	// Find C++ object associated with window.
+	ScintillaWin *sciThis = static_cast<ScintillaWin *>(PointerFromWindow(hWnd));
+	// sciThis will be zero if WM_CREATE not seen yet
+	if (sciThis == nullptr) {
+		if (iMessage == WM_CREATE) {
+			// Associate CallTip object with window
+			CREATESTRUCT *pCreate = static_cast<CREATESTRUCT *>(PtrFromSPtr(lParam));
+			SetWindowPointer(hWnd, pCreate->lpCreateParams);
+			return 0;
+		}
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+	}
+	return sciThis->CTProcessMessage(hWnd, iMessage, wParam, lParam);
+}
+
 sptr_t ScintillaWin::DirectFunction(
     sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam) {
-	ScintillaWin *sci = reinterpret_cast<ScintillaWin *>(ptr);
+	ScintillaWin *sci = static_cast<ScintillaWin *>(PtrFromSPtr(ptr));
 	PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(sci->MainHWND(), nullptr));
 	return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
 }
 
 sptr_t ScintillaWin::DirectStatusFunction(
     sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam, int *pStatus) {
-	ScintillaWin *sci = reinterpret_cast<ScintillaWin *>(ptr);
+	ScintillaWin *sci = static_cast<ScintillaWin *>(PtrFromSPtr(ptr));
 	PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(sci->MainHWND(), nullptr));
 	const sptr_t returnValue = sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
 	*pStatus = static_cast<int>(sci->errorStatus);
@@ -4051,19 +4063,17 @@ LRESULT PASCAL ScintillaWin::SWndProc(
 		} catch (...) {
 		}
 		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-	} else {
-		if (iMessage == WM_NCDESTROY) {
-			try {
-				sci->Finalise();
-				delete sci;
-			} catch (...) {
-			}
-			SetWindowPointer(hWnd, nullptr);
-			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-		} else {
-			return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
+	}
+	if (iMessage == WM_NCDESTROY) {
+		try {
+			sci->Finalise();
+			delete sci;
+		} catch (...) {
 		}
+		SetWindowPointer(hWnd, nullptr);
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 	}
+	return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
 }
 
 // This function is externally visible so it can be called from container when building statically.
diff --git a/src/scintilla/win32/SurfaceD2D.cxx b/src/scintilla/win32/SurfaceD2D.cxx
new file mode 100644
index 000000000..223d35fcf
--- /dev/null
+++ b/src/scintilla/win32/SurfaceD2D.cxx
@@ -0,0 +1,1743 @@
+// Scintilla source code edit control
+/** @file SurfaceD2D.cxx
+ ** Implementation of drawing to Direct2D on Windows.
+ **/
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+#include <ctime>
+#include <cmath>
+#include <climits>
+
+#include <string_view>
+#include <vector>
+#include <map>
+#include <optional>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <mutex>
+
+// Want to use std::min and std::max so don't want Windows.h version of min and max
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0A00
+#undef WINVER
+#define WINVER 0x0A00
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#include <commctrl.h>
+#include <richedit.h>
+#include <windowsx.h>
+#include <shellscalingapi.h>
+
+#include <wrl.h>
+using Microsoft::WRL::ComPtr;
+
+#if !defined(DISABLE_D2D)
+#define USE_D2D 1
+#endif
+
+#if defined(USE_D2D)
+#include <d2d1_1.h>
+#include <d3d11_1.h>
+#include <dwrite_1.h>
+#endif
+
+#include "ScintillaTypes.h"
+
+#include "Debugging.h"
+#include "Geometry.h"
+#include "Platform.h"
+#include "XPM.h"
+#include "UniConversion.h"
+#include "DBCS.h"
+
+#include "WinTypes.h"
+#include "PlatWin.h"
+#include "SurfaceGDI.h"
+#if defined(USE_D2D)
+#include "SurfaceD2D.h"
+#endif
+
+// __uuidof is a Microsoft extension but makes COM code neater, so disable warning
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wlanguage-extension-token"
+#endif
+
+using namespace Scintilla;
+using namespace Scintilla::Internal;
+
+namespace {
+
+#if defined(USE_D2D)
+
+D2D1_DRAW_TEXT_OPTIONS d2dDrawTextOptions = D2D1_DRAW_TEXT_OPTIONS_NONE;
+
+HMODULE hDLLD2D{};
+HMODULE hDLLD3D{};
+HMODULE hDLLDWrite{};
+
+PFN_D3D11_CREATE_DEVICE fnDCD{};
+
+void LoadD2DOnce() noexcept {
+	DWORD loadLibraryFlags = 0;
+	HMODULE kernel32 = ::GetModuleHandleW(L"kernel32.dll");
+	if (kernel32) {
+		if (::GetProcAddress(kernel32, "SetDefaultDllDirectories")) {
+			// Availability of SetDefaultDllDirectories implies Windows 8+ or
+			// that KB2533623 has been installed so LoadLibraryEx can be called
+			// with LOAD_LIBRARY_SEARCH_SYSTEM32.
+			loadLibraryFlags = LOAD_LIBRARY_SEARCH_SYSTEM32;
+		}
+	}
+
+	using D2D1CFSig = HRESULT(WINAPI *)(D2D1_FACTORY_TYPE factoryType, REFIID riid,
+		CONST D2D1_FACTORY_OPTIONS *pFactoryOptions, IUnknown **factory);
+	using DWriteCFSig = HRESULT(WINAPI *)(DWRITE_FACTORY_TYPE factoryType, REFIID iid,
+		IUnknown **factory);
+
+	hDLLD2D = ::LoadLibraryEx(TEXT("D2D1.DLL"), {}, loadLibraryFlags);
+	D2D1CFSig fnD2DCF = DLLFunction<D2D1CFSig>(hDLLD2D, "D2D1CreateFactory");
+	if (fnD2DCF) {
+		const D2D1_FACTORY_OPTIONS options{};
+		// A multi threaded factory in case Scintilla is used with multiple GUI threads
+		fnD2DCF(D2D1_FACTORY_TYPE_MULTI_THREADED,
+			__uuidof(ID2D1Factory1),
+			&options,
+			reinterpret_cast<IUnknown **>(&pD2DFactory));
+	}
+	hDLLDWrite = ::LoadLibraryEx(TEXT("DWRITE.DLL"), {}, loadLibraryFlags);
+	DWriteCFSig fnDWCF = DLLFunction<DWriteCFSig>(hDLLDWrite, "DWriteCreateFactory");
+	if (fnDWCF) {
+		const GUID IID_IDWriteFactory2 = // 0439fc60-ca44-4994-8dee-3a9af7b732ec
+		{ 0x0439fc60, 0xca44, 0x4994, { 0x8d, 0xee, 0x3a, 0x9a, 0xf7, 0xb7, 0x32, 0xec } };
+
+		const HRESULT hr = fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
+			IID_IDWriteFactory2,
+			reinterpret_cast<IUnknown **>(&pIDWriteFactory));
+		if (SUCCEEDED(hr)) {
+			// D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT
+			d2dDrawTextOptions = static_cast<D2D1_DRAW_TEXT_OPTIONS>(0x00000004);
+		} else {
+			fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
+				__uuidof(IDWriteFactory1),
+				reinterpret_cast<IUnknown **>(&pIDWriteFactory));
+		}
+	}
+
+	hDLLD3D = ::LoadLibraryEx(TEXT("D3D11.DLL"), {}, loadLibraryFlags);
+	if (!hDLLD3D) {
+		Platform::DebugPrintf("Direct3D not loaded\n");
+	}
+	fnDCD = DLLFunction<PFN_D3D11_CREATE_DEVICE>(hDLLD3D, "D3D11CreateDevice");
+	if (!fnDCD) {
+		Platform::DebugPrintf("Direct3D does not have D3D11CreateDevice\n");
+	}
+}
+
+constexpr D2D1_TEXT_ANTIALIAS_MODE DWriteMapFontQuality(FontQuality extraFontFlag) noexcept {
+	switch (extraFontFlag & FontQuality::QualityMask) {
+
+		case FontQuality::QualityNonAntialiased:
+			return D2D1_TEXT_ANTIALIAS_MODE_ALIASED;
+
+		case FontQuality::QualityAntialiased:
+			return D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE;
+
+		case FontQuality::QualityLcdOptimized:
+			return D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
+
+		default:
+			return D2D1_TEXT_ANTIALIAS_MODE_DEFAULT;
+	}
+}
+
+struct FontDirectWrite : public FontWin {
+	ComPtr<IDWriteTextFormat> pTextFormat;
+	FontQuality extraFontFlag = FontQuality::QualityDefault;
+	CharacterSet characterSet = CharacterSet::Ansi;
+	static constexpr FLOAT minimalAscent = 2.0f;
+	FLOAT yAscent = minimalAscent;
+	FLOAT yDescent = 1.0f;
+	FLOAT yInternalLeading = 0.0f;
+
+	explicit FontDirectWrite(const FontParameters &fp) :
+		extraFontFlag(fp.extraFontFlag),
+		characterSet(fp.characterSet) {
+		const std::wstring wsFace = WStringFromUTF8(fp.faceName);
+		const std::wstring wsLocale = WStringFromUTF8(fp.localeName);
+		const FLOAT fHeight = static_cast<FLOAT>(fp.size);
+		const DWRITE_FONT_STYLE style = fp.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
+		HRESULT hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
+			static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
+			style,
+			static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
+				fHeight, wsLocale.c_str(), pTextFormat.GetAddressOf());
+		if (hr == E_INVALIDARG) {
+			// Possibly a bad locale name like "/" so try "en-us".
+			hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
+				static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
+				style,
+				static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
+				fHeight, L"en-us", pTextFormat.ReleaseAndGetAddressOf());
+		}
+		if (SUCCEEDED(hr)) {
+			pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
+
+			if (TextLayout pTextLayout = LayoutCreate(L"X", pTextFormat.Get())) {
+				constexpr int maxLines = 2;
+				DWRITE_LINE_METRICS lineMetrics[maxLines]{};
+				UINT32 lineCount = 0;
+				hr = pTextLayout->GetLineMetrics(lineMetrics, maxLines, &lineCount);
+				if (SUCCEEDED(hr)) {
+					yAscent = lineMetrics[0].baseline;
+					yDescent = lineMetrics[0].height - lineMetrics[0].baseline;
+
+					FLOAT emHeight;
+					hr = pTextLayout->GetFontSize(0, &emHeight);
+					if (SUCCEEDED(hr)) {
+						yInternalLeading = lineMetrics[0].height - emHeight;
+					}
+				}
+				pTextFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineMetrics[0].height, lineMetrics[0].baseline);
+			}
+		}
+	}
+	// Allow copy constructor. Has to explicitly copy each field since can't use =default as deleted in Font.
+	FontDirectWrite(const FontDirectWrite &other) noexcept {
+		pTextFormat = other.pTextFormat;
+		extraFontFlag = other.extraFontFlag;
+		characterSet = other.characterSet;
+		yAscent = other.yAscent;
+		yDescent = other.yDescent;
+		yInternalLeading = other.yInternalLeading;
+	}
+	// Deleted so FontDirectWrite objects can not be copied.
+	FontDirectWrite(FontDirectWrite &&) = delete;
+	FontDirectWrite &operator=(const FontDirectWrite &) = delete;
+	FontDirectWrite &operator=(FontDirectWrite &&) = delete;
+	~FontDirectWrite() noexcept override = default;
+	[[nodiscard]] HFONT HFont() const noexcept override {
+		LOGFONTW lf = {};
+		const HRESULT hr = pTextFormat->GetFontFamilyName(lf.lfFaceName, LF_FACESIZE);
+		if (!SUCCEEDED(hr)) {
+			return {};
+		}
+		lf.lfWeight = pTextFormat->GetFontWeight();
+		lf.lfItalic = pTextFormat->GetFontStyle() == DWRITE_FONT_STYLE_ITALIC;
+		lf.lfHeight = -static_cast<int>(pTextFormat->GetFontSize());
+		return ::CreateFontIndirectW(&lf);
+	}
+
+	[[nodiscard]] int CodePageText(int codePage) const noexcept {
+		if (!(codePage == CpUtf8) && (characterSet != CharacterSet::Ansi)) {
+			codePage = CodePageFromCharSet(characterSet, codePage);
+		}
+		return codePage;
+	}
+
+	static const FontDirectWrite *Cast(const Font *font_) {
+		const FontDirectWrite *pfm = dynamic_cast<const FontDirectWrite *>(font_);
+		PLATFORM_ASSERT(pfm);
+		if (!pfm) {
+			throw std::runtime_error("SurfaceD2D::SetFont: wrong Font type.");
+		}
+		return pfm;
+	}
+
+	[[nodiscard]] std::unique_ptr<FontWin> Duplicate() const override {
+		return std::make_unique<FontDirectWrite>(*this);
+	}
+
+	[[nodiscard]] CharacterSet GetCharacterSet() const noexcept override {
+		return characterSet;
+	}
+};
+
+constexpr D2D1_RECT_F RectangleFromPRectangle(PRectangle rc) noexcept {
+	return {
+		static_cast<FLOAT>(rc.left),
+		static_cast<FLOAT>(rc.top),
+		static_cast<FLOAT>(rc.right),
+		static_cast<FLOAT>(rc.bottom)
+	};
+}
+
+constexpr D2D1_POINT_2F DPointFromPoint(Point point) noexcept {
+	return { static_cast<FLOAT>(point.x), static_cast<FLOAT>(point.y) };
+}
+
+constexpr Supports SupportsD2D[] = {
+	Supports::LineDrawsFinal,
+	Supports::FractionalStrokeWidth,
+	Supports::TranslucentStroke,
+	Supports::PixelModification,
+	Supports::ThreadSafeMeasureWidths,
+};
+
+constexpr D2D1_RECT_F RectangleInset(D2D1_RECT_F rect, FLOAT inset) noexcept {
+	return D2D1_RECT_F{
+		rect.left + inset,
+		rect.top + inset,
+		rect.right - inset,
+		rect.bottom - inset };
+}
+
+constexpr D2D_COLOR_F ColorFromColourAlpha(ColourRGBA colour) noexcept {
+	return D2D_COLOR_F{
+		colour.GetRedComponent(),
+		colour.GetGreenComponent(),
+		colour.GetBlueComponent(),
+		colour.GetAlphaComponent()
+	};
+}
+
+class BlobInline;
+
+class SurfaceD2D : public Surface, public ISetRenderingParams {
+	SurfaceMode mode;
+
+	// Text measuring surface: both pRenderTarget and pBitmapRenderTarget are null.
+	// Window surface: pRenderTarget is valid but not pBitmapRenderTarget.
+	// Bitmap drawing surface: both pRenderTarget and pBitmapRenderTarget are valid and the same.
+	ComPtr<ID2D1RenderTarget> pRenderTarget;
+	ComPtr<ID2D1BitmapRenderTarget> pBitmapRenderTarget;
+	int clipsActive = 0;
+
+	BrushSolid pBrush = nullptr;
+
+	static constexpr FontQuality invalidFontQuality = FontQuality::QualityMask;
+	FontQuality fontQuality = invalidFontQuality;
+	int logPixelsY = USER_DEFAULT_SCREEN_DPI;
+	int deviceScaleFactor = 1;
+	std::shared_ptr<RenderingParams> renderingParams;
+
+	void Clear() noexcept;
+	void SetFontQuality(FontQuality extraFontFlag);
+	HRESULT GetBitmap(ID2D1Bitmap **ppBitmap);
+	void SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept;
+
+public:
+	SurfaceD2D() noexcept = default;
+	SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
+	// Deleted so SurfaceD2D objects can not be copied.
+	SurfaceD2D(const SurfaceD2D &) = delete;
+	SurfaceD2D(SurfaceD2D &&) = delete;
+	SurfaceD2D &operator=(const SurfaceD2D &) = delete;
+	SurfaceD2D &operator=(SurfaceD2D &&) = delete;
+	~SurfaceD2D() noexcept override;
+
+	void SetScale(WindowID wid) noexcept;
+	void Init(WindowID wid) override;
+	void Init(SurfaceID sid, WindowID wid) override;
+	std::unique_ptr<Surface> AllocatePixMap(int width, int height) override;
+
+	void SetMode(SurfaceMode mode_) override;
+
+	void Release() noexcept override;
+	int SupportsFeature(Supports feature) noexcept override;
+	bool Initialised() override;
+
+	void D2DPenColourAlpha(ColourRGBA fore) noexcept;
+	int LogPixelsY() override;
+	int PixelDivisions() override;
+	int DeviceHeightFont(int points) override;
+	void LineDraw(Point start, Point end, Stroke stroke) override;
+	static Geometry GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept;
+	void PolyLine(const Point *pts, size_t npts, Stroke stroke) override;
+	void Polygon(const Point *pts, size_t npts, FillStroke fillStroke) override;
+	void RectangleDraw(PRectangle rc, FillStroke fillStroke) override;
+	void RectangleFrame(PRectangle rc, Stroke stroke) override;
+	void FillRectangle(PRectangle rc, Fill fill) override;
+	void FillRectangleAligned(PRectangle rc, Fill fill) override;
+	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
+	void RoundedRectangle(PRectangle rc, FillStroke fillStroke) override;
+	void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) override;
+	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
+	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
+	void Ellipse(PRectangle rc, FillStroke fillStroke) override;
+	void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) override;
+	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;
+
+	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;
+
+	void DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, int codePageOverride, UINT fuOptions);
+
+	void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
+	void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) override;
+	XYPOSITION WidthText(const Font *font_, std::string_view text) override;
+
+	void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
+	void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) override;
+	XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) override;
+
+	XYPOSITION Ascent(const Font *font_) override;
+	XYPOSITION Descent(const Font *font_) override;
+	XYPOSITION InternalLeading(const Font *font_) override;
+	XYPOSITION Height(const Font *font_) override;
+	XYPOSITION AverageCharWidth(const Font *font_) override;
+
+	void SetClip(PRectangle rc) override;
+	void PopClip() override;
+	void FlushCachedState() override;
+	void FlushDrawing() override;
+
+	void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) override;
+};
+
+SurfaceD2D::SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
+	const D2D1_SIZE_F desiredSize = D2D1::SizeF(static_cast<float>(width), static_cast<float>(height));
+	D2D1_PIXEL_FORMAT desiredFormat;
+#ifdef __MINGW32__
+	desiredFormat.format = DXGI_FORMAT_UNKNOWN;
+#else
+	desiredFormat = pRenderTargetCompatible->GetPixelFormat();
+#endif
+	desiredFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
+	const HRESULT hr = pRenderTargetCompatible->CreateCompatibleRenderTarget(
+		&desiredSize, nullptr, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, pBitmapRenderTarget.GetAddressOf());
+	if (SUCCEEDED(hr)) {
+		pRenderTarget = pBitmapRenderTarget;
+		SetDeviceScaleFactor(pRenderTarget.Get());
+		pRenderTarget->BeginDraw();
+	}
+	mode = mode_;
+	logPixelsY = logPixelsY_;
+}
+
+SurfaceD2D::~SurfaceD2D() noexcept {
+	Clear();
+}
+
+void SurfaceD2D::Clear() noexcept {
+	pBrush = nullptr;
+	if (pRenderTarget) {
+		while (clipsActive) {
+			pRenderTarget->PopAxisAlignedClip();
+			clipsActive--;
+		}
+		if (pBitmapRenderTarget) {
+			pRenderTarget->EndDraw();
+		}
+	}
+	pRenderTarget = nullptr;
+	pBitmapRenderTarget = nullptr;
+}
+
+void SurfaceD2D::Release() noexcept {
+	Clear();
+}
+
+void SurfaceD2D::SetScale(WindowID wid) noexcept {
+	fontQuality = invalidFontQuality;
+	logPixelsY = DpiForWindow(wid);
+}
+
+int SurfaceD2D::SupportsFeature(Supports feature) noexcept {
+	for (const Supports f : SupportsD2D) {
+		if (f == feature)
+			return 1;
+	}
+	return 0;
+}
+
+bool SurfaceD2D::Initialised() {
+	return pRenderTarget;
+}
+
+void SurfaceD2D::Init(WindowID wid) {
+	Release();
+	SetScale(wid);
+}
+
+void SurfaceD2D::Init(SurfaceID sid, WindowID wid) {
+	Release();
+	SetScale(wid);
+	pRenderTarget = static_cast<ID2D1RenderTarget *>(sid);
+	SetDeviceScaleFactor(pRenderTarget.Get());
+}
+
+std::unique_ptr<Surface> SurfaceD2D::AllocatePixMap(int width, int height) {
+	std::unique_ptr<SurfaceD2D> surf = std::make_unique<SurfaceD2D>(pRenderTarget.Get(), width, height, mode, logPixelsY);
+	surf->SetRenderingParams(renderingParams);
+	return surf;
+}
+
+void SurfaceD2D::SetMode(SurfaceMode mode_) {
+	mode = mode_;
+}
+
+HRESULT SurfaceD2D::GetBitmap(ID2D1Bitmap **ppBitmap) {
+	PLATFORM_ASSERT(pBitmapRenderTarget);
+	return pBitmapRenderTarget->GetBitmap(ppBitmap);
+}
+
+void SurfaceD2D::D2DPenColourAlpha(ColourRGBA fore) noexcept {
+	if (pRenderTarget) {
+		const D2D_COLOR_F col = ColorFromColourAlpha(fore);
+		if (pBrush) {
+			pBrush->SetColor(col);
+		} else {
+			const HRESULT hr = pRenderTarget->CreateSolidColorBrush(col, &pBrush);
+			if (!SUCCEEDED(hr)) {
+				pBrush = nullptr;
+			}
+		}
+	}
+}
+
+void SurfaceD2D::SetFontQuality(FontQuality extraFontFlag) {
+	if ((fontQuality != extraFontFlag) && renderingParams) {
+		fontQuality = extraFontFlag;
+		const D2D1_TEXT_ANTIALIAS_MODE aaMode = DWriteMapFontQuality(extraFontFlag);
+		if (aaMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE && renderingParams->customRenderingParams) {
+			pRenderTarget->SetTextRenderingParams(renderingParams->customRenderingParams.Get());
+		} else if (renderingParams->defaultRenderingParams) {
+			pRenderTarget->SetTextRenderingParams(renderingParams->defaultRenderingParams.Get());
+		}
+		pRenderTarget->SetTextAntialiasMode(aaMode);
+	}
+}
+
+int SurfaceD2D::LogPixelsY() {
+	return logPixelsY;
+}
+
+void SurfaceD2D::SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept {
+	FLOAT dpiX = 0.f;
+	FLOAT dpiY = 0.f;
+	pD2D1RenderTarget->GetDpi(&dpiX, &dpiY);
+	deviceScaleFactor = static_cast<int>(dpiX / dpiDefault);
+}
+
+int SurfaceD2D::PixelDivisions() {
+	return deviceScaleFactor;
+}
+
+int SurfaceD2D::DeviceHeightFont(int points) {
+	return ::MulDiv(points, LogPixelsY(), pointsPerInch);
+}
+
+constexpr FLOAT mitreLimit = 4.0f;
+
+void SurfaceD2D::LineDraw(Point start, Point end, Stroke stroke) {
+	D2DPenColourAlpha(stroke.colour);
+
+	D2D1_STROKE_STYLE_PROPERTIES strokeProps {};
+	strokeProps.startCap = D2D1_CAP_STYLE_SQUARE;
+	strokeProps.endCap = D2D1_CAP_STYLE_SQUARE;
+	strokeProps.dashCap = D2D1_CAP_STYLE_FLAT;
+	strokeProps.lineJoin = D2D1_LINE_JOIN_MITER;
+	strokeProps.miterLimit = mitreLimit;
+	strokeProps.dashStyle = D2D1_DASH_STYLE_SOLID;
+	strokeProps.dashOffset = 0;
+
+	// get the stroke style to apply
+	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
+		pRenderTarget->DrawLine(
+			DPointFromPoint(start),
+			DPointFromPoint(end), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
+	}
+}
+
+Geometry SurfaceD2D::GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept {
+	Geometry geometry = GeometryCreate();
+	if (geometry) {
+		if (const GeometrySink sink = GeometrySinkCreate(geometry.Get())) {
+			sink->BeginFigure(DPointFromPoint(pts[0]), figureBegin);
+			for (size_t i = 1; i < npts; i++) {
+				sink->AddLine(DPointFromPoint(pts[i]));
+			}
+			sink->EndFigure((figureBegin == D2D1_FIGURE_BEGIN_FILLED) ?
+				D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN);
+			sink->Close();
+		}
+	}
+	return geometry;
+}
+
+void SurfaceD2D::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
+	PLATFORM_ASSERT(pRenderTarget && (npts > 1));
+	if (!pRenderTarget || (npts <= 1)) {
+		return;
+	}
+
+	const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_HOLLOW);
+	PLATFORM_ASSERT(geometry);
+	if (!geometry) {
+		return;
+	}
+
+	D2DPenColourAlpha(stroke.colour);
+	D2D1_STROKE_STYLE_PROPERTIES strokeProps {};
+	strokeProps.startCap = D2D1_CAP_STYLE_ROUND;
+	strokeProps.endCap = D2D1_CAP_STYLE_ROUND;
+	strokeProps.dashCap = D2D1_CAP_STYLE_FLAT;
+	strokeProps.lineJoin = D2D1_LINE_JOIN_MITER;
+	strokeProps.miterLimit = mitreLimit;
+	strokeProps.dashStyle = D2D1_DASH_STYLE_SOLID;
+	strokeProps.dashOffset = 0;
+
+	// get the stroke style to apply
+	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
+		pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
+	}
+}
+
+void SurfaceD2D::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
+	PLATFORM_ASSERT(pRenderTarget && (npts > 2));
+	if (pRenderTarget) {
+		const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_FILLED);
+		PLATFORM_ASSERT(geometry);
+		if (geometry) {
+			D2DPenColourAlpha(fillStroke.fill.colour);
+			pRenderTarget->FillGeometry(geometry.Get(), pBrush.Get());
+			D2DPenColourAlpha(fillStroke.stroke.colour);
+			pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
+		}
+	}
+}
+
+void SurfaceD2D::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
+	if (!pRenderTarget)
+		return;
+	const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
+	const D2D1_RECT_F rectFill = RectangleInset(rect, fillStroke.stroke.WidthF());
+	const float halfStroke = fillStroke.stroke.WidthF() / 2.0f;
+	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);
+
+	D2DPenColourAlpha(fillStroke.fill.colour);
+	pRenderTarget->FillRectangle(&rectFill, pBrush.Get());
+	D2DPenColourAlpha(fillStroke.stroke.colour);
+	pRenderTarget->DrawRectangle(&rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
+}
+
+void SurfaceD2D::RectangleFrame(PRectangle rc, Stroke stroke) {
+	if (pRenderTarget) {
+		const XYPOSITION halfStroke = stroke.width / 2.0f;
+		const D2D1_RECT_F rectangle1 = RectangleFromPRectangle(rc.Inset(halfStroke));
+		D2DPenColourAlpha(stroke.colour);
+		pRenderTarget->DrawRectangle(&rectangle1, pBrush.Get(), stroke.WidthF());
+	}
+}
+
+void SurfaceD2D::FillRectangle(PRectangle rc, Fill fill) {
+	if (pRenderTarget) {
+		D2DPenColourAlpha(fill.colour);
+		const D2D1_RECT_F rectangle = RectangleFromPRectangle(rc);
+		pRenderTarget->FillRectangle(&rectangle, pBrush.Get());
+	}
+}
+
+void SurfaceD2D::FillRectangleAligned(PRectangle rc, Fill fill) {
+	FillRectangle(PixelAlign(rc, PixelDivisions()), fill);
+}
+
+void SurfaceD2D::FillRectangle(PRectangle rc, Surface &surfacePattern) {
+	SurfaceD2D *psurfOther = dynamic_cast<SurfaceD2D *>(&surfacePattern);
+	PLATFORM_ASSERT(psurfOther);
+	if (!psurfOther) {
+		throw std::runtime_error("SurfaceD2D::FillRectangle: wrong Surface type.");
+	}
+	ComPtr<ID2D1Bitmap> pBitmap;
+	HRESULT hr = psurfOther->GetBitmap(pBitmap.GetAddressOf());
+	if (SUCCEEDED(hr) && pBitmap) {
+		ComPtr<ID2D1BitmapBrush> pBitmapBrush;
+		const D2D1_BITMAP_BRUSH_PROPERTIES brushProperties =
+	        D2D1::BitmapBrushProperties(D2D1_EXTEND_MODE_WRAP, D2D1_EXTEND_MODE_WRAP,
+			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
+		// Create the bitmap brush.
+		hr = pRenderTarget->CreateBitmapBrush(pBitmap.Get(), brushProperties, pBitmapBrush.GetAddressOf());
+		if (SUCCEEDED(hr) && pBitmapBrush) {
+			pRenderTarget->FillRectangle(
+				RectangleFromPRectangle(rc),
+				pBitmapBrush.Get());
+		}
+	}
+}
+
+void SurfaceD2D::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
+	if (pRenderTarget) {
+		const FLOAT minDimension = static_cast<FLOAT>(std::min(rc.Width(), rc.Height())) / 2.0f;
+		const FLOAT radius = std::min(4.0f, minDimension);
+		if (fillStroke.fill.colour == fillStroke.stroke.colour) {
+			const D2D1_ROUNDED_RECT roundedRectFill = {
+				RectangleFromPRectangle(rc),
+				radius, radius };
+			D2DPenColourAlpha(fillStroke.fill.colour);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
+		} else {
+			const D2D1_ROUNDED_RECT roundedRectFill = {
+				RectangleFromPRectangle(rc.Inset(1.0)),
+				radius-1, radius-1 };
+			D2DPenColourAlpha(fillStroke.fill.colour);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
+
+			const D2D1_ROUNDED_RECT roundedRect = {
+				RectangleFromPRectangle(rc.Inset(0.5)),
+				radius, radius };
+			D2DPenColourAlpha(fillStroke.stroke.colour);
+			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
+		}
+	}
+}
+
+void SurfaceD2D::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) {
+	const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
+	const D2D1_RECT_F rectFill = RectangleInset(rect, fillStroke.stroke.WidthF());
+	const float halfStroke = fillStroke.stroke.WidthF() / 2.0f;
+	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);
+	if (pRenderTarget) {
+		if (cornerSize == 0) {
+			// When corner size is zero, draw square rectangle to prevent blurry pixels at corners
+			D2DPenColourAlpha(fillStroke.fill.colour);
+			pRenderTarget->FillRectangle(rectFill, pBrush.Get());
+
+			D2DPenColourAlpha(fillStroke.stroke.colour);
+			pRenderTarget->DrawRectangle(rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
+		} else {
+			const float cornerSizeF = static_cast<float>(cornerSize);
+			const D2D1_ROUNDED_RECT roundedRectFill = {
+				rectFill, cornerSizeF - 1.0f, cornerSizeF - 1.0f };
+			D2DPenColourAlpha(fillStroke.fill.colour);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
+
+			const D2D1_ROUNDED_RECT roundedRect = {
+				rectOutline, cornerSizeF, cornerSizeF};
+			D2DPenColourAlpha(fillStroke.stroke.colour);
+			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
+		}
+	}
+}
+
+void SurfaceD2D::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
+	if (pRenderTarget) {
+		D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lgbp {
+			DPointFromPoint(Point(rc.left, rc.top)), {}
+		};
+		switch (options) {
+		case GradientOptions::leftToRight:
+			lgbp.endPoint = DPointFromPoint(Point(rc.right, rc.top));
+			break;
+		case GradientOptions::topToBottom:
+		default:
+			lgbp.endPoint = DPointFromPoint(Point(rc.left, rc.bottom));
+			break;
+		}
+
+		std::vector<D2D1_GRADIENT_STOP> gradientStops;
+		for (const ColourStop &stop : stops) {
+			gradientStops.push_back({ static_cast<FLOAT>(stop.position), ColorFromColourAlpha(stop.colour) });
+		}
+		ComPtr<ID2D1GradientStopCollection> pGradientStops;
+		HRESULT hr = pRenderTarget->CreateGradientStopCollection(
+			gradientStops.data(), static_cast<UINT32>(gradientStops.size()), pGradientStops.GetAddressOf());
+		if (FAILED(hr) || !pGradientStops) {
+			return;
+		}
+		ComPtr<ID2D1LinearGradientBrush> pBrushLinear;
+		hr = pRenderTarget->CreateLinearGradientBrush(
+			lgbp, pGradientStops.Get(), pBrushLinear.GetAddressOf());
+		if (SUCCEEDED(hr) && pBrushLinear) {
+			const D2D1_RECT_F rectangle = RectangleFromPRectangle(PRectangle(
+				std::round(rc.left), rc.top, std::round(rc.right), rc.bottom));
+			pRenderTarget->FillRectangle(&rectangle, pBrushLinear.Get());
+		}
+	}
+}
+
+void SurfaceD2D::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
+	if (pRenderTarget) {
+		if (rc.Width() > width)
+			rc.left += std::floor((rc.Width() - width) / 2);
+		rc.right = rc.left + width;
+		if (rc.Height() > height)
+			rc.top += std::floor((rc.Height() - height) / 2);
+		rc.bottom = rc.top + height;
+
+		std::vector<unsigned char> image(RGBAImage::bytesPerPixel * height * width);
+		RGBAImage::BGRAFromRGBA(image.data(), pixelsImage, static_cast<ptrdiff_t>(height) * width);
+
+		ComPtr<ID2D1Bitmap> bitmap;
+		const D2D1_SIZE_U size = D2D1::SizeU(width, height);
+		const D2D1_BITMAP_PROPERTIES props = {{DXGI_FORMAT_B8G8R8A8_UNORM,
+		    D2D1_ALPHA_MODE_PREMULTIPLIED}, 72.0, 72.0};
+		const HRESULT hr = pRenderTarget->CreateBitmap(size, image.data(),
+                  width * 4, &props, bitmap.GetAddressOf());
+		if (SUCCEEDED(hr)) {
+			const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
+			pRenderTarget->DrawBitmap(bitmap.Get(), rcDestination);
+		}
+	}
+}
+
+void SurfaceD2D::Ellipse(PRectangle rc, FillStroke fillStroke) {
+	if (!pRenderTarget)
+		return;
+	const D2D1_POINT_2F centre = DPointFromPoint(rc.Centre());
+
+	const FLOAT radiusFill = static_cast<FLOAT>((rc.Width() / 2.0f) - fillStroke.stroke.width);
+	const D2D1_ELLIPSE ellipseFill = { centre, radiusFill, radiusFill };
+
+	D2DPenColourAlpha(fillStroke.fill.colour);
+	pRenderTarget->FillEllipse(ellipseFill, pBrush.Get());
+
+	const FLOAT radiusOutline = static_cast<FLOAT>((rc.Width() / 2.0f) - (fillStroke.stroke.width / 2.0f));
+	const D2D1_ELLIPSE ellipseOutline = { centre, radiusOutline, radiusOutline };
+
+	D2DPenColourAlpha(fillStroke.stroke.colour);
+	pRenderTarget->DrawEllipse(ellipseOutline, pBrush.Get(), fillStroke.stroke.WidthF());
+}
+
+void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
+	if (!pRenderTarget)
+		return;
+	if (rc.Width() < rc.Height()) {
+		// Can't draw nice ends so just draw a rectangle
+		RectangleDraw(rc, fillStroke);
+		return;
+	}
+	const FLOAT radius = static_cast<FLOAT>(rc.Height() / 2.0);
+	const FLOAT radiusFill = radius - fillStroke.stroke.WidthF();
+	const FLOAT halfStroke = fillStroke.stroke.WidthF() / 2.0f;
+	if (ends == Surface::Ends::semiCircles) {
+		const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
+		const D2D1_ROUNDED_RECT roundedRectFill = { RectangleInset(rect, fillStroke.stroke.WidthF()),
+			radiusFill, radiusFill };
+		D2DPenColourAlpha(fillStroke.fill.colour);
+		pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
+
+		const D2D1_ROUNDED_RECT roundedRect = { RectangleInset(rect, halfStroke),
+			radius, radius };
+		D2DPenColourAlpha(fillStroke.stroke.colour);
+		pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
+	} else {
+		const Ends leftSide = static_cast<Ends>(static_cast<int>(ends) & 0xf);
+		const Ends rightSide = static_cast<Ends>(static_cast<int>(ends) & 0xf0);
+		PRectangle rcInner = rc;
+		rcInner.left += radius;
+		rcInner.right -= radius;
+		const Geometry pathGeometry = GeometryCreate();
+		if (!pathGeometry)
+			return;
+		if (const GeometrySink pSink = GeometrySinkCreate(pathGeometry.Get())) {
+			switch (leftSide) {
+				case Ends::leftFlat:
+					pSink->BeginFigure(DPointFromPoint(Point(rc.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
+					pSink->AddLine(DPointFromPoint(Point(rc.left + halfStroke, rc.bottom - halfStroke)));
+					break;
+				case Ends::leftAngle:
+					pSink->BeginFigure(DPointFromPoint(Point(rcInner.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
+					pSink->AddLine(DPointFromPoint(Point(rc.left + halfStroke, rc.Centre().y)));
+					pSink->AddLine(DPointFromPoint(Point(rcInner.left + halfStroke, rc.bottom - halfStroke)));
+					break;
+				case Ends::semiCircles:
+				default: {
+						pSink->BeginFigure(DPointFromPoint(Point(rcInner.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
+						D2D1_ARC_SEGMENT segment{};
+						segment.point = DPointFromPoint(Point(rcInner.left + halfStroke, rc.bottom - halfStroke));
+						segment.size = D2D1::SizeF(radiusFill, radiusFill);
+						segment.rotationAngle = 0.0f;
+						segment.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
+						segment.arcSize = D2D1_ARC_SIZE_SMALL;
+						pSink->AddArc(segment);
+					}
+					break;
+			}
+
+			switch (rightSide) {
+			case Ends::rightFlat:
+				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.bottom - halfStroke)));
+				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.top + halfStroke)));
+				break;
+			case Ends::rightAngle:
+				pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.bottom - halfStroke)));
+				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.Centre().y)));
+				pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.top + halfStroke)));
+				break;
+			case Ends::semiCircles:
+			default: {
+					pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.bottom - halfStroke)));
+					D2D1_ARC_SEGMENT segment{};
+					segment.point = DPointFromPoint(Point(rcInner.right - halfStroke, rc.top + halfStroke));
+					segment.size = D2D1::SizeF(radiusFill, radiusFill);
+					segment.rotationAngle = 0.0f;
+					segment.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
+					segment.arcSize = D2D1_ARC_SIZE_SMALL;
+					pSink->AddArc(segment);
+				}
+				break;
+			}
+
+			pSink->EndFigure(D2D1_FIGURE_END_CLOSED);
+
+			pSink->Close();
+		}
+		D2DPenColourAlpha(fillStroke.fill.colour);
+		pRenderTarget->FillGeometry(pathGeometry.Get(), pBrush.Get());
+		D2DPenColourAlpha(fillStroke.stroke.colour);
+		pRenderTarget->DrawGeometry(pathGeometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
+	}
+}
+
+void SurfaceD2D::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
+	SurfaceD2D &surfOther = dynamic_cast<SurfaceD2D &>(surfaceSource);
+	ComPtr<ID2D1Bitmap> pBitmap;
+	const HRESULT hr = surfOther.GetBitmap(pBitmap.GetAddressOf());
+	if (SUCCEEDED(hr) && pBitmap) {
+		const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
+		const D2D1_RECT_F rcSource = RectangleFromPRectangle(PRectangle(
+			from.x, from.y, from.x + rc.Width(), from.y + rc.Height()));
+		pRenderTarget->DrawBitmap(pBitmap.Get(), rcDestination, 1.0f,
+			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, rcSource);
+	}
+}
+
+class BlobInline final : public IDWriteInlineObject {
+	XYPOSITION width;
+
+	// IUnknown
+	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
+	STDMETHODIMP_(ULONG)AddRef() override;
+	STDMETHODIMP_(ULONG)Release() override;
+
+	// IDWriteInlineObject
+	COM_DECLSPEC_NOTHROW STDMETHODIMP Draw(
+		void *clientDrawingContext,
+		IDWriteTextRenderer *renderer,
+		FLOAT originX,
+		FLOAT originY,
+		BOOL isSideways,
+		BOOL isRightToLeft,
+		IUnknown *clientDrawingEffect
+		) override;
+	COM_DECLSPEC_NOTHROW STDMETHODIMP GetMetrics(DWRITE_INLINE_OBJECT_METRICS *metrics) override;
+	COM_DECLSPEC_NOTHROW STDMETHODIMP GetOverhangMetrics(DWRITE_OVERHANG_METRICS *overhangs) override;
+	COM_DECLSPEC_NOTHROW STDMETHODIMP GetBreakConditions(
+		DWRITE_BREAK_CONDITION *breakConditionBefore,
+		DWRITE_BREAK_CONDITION *breakConditionAfter) override;
+public:
+	explicit BlobInline(XYPOSITION width_=0.0f) noexcept : width(width_) {
+	}
+};
+
+/// Implement IUnknown
+STDMETHODIMP BlobInline::QueryInterface(REFIID riid, PVOID *ppv) {
+	if (!ppv)
+		return E_POINTER;
+	// Never called so not checked.
+	*ppv = nullptr;
+	if (riid == IID_IUnknown)
+		*ppv = this;
+	if (riid == __uuidof(IDWriteInlineObject))
+		*ppv = this;
+	if (!*ppv)
+		return E_NOINTERFACE;
+	return S_OK;
+}
+
+STDMETHODIMP_(ULONG) BlobInline::AddRef() {
+	// Lifetime tied to Platform methods so ignore any reference operations.
+	return 1;
+}
+
+STDMETHODIMP_(ULONG) BlobInline::Release() {
+	// Lifetime tied to Platform methods so ignore any reference operations.
+	return 1;
+}
+
+/// Implement IDWriteInlineObject
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::Draw(
+	void*,
+	IDWriteTextRenderer*,
+	FLOAT,
+	FLOAT,
+	BOOL,
+	BOOL,
+	IUnknown*) {
+	// Since not performing drawing, not necessary to implement
+	// Could be implemented by calling back into platform-independent code.
+	// This would allow more of the drawing to be mediated through DirectWrite.
+	return S_OK;
+}
+
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetMetrics(
+	DWRITE_INLINE_OBJECT_METRICS *metrics
+) {
+	if (!metrics)
+		return E_POINTER;
+	metrics->width = static_cast<FLOAT>(width);
+	metrics->height = 2;
+	metrics->baseline = 1;
+	metrics->supportsSideways = FALSE;
+	return S_OK;
+}
+
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetOverhangMetrics(
+	DWRITE_OVERHANG_METRICS *overhangs
+) {
+	if (!overhangs)
+		return E_POINTER;
+	overhangs->left = 0;
+	overhangs->top = 0;
+	overhangs->right = 0;
+	overhangs->bottom = 0;
+	return S_OK;
+}
+
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetBreakConditions(
+	DWRITE_BREAK_CONDITION *breakConditionBefore,
+	DWRITE_BREAK_CONDITION *breakConditionAfter
+) {
+	if (!breakConditionBefore || !breakConditionAfter)
+		return E_POINTER;
+	// Since not performing 2D layout, not necessary to implement
+	*breakConditionBefore = DWRITE_BREAK_CONDITION_NEUTRAL;
+	*breakConditionAfter = DWRITE_BREAK_CONDITION_NEUTRAL;
+	return S_OK;
+}
+
+class ScreenLineLayout : public IScreenLineLayout {
+	std::string text;
+	std::wstring buffer;
+	std::vector<BlobInline> blobs;
+	// textLayout depends on blobs so must be declared after blobs so it is destroyed before blobs.
+	TextLayout textLayout;
+	static void FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs);
+	static std::wstring ReplaceRepresentation(std::string_view text);
+	static UINT32 GetPositionInLayout(std::string_view text, size_t position);
+public:
+	explicit ScreenLineLayout(const IScreenLine *screenLine);
+	// Deleted so ScreenLineLayout objects can not be copied
+	ScreenLineLayout(const ScreenLineLayout &) = delete;
+	ScreenLineLayout(ScreenLineLayout &&) = delete;
+	ScreenLineLayout &operator=(const ScreenLineLayout &) = delete;
+	ScreenLineLayout &operator=(ScreenLineLayout &&) = delete;
+	~ScreenLineLayout() noexcept override = default;
+	size_t PositionFromX(XYPOSITION xDistance, bool charPosition) override;
+	XYPOSITION XFromPosition(size_t caretPosition) override;
+	std::vector<Interval> FindRangeIntervals(size_t start, size_t end) override;
+};
+
+// Each char can have its own style, so we fill the textLayout with the textFormat of each char
+
+void ScreenLineLayout::FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs) {
+	// Reserve enough entries up front so they are not moved and the pointers handed
+	// to textLayout remain valid.
+	const ptrdiff_t numRepresentations = screenLine->RepresentationCount();
+	std::string_view text = screenLine->Text();
+	const ptrdiff_t numTabs = std::count(std::begin(text), std::end(text), '\t');
+	blobs.reserve(numRepresentations + numTabs);
+
+	UINT32 layoutPosition = 0;
+
+	for (size_t bytePosition = 0; bytePosition < screenLine->Length();) {
+		const unsigned char uch = screenLine->Text()[bytePosition];
+		const unsigned int byteCount = UTF8BytesOfLead[uch];
+		const UINT32 codeUnits = UTF16LengthFromUTF8ByteCount(byteCount);
+		const DWRITE_TEXT_RANGE textRange = { layoutPosition, codeUnits };
+
+		XYPOSITION representationWidth = screenLine->RepresentationWidth(bytePosition);
+		if ((representationWidth == 0.0f) && (screenLine->Text()[bytePosition] == '\t')) {
+			D2D1_POINT_2F realPt {};
+			DWRITE_HIT_TEST_METRICS realCaretMetrics {};
+			textLayout->HitTestTextPosition(
+				layoutPosition,
+				false, // trailing if false, else leading edge
+				&realPt.x,
+				&realPt.y,
+				&realCaretMetrics
+			);
+
+			const XYPOSITION nextTab = screenLine->TabPositionAfter(realPt.x);
+			representationWidth = nextTab - realPt.x;
+		}
+		if (representationWidth > 0.0f) {
+			blobs.emplace_back(representationWidth);
+			textLayout->SetInlineObject(&blobs.back(), textRange);
+		};
+
+		const FontDirectWrite *pfm =
+			dynamic_cast<const FontDirectWrite *>(screenLine->FontOfPosition(bytePosition));
+		if (!pfm) {
+			throw std::runtime_error("FillTextLayoutFormats: wrong Font type.");
+		}
+
+		const unsigned int fontFamilyNameSize = pfm->pTextFormat->GetFontFamilyNameLength();
+		std::wstring fontFamilyName(fontFamilyNameSize, 0);
+		const HRESULT hrFamily = pfm->pTextFormat->GetFontFamilyName(fontFamilyName.data(), fontFamilyNameSize + 1);
+		if (SUCCEEDED(hrFamily)) {
+			textLayout->SetFontFamilyName(fontFamilyName.c_str(), textRange);
+		}
+
+		textLayout->SetFontSize(pfm->pTextFormat->GetFontSize(), textRange);
+		textLayout->SetFontWeight(pfm->pTextFormat->GetFontWeight(), textRange);
+		textLayout->SetFontStyle(pfm->pTextFormat->GetFontStyle(), textRange);
+
+		const unsigned int localeNameSize = pfm->pTextFormat->GetLocaleNameLength();
+		std::wstring localeName(localeNameSize, 0);
+		const HRESULT hrLocale = pfm->pTextFormat->GetLocaleName(localeName.data(), localeNameSize + 1);
+		if (SUCCEEDED(hrLocale)) {
+			textLayout->SetLocaleName(localeName.c_str(), textRange);
+		}
+
+		textLayout->SetFontStretch(pfm->pTextFormat->GetFontStretch(), textRange);
+
+		IDWriteFontCollection *fontCollection = nullptr;
+		if (SUCCEEDED(pfm->pTextFormat->GetFontCollection(&fontCollection))) {
+			textLayout->SetFontCollection(fontCollection, textRange);
+		}
+
+		bytePosition += byteCount;
+		layoutPosition += codeUnits;
+	}
+
+}
+
+/* Convert to a wide character string and replace tabs with X to stop DirectWrite tab expansion */
+
+std::wstring ScreenLineLayout::ReplaceRepresentation(std::string_view text) {
+	const TextWide wideText(text, CpUtf8);
+	std::wstring ws(wideText.buffer, wideText.tlen);
+	std::replace(ws.begin(), ws.end(), L'\t', L'X');
+	return ws;
+}
+
+// Finds the position in the wide character version of the text.
+
+UINT32 ScreenLineLayout::GetPositionInLayout(std::string_view text, size_t position) {
+	const std::string_view textUptoPosition = text.substr(0, position);
+	return static_cast<UINT32>(UTF16Length(textUptoPosition));
+}
+
+ScreenLineLayout::ScreenLineLayout(const IScreenLine *screenLine) {
+	// If the text is empty, then no need to go through this function
+	if (!screenLine || !screenLine->Length())
+		return;
+
+	text = screenLine->Text();
+
+	// Get textFormat
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(screenLine->FontOfPosition(0));
+	if (!pfm->pTextFormat) {
+		return;
+	}
+
+	// Convert the string to wstring and replace the original control characters with their representative chars.
+	buffer = ReplaceRepresentation(screenLine->Text());
+
+	// Create a text layout
+	textLayout = LayoutCreate(
+		buffer,
+		pfm->pTextFormat.Get(),
+		static_cast<FLOAT>(screenLine->Width()),
+		static_cast<FLOAT>(screenLine->Height()));
+	if (!textLayout) {
+		return;
+	}
+
+	// Fill the textLayout chars with their own formats
+	FillTextLayoutFormats(screenLine, textLayout.Get(), blobs);
+}
+
+// Get the position from the provided x
+
+size_t ScreenLineLayout::PositionFromX(XYPOSITION xDistance, bool charPosition) {
+	if (!textLayout) {
+		return 0;
+	}
+
+	// Returns the text position corresponding to the mouse x,y.
+	// If hitting the trailing side of a cluster, return the
+	// leading edge of the following text position.
+
+	BOOL isTrailingHit = FALSE;
+	BOOL isInside = FALSE;
+	DWRITE_HIT_TEST_METRICS caretMetrics {};
+
+	textLayout->HitTestPoint(
+		static_cast<FLOAT>(xDistance),
+		0.0f,
+		&isTrailingHit,
+		&isInside,
+		&caretMetrics
+	);
+
+	DWRITE_HIT_TEST_METRICS hitTestMetrics {};
+	if (isTrailingHit) {
+		FLOAT caretX = 0.0f;
+		FLOAT caretY = 0.0f;
+
+		// Uses hit-testing to align the current caret position to a whole cluster,
+		// rather than residing in the middle of a base character + diacritic,
+		// surrogate pair, or character + UVS.
+
+		// Align the caret to the nearest whole cluster.
+		textLayout->HitTestTextPosition(
+			caretMetrics.textPosition,
+			false,
+			&caretX,
+			&caretY,
+			&hitTestMetrics
+		);
+	}
+
+	size_t pos;
+	if (charPosition) {
+		pos = isTrailingHit ? hitTestMetrics.textPosition : caretMetrics.textPosition;
+	} else {
+		pos = isTrailingHit ? static_cast<size_t>(hitTestMetrics.textPosition) + hitTestMetrics.length : caretMetrics.textPosition;
+	}
+
+	// Get the character position in original string
+	return UTF8PositionFromUTF16Position(text, pos);
+}
+
+// Finds the point of the caret position
+
+XYPOSITION ScreenLineLayout::XFromPosition(size_t caretPosition) {
+	if (!textLayout) {
+		return 0.0;
+	}
+	// Convert byte positions to wchar_t positions
+	const UINT32 position = GetPositionInLayout(text, caretPosition);
+
+	// Translate text character offset to point x,y.
+	DWRITE_HIT_TEST_METRICS caretMetrics {};
+	D2D1_POINT_2F pt {};
+
+	textLayout->HitTestTextPosition(
+		position,
+		false, // trailing if false, else leading edge
+		&pt.x,
+		&pt.y,
+		&caretMetrics
+	);
+
+	return pt.x;
+}
+
+// Find the selection range rectangles
+
+std::vector<Interval> ScreenLineLayout::FindRangeIntervals(size_t start, size_t end) {
+	std::vector<Interval> ret;
+
+	if (!textLayout || (start == end)) {
+		return ret;
+	}
+
+	// Convert byte positions to wchar_t positions
+	const UINT32 startPos = GetPositionInLayout(text, start);
+	const UINT32 endPos = GetPositionInLayout(text, end);
+
+	// Find selection range length
+	const UINT32 rangeLength = (endPos > startPos) ? (endPos - startPos) : (startPos - endPos);
+
+	// Determine actual number of hit-test ranges
+	UINT32 hitTestCount = 2;	// Simple selection often produces just 2 hits
+
+	// First try with 2 elements and if more needed, allocate.
+	std::vector<DWRITE_HIT_TEST_METRICS> hitTestMetrics(hitTestCount);
+	textLayout->HitTestTextRange(
+		startPos,
+		rangeLength,
+		0, // x
+		0, // y
+		hitTestMetrics.data(),
+		hitTestCount,
+		&hitTestCount
+	);
+
+	if (hitTestCount == 0) {
+		return ret;
+	}
+
+	if (hitTestMetrics.size() < hitTestCount) {
+		// Allocate enough room to return all hit-test metrics.
+		hitTestMetrics.resize(hitTestCount);
+		textLayout->HitTestTextRange(
+			startPos,
+			rangeLength,
+			0, // x
+			0, // y
+			hitTestMetrics.data(),
+			hitTestCount,
+			&hitTestCount
+		);
+	}
+
+	// Get the selection ranges behind the text.
+
+	for (size_t i = 0; i < hitTestCount; ++i) {
+		// Store selection rectangle
+		const DWRITE_HIT_TEST_METRICS &htm = hitTestMetrics[i];
+		const Interval selectionInterval { htm.left, htm.left + htm.width };
+		ret.push_back(selectionInterval);
+	}
+
+	return ret;
+}
+
+std::unique_ptr<IScreenLineLayout> SurfaceD2D::Layout(const IScreenLine *screenLine) {
+	return std::make_unique<ScreenLineLayout>(screenLine);
+}
+
+void SurfaceD2D::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, int codePageOverride, UINT fuOptions) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	if (pfm->pTextFormat && pRenderTarget && pBrush) {
+		// Use Unicode calls
+		const int codePageDraw = codePageOverride ? codePageOverride : pfm->CodePageText(mode.codePage);
+		const TextWide tbuf(text, codePageDraw);
+
+		SetFontQuality(pfm->extraFontFlag);
+		if (fuOptions & ETO_CLIPPED) {
+			const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
+			pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
+		}
+
+		// Explicitly creating a text layout appears a little faster
+		TextLayout pTextLayout = LayoutCreate(
+				tbuf.AsView(),
+				pfm->pTextFormat.Get(),
+				static_cast<FLOAT>(rc.Width()),
+				static_cast<FLOAT>(rc.Height()));
+		if (pTextLayout) {
+			const D2D1_POINT_2F origin = DPointFromPoint(Point(rc.left, ybase - pfm->yAscent));
+			pRenderTarget->DrawTextLayout(origin, pTextLayout.Get(), pBrush.Get(), d2dDrawTextOptions);
+		}
+
+		if (fuOptions & ETO_CLIPPED) {
+			pRenderTarget->PopAxisAlignedClip();
+		}
+	}
+}
+
+void SurfaceD2D::DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	if (pRenderTarget) {
+		FillRectangleAligned(rc, back);
+		D2DPenColourAlpha(fore);
+		DrawTextCommon(rc, font_, ybase, text, 0, ETO_OPAQUE);
+	}
+}
+
+void SurfaceD2D::DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	if (pRenderTarget) {
+		FillRectangleAligned(rc, back);
+		D2DPenColourAlpha(fore);
+		DrawTextCommon(rc, font_, ybase, text, 0, ETO_OPAQUE | ETO_CLIPPED);
+	}
+}
+
+void SurfaceD2D::DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore) {
+	// Avoid drawing spaces in transparent mode
+	for (const char ch : text) {
+		if (ch != ' ') {
+			if (pRenderTarget) {
+				D2DPenColourAlpha(fore);
+				DrawTextCommon(rc, font_, ybase, text, 0, 0);
+			}
+			return;
+		}
+	}
+}
+
+HRESULT MeasurePositions(TextPositions &poses, const TextWide &tbuf, IDWriteTextFormat *pTextFormat) {
+	if (!pTextFormat) {
+		// Unexpected failure like no access to DirectWrite so give up.
+		return E_FAIL;
+	}
+
+	// Initialize poses for safety.
+	std::fill(poses.buffer, poses.buffer + tbuf.tlen, 0.0f);
+	// Create a layout
+	TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pTextFormat);
+	if (!pTextLayout) {
+		return E_FAIL;
+	}
+	VarBuffer<DWRITE_CLUSTER_METRICS, stackBufferLength> cm(tbuf.tlen);
+	UINT32 count = 0;
+	const HRESULT hrGetCluster = pTextLayout->GetClusterMetrics(cm.buffer, tbuf.tlen, &count);
+	if (!SUCCEEDED(hrGetCluster)) {
+		return hrGetCluster;
+	}
+	const DWRITE_CLUSTER_METRICS * const clusterMetrics = cm.buffer;
+	// A cluster may be more than one WCHAR, such as for "ffi" which is a ligature in the Candara font
+	XYPOSITION position = 0.0;
+	int ti=0;
+	for (unsigned int ci=0; ci<count; ci++) {
+		for (unsigned int inCluster=0; inCluster<clusterMetrics[ci].length; inCluster++) {
+			const float proportion = static_cast<float>(inCluster + 1) / clusterMetrics[ci].length;
+			poses.buffer[ti++] = position + clusterMetrics[ci].width * proportion;
+		}
+		position += clusterMetrics[ci].width;
+	}
+	PLATFORM_ASSERT(ti == tbuf.tlen);
+	return S_OK;
+}
+
+void SurfaceD2D::MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	const int codePageText = pfm->CodePageText(mode.codePage);
+	const TextWide tbuf(text, codePageText);
+	TextPositions poses(tbuf.tlen);
+	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
+		return;
+	}
+	if (codePageText == CpUtf8) {
+		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
+		size_t i = 0;
+		for (int ui = 0; ui < tbuf.tlen; ui++) {
+			const unsigned char uch = text[i];
+			const unsigned int byteCount = UTF8BytesOfLead[uch];
+			if (byteCount == 4) {	// Non-BMP
+				ui++;
+			}
+			for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui<tbuf.tlen); bytePos++) {
+				positions[i++] = poses.buffer[ui];
+			}
+		}
+		const XYPOSITION lastPos = (i > 0) ? positions[i - 1] : 0.0;
+		while (i<text.length()) {
+			positions[i++] = lastPos;
+		}
+	} else if (!IsDBCSCodePage(codePageText)) {
+
+		// One char per position
+		PLATFORM_ASSERT(text.length() == static_cast<size_t>(tbuf.tlen));
+		for (int kk=0; kk<tbuf.tlen; kk++) {
+			positions[kk] = poses.buffer[kk];
+		}
+
+	} else {
+
+		// May be one or two bytes per position
+		int ui = 0;
+		for (size_t i=0; i<text.length() && ui<tbuf.tlen;) {
+			positions[i] = poses.buffer[ui];
+			if (DBCSIsLeadByte(codePageText, text[i])) {
+				positions[i+1] = poses.buffer[ui];
+				i += 2;
+			} else {
+				i++;
+			}
+
+			ui++;
+		}
+	}
+}
+
+XYPOSITION SurfaceD2D::WidthText(const Font *font_, std::string_view text) {
+	FLOAT width = 1.0;
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	if (pfm->pTextFormat) {
+		const TextWide tbuf(text, pfm->CodePageText(mode.codePage));
+		// Create a layout
+		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
+			DWRITE_TEXT_METRICS textMetrics;
+			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
+				width = textMetrics.widthIncludingTrailingWhitespace;
+		}
+	}
+	return width;
+}
+
+void SurfaceD2D::DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	if (pRenderTarget) {
+		FillRectangleAligned(rc, back);
+		D2DPenColourAlpha(fore);
+		DrawTextCommon(rc, font_, ybase, text, CpUtf8, ETO_OPAQUE);
+	}
+}
+
+void SurfaceD2D::DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	if (pRenderTarget) {
+		FillRectangleAligned(rc, back);
+		D2DPenColourAlpha(fore);
+		DrawTextCommon(rc, font_, ybase, text, CpUtf8, ETO_OPAQUE | ETO_CLIPPED);
+	}
+}
+
+void SurfaceD2D::DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore) {
+	// Avoid drawing spaces in transparent mode
+	for (const char ch : text) {
+		if (ch != ' ') {
+			if (pRenderTarget) {
+				D2DPenColourAlpha(fore);
+				DrawTextCommon(rc, font_, ybase, text, CpUtf8, 0);
+			}
+			return;
+		}
+	}
+}
+
+void SurfaceD2D::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	const TextWide tbuf(text, CpUtf8);
+	TextPositions poses(tbuf.tlen);
+	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
+		return;
+	}
+	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
+	size_t i = 0;
+	for (int ui = 0; ui < tbuf.tlen; ui++) {
+		const unsigned char uch = text[i];
+		const unsigned int byteCount = UTF8BytesOfLead[uch];
+		if (byteCount == 4) {	// Non-BMP
+			ui++;
+			PLATFORM_ASSERT(ui < tbuf.tlen);
+		}
+		for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui < tbuf.tlen); bytePos++) {
+			positions[i++] = poses.buffer[ui];
+		}
+	}
+	const XYPOSITION lastPos = (i > 0) ? positions[i - 1] : 0.0;
+	while (i < text.length()) {
+		positions[i++] = lastPos;
+	}
+}
+
+XYPOSITION SurfaceD2D::WidthTextUTF8(const Font * font_, std::string_view text) {
+	FLOAT width = 1.0;
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	if (pfm->pTextFormat) {
+		const TextWide tbuf(text, CpUtf8);
+		// Create a layout
+		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
+			DWRITE_TEXT_METRICS textMetrics;
+			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
+				width = textMetrics.widthIncludingTrailingWhitespace;
+		}
+	}
+	return width;
+}
+
+XYPOSITION SurfaceD2D::Ascent(const Font *font_) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	return std::ceil(pfm->yAscent);
+}
+
+XYPOSITION SurfaceD2D::Descent(const Font *font_) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	return std::ceil(pfm->yDescent);
+}
+
+XYPOSITION SurfaceD2D::InternalLeading(const Font *font_) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	return std::floor(pfm->yInternalLeading);
+}
+
+XYPOSITION SurfaceD2D::Height(const Font *font_) {
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	return std::ceil(pfm->yAscent) + std::ceil(pfm->yDescent);
+}
+
+XYPOSITION SurfaceD2D::AverageCharWidth(const Font *font_) {
+	FLOAT width = 1.0;
+	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
+	if (pfm->pTextFormat) {
+		// Create a layout
+		static constexpr std::wstring_view wsvAllAlpha = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		if (TextLayout pTextLayout = LayoutCreate(wsvAllAlpha, pfm->pTextFormat.Get())) {
+			DWRITE_TEXT_METRICS textMetrics;
+			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
+				width = textMetrics.width / wsvAllAlpha.length();
+		}
+	}
+	return width;
+}
+
+void SurfaceD2D::SetClip(PRectangle rc) {
+	if (pRenderTarget) {
+		const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
+		pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
+		clipsActive++;
+	}
+}
+
+void SurfaceD2D::PopClip() {
+	if (pRenderTarget) {
+		PLATFORM_ASSERT(clipsActive > 0);
+		pRenderTarget->PopAxisAlignedClip();
+		clipsActive--;
+	}
+}
+
+void SurfaceD2D::FlushCachedState() {
+}
+
+void SurfaceD2D::FlushDrawing() {
+	if (pRenderTarget) {
+		pRenderTarget->Flush();
+	}
+}
+
+void SurfaceD2D::SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) {
+	renderingParams = std::move(renderingParams_);
+}
+
+#endif
+
+}
+
+namespace Scintilla::Internal {
+
+#if defined(USE_D2D)
+IDWriteFactory1 *pIDWriteFactory = nullptr;
+ID2D1Factory1 *pD2DFactory = nullptr;
+
+HRESULT CreateD3D(D3D11Device &device) noexcept {
+	device = nullptr;
+	if (!fnDCD) {
+		return E_FAIL;
+	}
+
+	const D3D_FEATURE_LEVEL featureLevels[] = {
+		D3D_FEATURE_LEVEL_11_1,
+		D3D_FEATURE_LEVEL_11_0,
+		D3D_FEATURE_LEVEL_10_1,
+		D3D_FEATURE_LEVEL_10_0,
+		D3D_FEATURE_LEVEL_9_3,
+		D3D_FEATURE_LEVEL_9_2,
+		D3D_FEATURE_LEVEL_9_1
+	};
+
+	// Create device.
+	// Try for a hardware device but, if that fails, fall back to the Warp software rasterizer.
+	ComPtr<ID3D11Device> upDevice;
+	HRESULT hr = S_OK;
+	const D3D_DRIVER_TYPE typesToTry[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP };
+	for (const D3D_DRIVER_TYPE type : typesToTry) {
+		hr = fnDCD(nullptr,
+			type,
+			{},
+			D3D11_CREATE_DEVICE_BGRA_SUPPORT,
+			featureLevels,
+			ARRAYSIZE(featureLevels),
+			D3D11_SDK_VERSION,
+			upDevice.GetAddressOf(),
+			nullptr,
+			nullptr);
+		if (SUCCEEDED(hr))
+			break;
+	}
+	if (FAILED(hr)) {
+		Platform::DebugPrintf("Failed to create D3D11 device 0x%lx\n", hr);
+		return hr;
+	}
+
+	// Convert from D3D11 to D3D11.1
+	hr = upDevice.As(&device);
+	if (FAILED(hr)) {
+		Platform::DebugPrintf("Failed to create D3D11.1 device 0x%lx\n", hr);
+	}
+	return hr;
+}
+
+bool LoadD2D() noexcept {
+	static std::once_flag once;
+	try {
+		std::call_once(once, LoadD2DOnce);
+	}
+	catch (...) {
+		// ignore
+	}
+	return pIDWriteFactory && pD2DFactory;
+}
+
+void ReleaseD2D() noexcept {
+	ReleaseUnknown(pIDWriteFactory);
+	ReleaseUnknown(pD2DFactory);
+	ReleaseLibrary(hDLLDWrite);
+	ReleaseLibrary(hDLLD3D);
+	ReleaseLibrary(hDLLD2D);
+}
+
+HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept {
+	return pD2DFactory->CreateDCRenderTarget(renderTargetProperties, dcRT.ReleaseAndGetAddressOf());
+}
+
+BrushSolid BrushSolidCreate(ID2D1RenderTarget *pTarget, COLORREF colour) noexcept {
+	BrushSolid brush;
+	const D2D_COLOR_F col = ColorFromColourAlpha(ColourRGBA::FromRGB(colour));
+	if (FAILED(pTarget->CreateSolidColorBrush(col, brush.GetAddressOf()))) {
+		return {};
+	}
+	return brush;
+}
+
+Geometry GeometryCreate() noexcept {
+	Geometry geometry;
+	if (FAILED(pD2DFactory->CreatePathGeometry(geometry.GetAddressOf()))) {
+		return {};
+	}
+	return geometry;
+}
+
+GeometrySink GeometrySinkCreate(ID2D1PathGeometry *geometry) noexcept {
+	GeometrySink sink;
+	if (FAILED(geometry->Open(sink.GetAddressOf()))) {
+		return {};
+	}
+	return sink;
+}
+
+StrokeStyle StrokeStyleCreate(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties) noexcept {
+	StrokeStyle strokeStyle;
+	const HRESULT hr = pD2DFactory->CreateStrokeStyle(
+		strokeStyleProperties, nullptr, 0, strokeStyle.GetAddressOf());
+	if (FAILED(hr)) {
+		return {};
+	}
+	return strokeStyle;
+}
+
+TextLayout LayoutCreate(std::wstring_view wsv, IDWriteTextFormat *pTextFormat, FLOAT maxWidth, FLOAT maxHeight) noexcept {
+	TextLayout layout;
+	const HRESULT hr = pIDWriteFactory->CreateTextLayout(wsv.data(), static_cast<UINT32>(wsv.length()),
+		pTextFormat, maxWidth, maxHeight, layout.GetAddressOf());
+	if (FAILED(hr)) {
+		return {};
+	}
+	return layout;
+}
+
+#endif
+
+std::shared_ptr<Font> Font::Allocate(const FontParameters &fp) {
+#if defined(USE_D2D)
+	if (fp.technology != Technology::Default) {
+		return std::make_shared<FontDirectWrite>(fp);
+	}
+#endif
+	return FontGDI_Allocate(fp);
+}
+
+std::unique_ptr<Surface> Surface::Allocate([[maybe_unused]] Technology technology) {
+#if defined(USE_D2D)
+	if (technology != Technology::Default) {
+		return std::make_unique<SurfaceD2D>();
+	}
+#endif
+	return SurfaceGDI_Allocate();
+}
+
+}
diff --git a/src/scintilla/win32/SurfaceD2D.h b/src/scintilla/win32/SurfaceD2D.h
new file mode 100644
index 000000000..8025069db
--- /dev/null
+++ b/src/scintilla/win32/SurfaceD2D.h
@@ -0,0 +1,50 @@
+// Scintilla source code edit control
+/** @file SurfaceD2D.h
+ ** Definitions for drawing to Direct2D on Windows.
+ **/
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SURFACED2D_H
+#define SURFACED2D_H
+
+namespace Scintilla::Internal {
+
+extern bool LoadD2D() noexcept;
+extern void ReleaseD2D() noexcept;
+extern ID2D1Factory1 *pD2DFactory;
+extern IDWriteFactory1 *pIDWriteFactory;
+
+using DCRenderTarget = ComPtr<ID2D1DCRenderTarget>;
+
+using D3D11Device = ComPtr<ID3D11Device1>;
+
+HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept;
+extern HRESULT CreateD3D(D3D11Device &device) noexcept;
+
+using WriteRenderingParams = ComPtr<IDWriteRenderingParams1>;
+
+struct RenderingParams {
+	WriteRenderingParams defaultRenderingParams;
+	WriteRenderingParams customRenderingParams;
+};
+
+struct ISetRenderingParams {
+	virtual void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) = 0;
+};
+
+using BrushSolid = ComPtr<ID2D1SolidColorBrush>;
+using Geometry = ComPtr<ID2D1PathGeometry>;
+using GeometrySink = ComPtr<ID2D1GeometrySink>;
+using StrokeStyle = ComPtr<ID2D1StrokeStyle>;
+using TextLayout = ComPtr<IDWriteTextLayout>;
+
+BrushSolid BrushSolidCreate(ID2D1RenderTarget *pTarget, COLORREF colour) noexcept;
+Geometry GeometryCreate() noexcept;
+GeometrySink GeometrySinkCreate(ID2D1PathGeometry *geometry) noexcept;
+StrokeStyle StrokeStyleCreate(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties) noexcept;
+TextLayout LayoutCreate(std::wstring_view wsv, IDWriteTextFormat *pTextFormat, FLOAT maxWidth=10000.0F, FLOAT maxHeight=1000.0F) noexcept;
+
+}
+
+#endif
diff --git a/src/scintilla/win32/SurfaceGDI.cxx b/src/scintilla/win32/SurfaceGDI.cxx
new file mode 100644
index 000000000..9df4deb97
--- /dev/null
+++ b/src/scintilla/win32/SurfaceGDI.cxx
@@ -0,0 +1,889 @@
+// Scintilla source code edit control
+/** @file SurfaceGDI.cxx
+ ** Implementation of drawing to GDI on Windows.
+ **/
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+#include <ctime>
+#include <cmath>
+#include <climits>
+
+#include <string_view>
+#include <vector>
+#include <map>
+#include <optional>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <mutex>
+
+// Want to use std::min and std::max so don't want Windows.h version of min and max
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0A00
+#undef WINVER
+#define WINVER 0x0A00
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#include <commctrl.h>
+#include <richedit.h>
+#include <windowsx.h>
+#include <shellscalingapi.h>
+
+#include "ScintillaTypes.h"
+
+#include "Debugging.h"
+#include "Geometry.h"
+#include "Platform.h"
+#include "XPM.h"
+#include "UniConversion.h"
+#include "DBCS.h"
+
+#include "WinTypes.h"
+#include "PlatWin.h"
+#include "SurfaceGDI.h"
+
+using namespace Scintilla;
+using namespace Scintilla::Internal;
+
+// All file hidden in unnamed namespace except for FontGDI_Allocate and SurfaceGDI_Allocate
+namespace {
+
+constexpr Supports SupportsGDI[] = {
+	Supports::PixelModification,
+};
+
+constexpr BYTE Win32MapFontQuality(FontQuality extraFontFlag) noexcept {
+	switch (extraFontFlag & FontQuality::QualityMask) {
+
+	case FontQuality::QualityNonAntialiased:
+		return NONANTIALIASED_QUALITY;
+
+	case FontQuality::QualityAntialiased:
+		return ANTIALIASED_QUALITY;
+
+	case FontQuality::QualityLcdOptimized:
+		return CLEARTYPE_QUALITY;
+
+	default:
+		return DEFAULT_QUALITY;
+	}
+}
+
+void SetLogFont(LOGFONTW &lf, const char *faceName, CharacterSet characterSet, XYPOSITION size, FontWeight weight, bool italic, FontQuality extraFontFlag) {
+	lf = LOGFONTW();
+	// The negative is to allow for leading
+	lf.lfHeight = -(std::abs(std::lround(size)));
+	lf.lfWeight = static_cast<LONG>(weight);
+	lf.lfItalic = italic ? 1 : 0;
+	lf.lfCharSet = static_cast<BYTE>(characterSet);
+	lf.lfQuality = Win32MapFontQuality(extraFontFlag);
+	UTF16FromUTF8(faceName, lf.lfFaceName, LF_FACESIZE);
+}
+
+struct FontGDI : public FontWin {
+	HFONT hfont = {};
+	CharacterSet characterSet = CharacterSet::Ansi;
+	FontGDI(HFONT hfont_, CharacterSet characterSet_) noexcept : hfont(hfont_), characterSet(characterSet_) {
+		// Takes ownership and deletes the font
+	}
+	explicit FontGDI(const FontParameters &fp) : characterSet(fp.characterSet) {
+		LOGFONTW lf;
+		SetLogFont(lf, fp.faceName, fp.characterSet, fp.size, fp.weight, fp.italic, fp.extraFontFlag);
+		hfont = ::CreateFontIndirectW(&lf);
+	}
+	// Deleted so FontGDI objects can not be copied.
+	FontGDI(const FontGDI &) = delete;
+	FontGDI(FontGDI &&) = delete;
+	FontGDI &operator=(const FontGDI &) = delete;
+	FontGDI &operator=(FontGDI &&) = delete;
+	~FontGDI() noexcept override {
+		if (hfont)
+			::DeleteObject(hfont);
+	}
+	[[nodiscard]] HFONT HFont() const noexcept override {
+		// Duplicating hfont
+		LOGFONTW lf = {};
+		if (0 == ::GetObjectW(hfont, sizeof(lf), &lf)) {
+			return {};
+		}
+		return ::CreateFontIndirectW(&lf);
+	}
+	[[nodiscard]] std::unique_ptr<FontWin> Duplicate() const override {
+		HFONT hfontCopy = HFont();
+		return std::make_unique<FontGDI>(hfontCopy, characterSet);
+	}
+	[[nodiscard]] CharacterSet GetCharacterSet() const noexcept override {
+		return characterSet;
+	}
+};
+
+class SurfaceGDI : public Surface {
+	SurfaceMode mode;
+	HDC hdc{};
+	bool hdcOwned = false;
+	HPEN pen{};
+	HPEN penOld{};
+	HBRUSH brush{};
+	HBRUSH brushOld{};
+	HFONT fontOld{};
+	HBITMAP bitmap{};
+	HBITMAP bitmapOld{};
+
+	int logPixelsY = USER_DEFAULT_SCREEN_DPI;
+
+	static constexpr int maxWidthMeasure = INT_MAX;
+	// There appears to be a 16 bit string length limit in GDI on NT.
+	static constexpr int maxLenText = 65535;
+
+	void PenColour(ColourRGBA fore, XYPOSITION widthStroke) noexcept;
+
+	void BrushColour(ColourRGBA back) noexcept;
+	void SetFont(const Font *font_);
+	void Clear() noexcept;
+
+public:
+	SurfaceGDI() noexcept = default;
+	SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
+	// Deleted so SurfaceGDI objects can not be copied.
+	SurfaceGDI(const SurfaceGDI &) = delete;
+	SurfaceGDI(SurfaceGDI &&) = delete;
+	SurfaceGDI &operator=(const SurfaceGDI &) = delete;
+	SurfaceGDI &operator=(SurfaceGDI &&) = delete;
+
+	~SurfaceGDI() noexcept override;
+
+	void Init(WindowID wid) override;
+	void Init(SurfaceID sid, WindowID wid) override;
+	std::unique_ptr<Surface> AllocatePixMap(int width, int height) override;
+
+	void SetMode(SurfaceMode mode_) override;
+
+	void Release() noexcept override;
+	int SupportsFeature(Supports feature) noexcept override;
+	bool Initialised() override;
+	int LogPixelsY() override;
+	int PixelDivisions() override;
+	int DeviceHeightFont(int points) override;
+	void LineDraw(Point start, Point end, Stroke stroke) override;
+	void PolyLine(const Point *pts, size_t npts, Stroke stroke) override;
+	void Polygon(const Point *pts, size_t npts, FillStroke fillStroke) override;
+	void RectangleDraw(PRectangle rc, FillStroke fillStroke) override;
+	void RectangleFrame(PRectangle rc, Stroke stroke) override;
+	void FillRectangle(PRectangle rc, Fill fill) override;
+	void FillRectangleAligned(PRectangle rc, Fill fill) override;
+	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
+	void RoundedRectangle(PRectangle rc, FillStroke fillStroke) override;
+	void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) override;
+	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
+	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
+	void Ellipse(PRectangle rc, FillStroke fillStroke) override;
+	void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) override;
+	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;
+
+	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;
+
+	void DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
+	void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
+	void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) override;
+	XYPOSITION WidthText(const Font *font_, std::string_view text) override;
+
+	void DrawTextCommonUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
+	void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
+	void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
+	void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) override;
+	XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) override;
+
+	XYPOSITION Ascent(const Font *font_) override;
+	XYPOSITION Descent(const Font *font_) override;
+	XYPOSITION InternalLeading(const Font *font_) override;
+	XYPOSITION Height(const Font *font_) override;
+	XYPOSITION AverageCharWidth(const Font *font_) override;
+
+	void SetClip(PRectangle rc) override;
+	void PopClip() override;
+	void FlushCachedState() override;
+	void FlushDrawing() override;
+};
+
+SurfaceGDI::SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
+	hdc = ::CreateCompatibleDC(hdcCompatible);
+	hdcOwned = true;
+	bitmap = ::CreateCompatibleBitmap(hdcCompatible, width, height);
+	bitmapOld = SelectBitmap(hdc, bitmap);
+	::SetTextAlign(hdc, TA_BASELINE);
+	mode = mode_;
+	logPixelsY = logPixelsY_;
+}
+
+SurfaceGDI::~SurfaceGDI() noexcept {
+	Clear();
+}
+
+void SurfaceGDI::Clear() noexcept {
+	if (penOld) {
+		::SelectObject(hdc, penOld);
+		::DeleteObject(pen);
+		penOld = {};
+	}
+	pen = {};
+	if (brushOld) {
+		::SelectObject(hdc, brushOld);
+		::DeleteObject(brush);
+		brushOld = {};
+	}
+	brush = {};
+	if (fontOld) {
+		// Fonts are not deleted as they are owned by a Font object
+		::SelectObject(hdc, fontOld);
+		fontOld = {};
+	}
+	if (bitmapOld) {
+		::SelectObject(hdc, bitmapOld);
+		::DeleteObject(bitmap);
+		bitmapOld = {};
+	}
+	bitmap = {};
+	if (hdcOwned) {
+		::DeleteDC(hdc);
+		hdc = {};
+		hdcOwned = false;
+	}
+}
+
+void SurfaceGDI::Release() noexcept {
+	Clear();
+}
+
+int SurfaceGDI::SupportsFeature(Supports feature) noexcept {
+	for (const Supports f : SupportsGDI) {
+		if (f == feature)
+			return 1;
+	}
+	return 0;
+}
+
+bool SurfaceGDI::Initialised() {
+	return hdc;
+}
+
+void SurfaceGDI::Init(WindowID wid) {
+	Release();
+	hdc = ::CreateCompatibleDC({});
+	hdcOwned = true;
+	::SetTextAlign(hdc, TA_BASELINE);
+	logPixelsY = DpiForWindow(wid);
+}
+
+void SurfaceGDI::Init(SurfaceID sid, WindowID wid) {
+	Release();
+	hdc = static_cast<HDC>(sid);
+	::SetTextAlign(hdc, TA_BASELINE);
+	// Windows on screen are scaled but printers are not.
+	const bool printing = ::GetDeviceCaps(hdc, TECHNOLOGY) != DT_RASDISPLAY;
+	logPixelsY = printing ? ::GetDeviceCaps(hdc, LOGPIXELSY) : DpiForWindow(wid);
+}
+
+std::unique_ptr<Surface> SurfaceGDI::AllocatePixMap(int width, int height) {
+	return std::make_unique<SurfaceGDI>(hdc, width, height, mode, logPixelsY);
+}
+
+void SurfaceGDI::SetMode(SurfaceMode mode_) {
+	mode = mode_;
+}
+
+void SurfaceGDI::PenColour(ColourRGBA fore, XYPOSITION widthStroke) noexcept {
+	if (pen) {
+		::SelectObject(hdc, penOld);
+		::DeleteObject(pen);
+		pen = {};
+		penOld = {};
+	}
+	const DWORD penWidth = std::lround(widthStroke);
+	const COLORREF penColour = fore.OpaqueRGB();
+	if (widthStroke > 1) {
+		const LOGBRUSH brushParameters{ BS_SOLID, penColour, 0 };
+		pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
+			penWidth,
+			&brushParameters,
+			0,
+			nullptr);
+	} else {
+		pen = ::CreatePen(PS_INSIDEFRAME, penWidth, penColour);
+	}
+	penOld = SelectPen(hdc, pen);
+}
+
+void SurfaceGDI::BrushColour(ColourRGBA back) noexcept {
+	if (brush) {
+		::SelectObject(hdc, brushOld);
+		::DeleteObject(brush);
+		brush = {};
+		brushOld = {};
+	}
+	brush = ::CreateSolidBrush(back.OpaqueRGB());
+	brushOld = SelectBrush(hdc, brush);
+}
+
+void SurfaceGDI::SetFont(const Font *font_) {
+	const FontGDI *pfm = dynamic_cast<const FontGDI *>(font_);
+	PLATFORM_ASSERT(pfm);
+	if (!pfm) {
+		throw std::runtime_error("SurfaceGDI::SetFont: wrong Font type.");
+	}
+	if (fontOld) {
+		SelectFont(hdc, pfm->hfont);
+	} else {
+		fontOld = SelectFont(hdc, pfm->hfont);
+	}
+}
+
+int SurfaceGDI::LogPixelsY() {
+	return logPixelsY;
+}
+
+int SurfaceGDI::PixelDivisions() {
+	// Win32 uses device pixels.
+	return 1;
+}
+
+int SurfaceGDI::DeviceHeightFont(int points) {
+	return ::MulDiv(points, LogPixelsY(), pointsPerInch);
+}
+
+void SurfaceGDI::LineDraw(Point start, Point end, Stroke stroke) {
+	PenColour(stroke.colour, stroke.width);
+	::MoveToEx(hdc, std::lround(std::floor(start.x)), std::lround(std::floor(start.y)), nullptr);
+	::LineTo(hdc, std::lround(std::floor(end.x)), std::lround(std::floor(end.y)));
+}
+
+void SurfaceGDI::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
+	PLATFORM_ASSERT(npts > 1);
+	if (npts <= 1) {
+		return;
+	}
+	PenColour(stroke.colour, stroke.width);
+	std::vector<POINT> outline;
+	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
+	::Polyline(hdc, outline.data(), static_cast<int>(npts));
+}
+
+void SurfaceGDI::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
+	PenColour(fillStroke.stroke.colour.WithoutAlpha(), fillStroke.stroke.width);
+	BrushColour(fillStroke.fill.colour.WithoutAlpha());
+	std::vector<POINT> outline;
+	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
+	::Polygon(hdc, outline.data(), static_cast<int>(npts));
+}
+
+void SurfaceGDI::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
+	RectangleFrame(rc, fillStroke.stroke);
+	FillRectangle(rc.Inset(fillStroke.stroke.width), fillStroke.fill.colour);
+}
+
+void SurfaceGDI::RectangleFrame(PRectangle rc, Stroke stroke) {
+	BrushColour(stroke.colour);
+	const RECT rcw = RectFromPRectangle(rc);
+	::FrameRect(hdc, &rcw, brush);
+}
+
+void SurfaceGDI::FillRectangle(PRectangle rc, Fill fill) {
+	if (fill.colour.IsOpaque()) {
+		// Using ExtTextOut rather than a FillRect ensures that no dithering occurs.
+		// There is no need to allocate a brush either.
+		const RECT rcw = RectFromPRectangle(rc);
+		::SetBkColor(hdc, fill.colour.OpaqueRGB());
+		::ExtTextOut(hdc, rcw.left, rcw.top, ETO_OPAQUE, &rcw, TEXT(""), 0, nullptr);
+	} else {
+		AlphaRectangle(rc, 0, FillStroke(fill.colour));
+	}
+}
+
+void SurfaceGDI::FillRectangleAligned(PRectangle rc, Fill fill) {
+	FillRectangle(PixelAlign(rc, 1), fill);
+}
+
+void SurfaceGDI::FillRectangle(PRectangle rc, Surface &surfacePattern) {
+	HBRUSH br{};
+	if (SurfaceGDI *psgdi = dynamic_cast<SurfaceGDI *>(&surfacePattern); psgdi && psgdi->bitmap) {
+		br = ::CreatePatternBrush(psgdi->bitmap);
+	} else {	// Something is wrong so display in red
+		br = ::CreateSolidBrush(RGB(0xff, 0, 0));
+	}
+	const RECT rcw = RectFromPRectangle(rc);
+	::FillRect(hdc, &rcw, br);
+	::DeleteObject(br);
+}
+
+void SurfaceGDI::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
+	PenColour(fillStroke.stroke.colour, fillStroke.stroke.width);
+	BrushColour(fillStroke.fill.colour);
+	const RECT rcw = RectFromPRectangle(rc);
+	constexpr int cornerSize = 8;
+	::RoundRect(hdc,
+		rcw.left + 1, rcw.top,
+		rcw.right - 1, rcw.bottom,
+		cornerSize, cornerSize);
+}
+
+// DIBSection is bitmap with some drawing operations used by SurfaceGDI.
+class DIBSection {
+	GDIBitMap bm;
+	SIZE size{};
+	DWORD *pixels = nullptr;
+public:
+	DIBSection(HDC hdc, SIZE size_) noexcept;
+	explicit operator bool() const noexcept {
+		return bm && pixels;
+	}
+	[[nodiscard]] DWORD *Pixels() const noexcept {
+		return pixels;
+	}
+	[[nodiscard]] unsigned char *Bytes() const noexcept {
+		return reinterpret_cast<unsigned char *>(pixels);
+	}
+	[[nodiscard]] HDC DC() const noexcept {
+		return bm.DC();
+	}
+	void SetPixel(LONG x, LONG y, DWORD value) noexcept {
+		PLATFORM_ASSERT(x >= 0);
+		PLATFORM_ASSERT(y >= 0);
+		PLATFORM_ASSERT(x < size.cx);
+		PLATFORM_ASSERT(y < size.cy);
+		pixels[(y * size.cx) + x] = value;
+	}
+	void SetSymmetric(LONG x, LONG y, DWORD value) noexcept;
+};
+
+DIBSection::DIBSection(HDC hdc, SIZE size_) noexcept : size(size_) {
+	// -size.y makes bitmap start from top
+	bm.Create(hdc, size.cx, -size.cy, &pixels);
+}
+
+void DIBSection::SetSymmetric(LONG x, LONG y, DWORD value) noexcept {
+	// Plot a point symmetrically to all 4 quadrants
+	const LONG xSymmetric = size.cx - 1 - x;
+	const LONG ySymmetric = size.cy - 1 - y;
+	SetPixel(x, y, value);
+	SetPixel(xSymmetric, y, value);
+	SetPixel(x, ySymmetric, value);
+	SetPixel(xSymmetric, ySymmetric, value);
+}
+
+ColourRGBA GradientValue(const std::vector<ColourStop> &stops, XYPOSITION proportion) noexcept {
+	for (size_t stop = 0; stop < stops.size() - 1; stop++) {
+		// Loop through each pair of stops
+		const XYPOSITION positionStart = stops[stop].position;
+		const XYPOSITION positionEnd = stops[stop + 1].position;
+		if ((proportion >= positionStart) && (proportion <= positionEnd)) {
+			const XYPOSITION proportionInPair = (proportion - positionStart) /
+				(positionEnd - positionStart);
+			return stops[stop].colour.MixedWith(stops[stop + 1].colour, proportionInPair);
+		}
+	}
+	// Loop should always find a value
+	return ColourRGBA();
+}
+
+constexpr DWORD dwordFromBGRA(byte b, byte g, byte r, byte a) noexcept {
+	constexpr int aShift = 24;
+	constexpr int rShift = 16;
+	constexpr int gShift = 8;
+	return (a << aShift) | (r << rShift) | (g << gShift) | b;
+}
+
+constexpr byte AlphaScaled(unsigned char component, unsigned int alpha) noexcept {
+	constexpr byte maxByte = 0xFFU;
+	return (component * alpha / maxByte) & maxByte;
+}
+
+constexpr DWORD dwordMultiplied(ColourRGBA colour) noexcept {
+	return dwordFromBGRA(
+		AlphaScaled(colour.GetBlue(), colour.GetAlpha()),
+		AlphaScaled(colour.GetGreen(), colour.GetAlpha()),
+		AlphaScaled(colour.GetRed(), colour.GetAlpha()),
+		colour.GetAlpha());
+}
+
+constexpr BLENDFUNCTION mergeAlpha = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
+
+void SurfaceGDI::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) {
+	// TODO: Implement strokeWidth
+	const RECT rcw = RectFromPRectangle(rc);
+	const SIZE size = SizeOfRect(rcw);
+
+	if (size.cx > 0) {
+
+		DIBSection section(hdc, size);
+
+		if (section) {
+
+			// Ensure not distorted too much by corners when small
+			const LONG corner = std::min(static_cast<LONG>(cornerSize), (std::min(size.cx, size.cy) / 2) - 2);
+
+			constexpr DWORD valEmpty = dwordFromBGRA(0, 0, 0, 0);
+			const DWORD valFill = dwordMultiplied(fillStroke.fill.colour);
+			const DWORD valOutline = dwordMultiplied(fillStroke.stroke.colour);
+
+			// Draw a framed rectangle
+			for (int y = 0; y < size.cy; y++) {
+				for (int x = 0; x < size.cx; x++) {
+					if ((x == 0) || (x == size.cx - 1) || (y == 0) || (y == size.cy - 1)) {
+						section.SetPixel(x, y, valOutline);
+					} else {
+						section.SetPixel(x, y, valFill);
+					}
+				}
+			}
+
+			// Make the corners transparent
+			for (LONG c = 0; c < corner; c++) {
+				for (LONG x = 0; x < c + 1; x++) {
+					section.SetSymmetric(x, c - x, valEmpty);
+				}
+			}
+
+			// Draw the corner frame pieces
+			for (LONG x = 1; x < corner; x++) {
+				section.SetSymmetric(x, corner - x, valOutline);
+			}
+
+			GdiAlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
+		}
+	} else {
+		BrushColour(fillStroke.stroke.colour);
+		FrameRect(hdc, &rcw, brush);
+	}
+}
+
+void SurfaceGDI::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
+
+	const RECT rcw = RectFromPRectangle(rc);
+	const SIZE size = SizeOfRect(rcw);
+
+	DIBSection section(hdc, size);
+
+	if (section) {
+
+		if (options == GradientOptions::topToBottom) {
+			for (LONG y = 0; y < size.cy; y++) {
+				// Find y/height proportional colour
+				const XYPOSITION proportion = y / (rc.Height() - 1.0f);
+				const ColourRGBA mixed = GradientValue(stops, proportion);
+				const DWORD valFill = dwordMultiplied(mixed);
+				for (LONG x = 0; x < size.cx; x++) {
+					section.SetPixel(x, y, valFill);
+				}
+			}
+		} else {
+			for (LONG x = 0; x < size.cx; x++) {
+				// Find x/width proportional colour
+				const XYPOSITION proportion = x / (rc.Width() - 1.0f);
+				const ColourRGBA mixed = GradientValue(stops, proportion);
+				const DWORD valFill = dwordMultiplied(mixed);
+				for (LONG y = 0; y < size.cy; y++) {
+					section.SetPixel(x, y, valFill);
+				}
+			}
+		}
+
+		GdiAlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
+	}
+}
+
+void SurfaceGDI::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
+	if (rc.Width() > 0) {
+		if (rc.Width() > width)
+			rc.left += std::floor((rc.Width() - width) / 2);
+		rc.right = rc.left + width;
+		if (rc.Height() > height)
+			rc.top += std::floor((rc.Height() - height) / 2);
+		rc.bottom = rc.top + height;
+
+		const SIZE size{ width, height };
+		DIBSection section(hdc, size);
+		if (section) {
+			RGBAImage::BGRAFromRGBA(section.Bytes(), pixelsImage, static_cast<size_t>(width) * height);
+			GdiAlphaBlend(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
+				static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), section.DC(),
+				0, 0, width, height, mergeAlpha);
+		}
+	}
+}
+
+void SurfaceGDI::Ellipse(PRectangle rc, FillStroke fillStroke) {
+	PenColour(fillStroke.stroke.colour, fillStroke.stroke.width);
+	BrushColour(fillStroke.fill.colour);
+	const RECT rcw = RectFromPRectangle(rc);
+	::Ellipse(hdc, rcw.left, rcw.top, rcw.right, rcw.bottom);
+}
+
+void SurfaceGDI::Stadium(PRectangle rc, FillStroke fillStroke, [[maybe_unused]] Ends ends) {
+	// TODO: Implement properly - the rectangle is just a placeholder
+	RectangleDraw(rc, fillStroke);
+}
+
+void SurfaceGDI::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
+	::BitBlt(hdc,
+		static_cast<int>(rc.left), static_cast<int>(rc.top),
+		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()),
+		dynamic_cast<SurfaceGDI &>(surfaceSource).hdc,
+		static_cast<int>(from.x), static_cast<int>(from.y), SRCCOPY);
+}
+
+std::unique_ptr<IScreenLineLayout> SurfaceGDI::Layout(const IScreenLine *) {
+	return {};
+}
+
+using TextPositionsI = VarBuffer<int, stackBufferLength>;
+
+void SurfaceGDI::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
+	SetFont(font_);
+	const RECT rcw = RectFromPRectangle(rc);
+	const int x = static_cast<int>(rc.left);
+	const int yBaseInt = static_cast<int>(ybase);
+
+	if (mode.codePage == CpUtf8) {
+		const TextWide tbuf(text, mode.codePage);
+		::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
+	} else {
+		::ExtTextOutA(hdc, x, yBaseInt, fuOptions, &rcw, text.data(), static_cast<UINT>(text.length()), nullptr);
+	}
+}
+
+void SurfaceGDI::DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	::SetTextColor(hdc, fore.OpaqueRGB());
+	::SetBkColor(hdc, back.OpaqueRGB());
+	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE);
+}
+
+void SurfaceGDI::DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	::SetTextColor(hdc, fore.OpaqueRGB());
+	::SetBkColor(hdc, back.OpaqueRGB());
+	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
+}
+
+void SurfaceGDI::DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore) {
+	// Avoid drawing spaces in transparent mode
+	for (const char ch : text) {
+		if (ch != ' ') {
+			::SetTextColor(hdc, fore.OpaqueRGB());
+			::SetBkMode(hdc, TRANSPARENT);
+			DrawTextCommon(rc, font_, ybase, text, 0);
+			::SetBkMode(hdc, OPAQUE);
+			return;
+		}
+	}
+}
+
+void SurfaceGDI::MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) {
+	// Zero positions to avoid random behaviour on failure.
+	std::fill(positions, positions + text.length(), 0.0f);
+	SetFont(font_);
+	SIZE sz = { 0,0 };
+	int fit = 0;
+	int i = 0;
+	const int len = static_cast<int>(text.length());
+	if (mode.codePage == CpUtf8) {
+		const TextWide tbuf(text, mode.codePage);
+		TextPositionsI poses(tbuf.tlen);
+		if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
+			// Failure
+			return;
+		}
+		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
+		for (int ui = 0; ui < fit; ui++) {
+			const unsigned char uch = text[i];
+			const unsigned int byteCount = UTF8BytesOfLead[uch];
+			if (byteCount == 4) {	// Non-BMP
+				ui++;
+			}
+			for (unsigned int bytePos = 0; (bytePos < byteCount) && (i < len); bytePos++) {
+				positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
+			}
+		}
+	} else {
+		TextPositionsI poses(len);
+		if (!::GetTextExtentExPointA(hdc, text.data(), len, maxWidthMeasure, &fit, poses.buffer, &sz)) {
+			// Eeek - a NULL DC or other foolishness could cause this.
+			return;
+		}
+		while (i < fit) {
+			positions[i] = static_cast<XYPOSITION>(poses.buffer[i]);
+			i++;
+		}
+	}
+	// If any positions not filled in then use the last position for them
+	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
+	std::fill(positions + i, positions + text.length(), lastPos);
+}
+
+XYPOSITION SurfaceGDI::WidthText(const Font *font_, std::string_view text) {
+	SetFont(font_);
+	SIZE sz = { 0,0 };
+	if (!(mode.codePage == CpUtf8)) {
+		::GetTextExtentPoint32A(hdc, text.data(), std::min(static_cast<int>(text.length()), maxLenText), &sz);
+	} else {
+		const TextWide tbuf(text, mode.codePage);
+		::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
+	}
+	return static_cast<XYPOSITION>(sz.cx);
+}
+
+void SurfaceGDI::DrawTextCommonUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
+	SetFont(font_);
+	const RECT rcw = RectFromPRectangle(rc);
+	const int x = static_cast<int>(rc.left);
+	const int yBaseInt = static_cast<int>(ybase);
+
+	const TextWide tbuf(text, CpUtf8);
+	::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
+}
+
+void SurfaceGDI::DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	::SetTextColor(hdc, fore.OpaqueRGB());
+	::SetBkColor(hdc, back.OpaqueRGB());
+	DrawTextCommonUTF8(rc, font_, ybase, text, ETO_OPAQUE);
+}
+
+void SurfaceGDI::DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore, ColourRGBA back) {
+	::SetTextColor(hdc, fore.OpaqueRGB());
+	::SetBkColor(hdc, back.OpaqueRGB());
+	DrawTextCommonUTF8(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
+}
+
+void SurfaceGDI::DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
+	ColourRGBA fore) {
+	// Avoid drawing spaces in transparent mode
+	for (const char ch : text) {
+		if (ch != ' ') {
+			::SetTextColor(hdc, fore.OpaqueRGB());
+			::SetBkMode(hdc, TRANSPARENT);
+			DrawTextCommonUTF8(rc, font_, ybase, text, 0);
+			::SetBkMode(hdc, OPAQUE);
+			return;
+		}
+	}
+}
+
+void SurfaceGDI::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) {
+	// Zero positions to avoid random behaviour on failure.
+	std::fill(positions, positions + text.length(), 0.0f);
+	SetFont(font_);
+	SIZE sz = { 0,0 };
+	int fit = 0;
+	int i = 0;
+	const int len = static_cast<int>(text.length());
+	const TextWide tbuf(text, CpUtf8);
+	TextPositionsI poses(tbuf.tlen);
+	if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
+		// Failure
+		return;
+	}
+	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
+	for (int ui = 0; ui < fit; ui++) {
+		const unsigned char uch = text[i];
+		const unsigned int byteCount = UTF8BytesOfLead[uch];
+		if (byteCount == 4) {	// Non-BMP
+			ui++;
+		}
+		for (unsigned int bytePos = 0; (bytePos < byteCount) && (i < len); bytePos++) {
+			positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
+		}
+	}
+	// If any positions not filled in then use the last position for them
+	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
+	std::fill(positions + i, positions + text.length(), lastPos);
+}
+
+XYPOSITION SurfaceGDI::WidthTextUTF8(const Font *font_, std::string_view text) {
+	SetFont(font_);
+	SIZE sz = { 0,0 };
+	const TextWide tbuf(text, CpUtf8);
+	::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
+	return static_cast<XYPOSITION>(sz.cx);
+}
+
+XYPOSITION SurfaceGDI::Ascent(const Font *font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmAscent);
+}
+
+XYPOSITION SurfaceGDI::Descent(const Font *font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmDescent);
+}
+
+XYPOSITION SurfaceGDI::InternalLeading(const Font *font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmInternalLeading);
+}
+
+XYPOSITION SurfaceGDI::Height(const Font *font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmHeight);
+}
+
+XYPOSITION SurfaceGDI::AverageCharWidth(const Font *font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmAveCharWidth);
+}
+
+void SurfaceGDI::SetClip(PRectangle rc) {
+	::SaveDC(hdc);
+	::IntersectClipRect(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
+		static_cast<int>(rc.right), static_cast<int>(rc.bottom));
+}
+
+void SurfaceGDI::PopClip() {
+	::RestoreDC(hdc, -1);
+}
+
+void SurfaceGDI::FlushCachedState() {
+	pen = {};
+	brush = {};
+}
+
+void SurfaceGDI::FlushDrawing() {
+}
+
+}
+
+namespace Scintilla::Internal {
+
+std::shared_ptr<Font> FontGDI_Allocate(const FontParameters &fp) {
+	return std::make_shared<FontGDI>(fp);
+}
+
+std::unique_ptr<Surface> SurfaceGDI_Allocate() {
+	return std::make_unique<SurfaceGDI>();
+}
+
+}
diff --git a/src/scintilla/win32/SurfaceGDI.h b/src/scintilla/win32/SurfaceGDI.h
new file mode 100644
index 000000000..990b052fc
--- /dev/null
+++ b/src/scintilla/win32/SurfaceGDI.h
@@ -0,0 +1,18 @@
+// Scintilla source code edit control
+/** @file SurfaceGDI.h
+ ** Definitions for drawing to GDI on Windows.
+ **/
+// Copyright 2025 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SURFACEGDI_H
+#define SURFACEGDI_H
+
+namespace Scintilla::Internal {
+
+std::shared_ptr<Font> FontGDI_Allocate(const FontParameters &fp);
+std::unique_ptr<Surface> SurfaceGDI_Allocate();
+
+}
+
+#endif
diff --git a/src/scintilla/win32/WinTypes.h b/src/scintilla/win32/WinTypes.h
index c0d6c558d..f2bbfd5f9 100644
--- a/src/scintilla/win32/WinTypes.h
+++ b/src/scintilla/win32/WinTypes.h
@@ -52,6 +52,13 @@ inline T DLLFunction(HMODULE hModule, LPCSTR lpProcName) noexcept {
 	return fp;
 }
 
+inline void ReleaseLibrary(HMODULE &hLib) noexcept {
+	if (hLib) {
+		FreeLibrary(hLib);
+		hLib = {};
+	}
+}
+
 }
 
 #endif
diff --git a/src/scintilla/win32/deps.mak b/src/scintilla/win32/deps.mak
index 8c36e8ddb..c9f208701 100644
--- a/src/scintilla/win32/deps.mak
+++ b/src/scintilla/win32/deps.mak
@@ -3,6 +3,19 @@ $(DIR_O)/HanjaDic.o: \
 	HanjaDic.cxx \
 	WinTypes.h \
 	HanjaDic.h
+$(DIR_O)/ListBox.o: \
+	ListBox.cxx \
+	../include/ScintillaTypes.h \
+	../src/Debugging.h \
+	../src/Geometry.h \
+	../src/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	WinTypes.h \
+	PlatWin.h \
+	ListBox.h \
+	SurfaceD2D.h
 $(DIR_O)/PlatWin.o: \
 	PlatWin.cxx \
 	../include/ScintillaTypes.h \
@@ -13,7 +26,9 @@ $(DIR_O)/PlatWin.o: \
 	../src/UniConversion.h \
 	../src/DBCS.h \
 	WinTypes.h \
-	PlatWin.h
+	PlatWin.h \
+	ListBox.h \
+	SurfaceD2D.h
 $(DIR_O)/ScintillaDLL.o: \
 	ScintillaDLL.cxx \
 	../include/ScintillaTypes.h \
@@ -29,6 +44,7 @@ $(DIR_O)/ScintillaWin.o: \
 	../src/Debugging.h \
 	../src/Geometry.h \
 	../src/Platform.h \
+	../src/CharacterType.h \
 	../src/CharacterCategoryMap.h \
 	../src/Position.h \
 	../src/UniqueString.h \
@@ -49,6 +65,7 @@ $(DIR_O)/ScintillaWin.o: \
 	../src/Document.h \
 	../src/CaseConvert.h \
 	../src/UniConversion.h \
+	../src/DBCS.h \
 	../src/Selection.h \
 	../src/PositionCache.h \
 	../src/EditModel.h \
@@ -60,8 +77,34 @@ $(DIR_O)/ScintillaWin.o: \
 	../src/ScintillaBase.h \
 	WinTypes.h \
 	PlatWin.h \
+	SurfaceD2D.h \
 	HanjaDic.h \
 	ScintillaWin.h
+$(DIR_O)/SurfaceD2D.o: \
+	SurfaceD2D.cxx \
+	../include/ScintillaTypes.h \
+	../src/Debugging.h \
+	../src/Geometry.h \
+	../src/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	WinTypes.h \
+	PlatWin.h \
+	SurfaceGDI.h \
+	SurfaceD2D.h
+$(DIR_O)/SurfaceGDI.o: \
+	SurfaceGDI.cxx \
+	../include/ScintillaTypes.h \
+	../src/Debugging.h \
+	../src/Geometry.h \
+	../src/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	WinTypes.h \
+	PlatWin.h \
+	SurfaceGDI.h
 $(DIR_O)/AutoComplete.o: \
 	../src/AutoComplete.cxx \
 	../include/ScintillaTypes.h \
diff --git a/src/scintilla/win32/nmdeps.mak b/src/scintilla/win32/nmdeps.mak
index 961aba5ee..5d5d35c8a 100644
--- a/src/scintilla/win32/nmdeps.mak
+++ b/src/scintilla/win32/nmdeps.mak
@@ -3,6 +3,19 @@ $(DIR_O)/HanjaDic.obj: \
 	HanjaDic.cxx \
 	WinTypes.h \
 	HanjaDic.h
+$(DIR_O)/ListBox.obj: \
+	ListBox.cxx \
+	../include/ScintillaTypes.h \
+	../src/Debugging.h \
+	../src/Geometry.h \
+	../src/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	WinTypes.h \
+	PlatWin.h \
+	ListBox.h \
+	SurfaceD2D.h
 $(DIR_O)/PlatWin.obj: \
 	PlatWin.cxx \
 	../include/ScintillaTypes.h \
@@ -13,7 +26,9 @@ $(DIR_O)/PlatWin.obj: \
 	../src/UniConversion.h \
 	../src/DBCS.h \
 	WinTypes.h \
-	PlatWin.h
+	PlatWin.h \
+	ListBox.h \
+	SurfaceD2D.h
 $(DIR_O)/ScintillaDLL.obj: \
 	ScintillaDLL.cxx \
 	../include/ScintillaTypes.h \
@@ -29,6 +44,7 @@ $(DIR_O)/ScintillaWin.obj: \
 	../src/Debugging.h \
 	../src/Geometry.h \
 	../src/Platform.h \
+	../src/CharacterType.h \
 	../src/CharacterCategoryMap.h \
 	../src/Position.h \
 	../src/UniqueString.h \
@@ -49,6 +65,7 @@ $(DIR_O)/ScintillaWin.obj: \
 	../src/Document.h \
 	../src/CaseConvert.h \
 	../src/UniConversion.h \
+	../src/DBCS.h \
 	../src/Selection.h \
 	../src/PositionCache.h \
 	../src/EditModel.h \
@@ -60,8 +77,34 @@ $(DIR_O)/ScintillaWin.obj: \
 	../src/ScintillaBase.h \
 	WinTypes.h \
 	PlatWin.h \
+	SurfaceD2D.h \
 	HanjaDic.h \
 	ScintillaWin.h
+$(DIR_O)/SurfaceD2D.obj: \
+	SurfaceD2D.cxx \
+	../include/ScintillaTypes.h \
+	../src/Debugging.h \
+	../src/Geometry.h \
+	../src/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	WinTypes.h \
+	PlatWin.h \
+	SurfaceGDI.h \
+	SurfaceD2D.h
+$(DIR_O)/SurfaceGDI.obj: \
+	SurfaceGDI.cxx \
+	../include/ScintillaTypes.h \
+	../src/Debugging.h \
+	../src/Geometry.h \
+	../src/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	WinTypes.h \
+	PlatWin.h \
+	SurfaceGDI.h
 $(DIR_O)/AutoComplete.obj: \
 	../src/AutoComplete.cxx \
 	../include/ScintillaTypes.h \
diff --git a/src/scintilla/win32/scintilla.mak b/src/scintilla/win32/scintilla.mak
index 5034c8d0d..596b2b767 100644
--- a/src/scintilla/win32/scintilla.mak
+++ b/src/scintilla/win32/scintilla.mak
@@ -10,7 +10,7 @@
 
 .SUFFIXES: .cxx
 
-DIR_O=.
+DIR_O=obj
 DIR_BIN=..\bin
 
 COMPONENT=$(DIR_BIN)\Scintilla.dll
@@ -18,6 +18,10 @@ LIBSCI=$(DIR_BIN)\libscintilla.lib
 
 LD=link
 
+!IF "$(PLATFORM:64=)" == "arm"
+ARM64=1
+!ENDIF
+
 !IFDEF SUPPORT_XP
 ADD_DEFINE=-D_USING_V110_SDK71_
 # Different subsystems for 32-bit and 64-bit Windows XP so detect based on Platform
@@ -28,10 +32,11 @@ SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.02
 SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.01
 !ENDIF
 !ELSE
-CETCOMPAT=-CETCOMPAT
 !IFDEF ARM64
 ADD_DEFINE=-D_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1
 SUBSYSTEM=-SUBSYSTEM:WINDOWS,10.00
+!ELSE
+CETCOMPAT=-CETCOMPAT
 !ENDIF
 !ENDIF
 
@@ -65,7 +70,10 @@ CXXFLAGS=$(CXXFLAGS) $(CXXNDEBUG)
 INCLUDES=-I../include -I../src
 CXXFLAGS=$(CXXFLAGS) $(INCLUDES)
 
-all:	$(COMPONENT) $(LIBSCI)
+all:	$(DIR_O) $(COMPONENT) $(LIBSCI)
+
+$(DIR_O):
+	mkdir "$(DIR_O)" 2>NUL || cd .
 
 clean:
 	-del /q $(DIR_O)\*.obj $(DIR_O)\*.pdb $(DIR_O)\*.asm $(COMPONENT) \
@@ -113,6 +121,9 @@ SRC_OBJS=\
 COMPONENT_OBJS = \
 	$(DIR_O)\HanjaDic.obj \
 	$(DIR_O)\PlatWin.obj \
+	$(DIR_O)\ListBox.obj \
+	$(DIR_O)\SurfaceGDI.obj \
+	$(DIR_O)\SurfaceD2D.obj \
 	$(DIR_O)\ScintillaBase.obj \
 	$(DIR_O)\ScintillaWin.obj \
 	$(SRC_OBJS)