Index: lexilla/.gitattributes
===================================================================
--- lexilla/.gitattributes	(版本 0)
+++ lexilla/.gitattributes	(版本 45)
@@ -0,0 +1,95 @@
+* -text
+**.cxx text
+**.cpp text
+**.c text
+**.h text
+**.hpp text
+**.m text
+**.mm text
+**.iface text
+**.template text
+**.mk text
+**.mk text
+**.py text
+**.rc text
+**.css text
+**.html text
+**.bat text
+**.bsh text
+**.zsh text
+**.mak text
+**.def text
+**.manifest text
+**.properties text
+**.props text
+**.session text
+**.styled text
+**.folded text
+**.adoc text
+**.asp text
+**.aspx text
+**.php text
+**.vb text
+**.vbs text
+**.asm text
+**.cob text
+**.cmake text
+**.d text
+**.dart text
+**.diff text
+**.erl text
+**.f text
+**.gd text
+**.gui text
+**.iss text
+**.jl text
+**.json text
+**.lua text
+**.m3 text
+**.matlab text
+**.ml text
+**.nim text
+**.nix text
+**.octave text
+**.p text
+**.pas text
+**.pl text
+**.p6 text
+**.ps1 text
+**.r text
+**.rb text
+**.roff text
+**.rs text
+**.sql text
+**.st text
+**.tcl text
+**.toml text
+**.tsql text
+**.err text
+**.mms text
+**.tex text
+**.fs text
+**.vh text
+**.vhd text
+**.x12 text
+**.xml text
+**.yaml text
+**.zig text
+**.md text
+**.txt text
+**.pch text
+**.hg* text
+**.dsp text
+**.pbxproj text
+**.plist text
+**.xcworkspacedata text
+**.pro text
+**.gen text
+**makefile text
+**.bmp binary
+**.cur binary
+**.ico binary
+**.jpg binary
+**.png binary
+**.sh text eol=lf
+tgzsrc text eol=lf
Index: lexilla/.github/workflows/build-check-win32.yml
===================================================================
--- lexilla/.github/workflows/build-check-win32.yml	(版本 44)
+++ lexilla/.github/workflows/build-check-win32.yml	(版本 45)
@@ -3,16 +3,24 @@
 on: [push]
 
 jobs:
+    # Compile for amd64 and cross-compile for arm64. Tests run only for amd64.
     build:
 
         runs-on: windows-latest
 
+        strategy:
+          matrix:
+            arch:
+              - amd64
+              - amd64_arm64
+        env:
+          TEST: ${{ matrix.arch == 'amd64' && 'test' || '' }}
         steps:
         - uses: actions/checkout@v4
         - name: Preparing nmake
           uses: ilammy/msvc-dev-cmd@v1
           with:
-            arch: x64
+            arch: ${{ matrix.arch }}
         - name: Install Scintilla source
           run: |
               pwd
@@ -24,7 +32,7 @@
         - name: Unit Test
           run: |
               cd test/unit
-              nmake -f test.mak DEBUG=1 test
+              nmake -f test.mak DEBUG=1 $env:TEST
               cd ../..
         - name: Build Lexilla
           run: |
@@ -33,14 +41,15 @@
               cd ..
         - uses: actions/upload-artifact@v4
           with:
-              name: lexilla.dll
+              name: lexilla${{ matrix.arch == 'amd64_arm64' && '-arm64' || '' }}.dll
               path: bin/lexilla.dll
         - name: Test lexing and folding
           run: |
               cd test
-              nmake -f testlexers.mak DEBUG=1 test
+              nmake -f testlexers.mak DEBUG=1 $env:TEST
               cd ..
         - name: CheckLexilla C Example
+          if: matrix.arch == 'amd64'
           run: |
               cd examples/CheckLexilla
               cl -MP CheckLexilla.c -I ../../include -Fe: CheckLexilla
Index: lexilla/access/LexillaAccess.cxx
===================================================================
--- lexilla/access/LexillaAccess.cxx	(版本 44)
+++ lexilla/access/LexillaAccess.cxx	(版本 45)
@@ -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 @@
 			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 @@
 			}
 		}
 	}
-	return std::string();
+	return {};
 }
 
 std::vector<std::string> Lexilla::LibraryProperties() {
Index: lexilla/cppcheck.suppress
===================================================================
--- lexilla/cppcheck.suppress	(版本 44)
+++ lexilla/cppcheck.suppress	(版本 45)
@@ -70,6 +70,7 @@
 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
@@ -76,6 +77,7 @@
 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 @@
 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 @@
 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
@@ -188,7 +192,6 @@
 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.
Index: lexilla/doc/Lexilla.html
===================================================================
--- lexilla/doc/Lexilla.html	(版本 44)
+++ lexilla/doc/Lexilla.html	(版本 45)
@@ -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="20250402" />
     <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.4<br />
+           Site last modified April 2 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +78,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.4.4 fixes a problem when building for ARM654 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>
Index: lexilla/doc/LexillaDoc.html
===================================================================
--- lexilla/doc/LexillaDoc.html	(版本 44)
+++ lexilla/doc/LexillaDoc.html	(版本 45)
@@ -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">
 <!--
Index: lexilla/doc/LexillaDownload.html
===================================================================
--- lexilla/doc/LexillaDownload.html	(版本 44)
+++ lexilla/doc/LexillaDownload.html	(版本 45)
@@ -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/lexilla544.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/lexilla543.tgz">
+	<a href="https://www.scintilla.org/lexilla544.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.4.3
+       Release 5.4.4
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@
        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/lexilla544.zip">zip format</a> (1.4M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/lexilla544.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>
Index: lexilla/doc/LexillaHistory.html
===================================================================
--- lexilla/doc/LexillaHistory.html	(版本 44)
+++ lexilla/doc/LexillaHistory.html	(版本 45)
@@ -590,10 +590,23 @@
 	<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/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>
     <ul>
Index: lexilla/lexers/LexBash.cxx
===================================================================
--- lexilla/lexers/LexBash.cxx	(版本 44)
+++ lexilla/lexers/LexBash.cxx	(版本 45)
@@ -109,7 +109,7 @@
 	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 @@
 		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 @@
 						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 @@
 				}
 				// 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);
Index: lexilla/lexers/LexYAML.cxx
===================================================================
--- lexilla/lexers/LexYAML.cxx	(版本 44)
+++ lexilla/lexers/LexYAML.cxx	(版本 45)
@@ -48,11 +48,11 @@
 	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 @@
 	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;
Index: lexilla/src/Lexilla/Info.plist
===================================================================
--- lexilla/src/Lexilla/Info.plist	(版本 44)
+++ lexilla/src/Lexilla/Info.plist	(版本 45)
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>5.4.3</string>
+	<string>5.4.4</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
Index: lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
===================================================================
--- lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj	(版本 44)
+++ lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj	(版本 45)
@@ -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.4;
 				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.4;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
Index: lexilla/src/LexillaVersion.rc
===================================================================
--- lexilla/src/LexillaVersion.rc	(版本 44)
+++ lexilla/src/LexillaVersion.rc	(版本 45)
@@ -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.4"
+#define VERSION_WORDS 5, 4, 4, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
Index: lexilla/src/lexilla.mak
===================================================================
--- lexilla/src/lexilla.mak	(版本 44)
+++ lexilla/src/lexilla.mak	(版本 45)
@@ -15,7 +15,7 @@
 
 .SUFFIXES: .cxx
 
-DIR_O=.
+DIR_O=obj
 DIR_BIN=..\bin
 
 LEXILLA=$(DIR_BIN)\lexilla.dll
@@ -23,6 +23,10 @@
 
 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.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,8 +73,11 @@
 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 \
 	$(DIR_O)\*.res $(DIR_BIN)\*.map $(DIR_BIN)\*.exp $(DIR_BIN)\*.pdb $(DIR_BIN)\lexilla.lib \
Index: lexilla/test/testlexers.mak
===================================================================
--- lexilla/test/testlexers.mak	(版本 44)
+++ lexilla/test/testlexers.mak	(版本 45)
@@ -17,7 +17,7 @@
 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
 
Index: lexilla/version.txt
===================================================================
--- lexilla/version.txt	(版本 44)
+++ lexilla/version.txt	(版本 45)
@@ -1 +1 @@
-543
\ No newline at end of file
+544
\ No newline at end of file
Index: scintilla/.hg_archival.txt
===================================================================
--- scintilla/.hg_archival.txt	(版本 44)
+++ scintilla/.hg_archival.txt	(版本 45)
@@ -1,4 +1,4 @@
 repo: bdf8c3ef2fb01ea24578e726337888e706d10b92
-node: 5cb9af9b3103ffa3c8c4e3c15887191486de260f
+node: 68ddcf0a91ee2763cfc148925917bf609b355948
 branch: default
-tag: rel-5-5-5
+tag: rel-5-5-6
Index: scintilla/.hgtags
===================================================================
--- scintilla/.hgtags	(版本 44)
+++ scintilla/.hgtags	(版本 45)
@@ -213,3 +213,4 @@
 8d3fb4e5905454cc46a33141d07654dddfeb3b44 rel-5-5-2
 7bc37e9e9de31baf3725e083ee1b937e54856856 rel-5-5-3
 56bc6f0e611a5f46529ff4d2f47ddb1b922d743e rel-5-5-4
+5cb9af9b3103ffa3c8c4e3c15887191486de260f rel-5-5-5
Index: scintilla/call/ScintillaCall.cxx
===================================================================
--- scintilla/call/ScintillaCall.cxx	(版本 44)
+++ scintilla/call/ScintillaCall.cxx	(版本 45)
@@ -2819,8 +2819,8 @@
 	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) {
Index: scintilla/cocoa/Scintilla/Info.plist
===================================================================
--- scintilla/cocoa/Scintilla/Info.plist	(版本 44)
+++ scintilla/cocoa/Scintilla/Info.plist	(版本 45)
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>5.5.5</string>
+	<string>5.5.6</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
Index: scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
===================================================================
--- scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj	(版本 44)
+++ scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj	(版本 45)
@@ -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.6;
 				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.6;
 				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.6;
 				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.6;
 				DEAD_CODE_STRIPPING = YES;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
Index: scintilla/doc/ScintillaDoc.html
===================================================================
--- scintilla/doc/ScintillaDoc.html	(版本 44)
+++ scintilla/doc/ScintillaDoc.html	(版本 45)
@@ -130,7 +130,7 @@
 
     <h1>Scintilla Documentation</h1>
 
-    <p>Last edited 12 February 2025 NH</p>
+    <p>Last edited 29 March 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 />
@@ -3583,117 +3583,140 @@
 <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></td>
+    <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>
@@ -4960,6 +4983,8 @@
     </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>
 
@@ -9043,21 +9068,24 @@
 	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 */
Index: scintilla/doc/ScintillaDownload.html
===================================================================
--- scintilla/doc/ScintillaDownload.html	(版本 44)
+++ scintilla/doc/ScintillaDownload.html	(版本 45)
@@ -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/scintilla556.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/scintilla555.tgz">
+	<a href="https://www.scintilla.org/scintilla556.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.5.5
+       Release 5.5.6
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@
        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/scintilla556.zip">zip format</a> (1.8M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/scintilla556.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>
Index: scintilla/doc/ScintillaHistory.html
===================================================================
--- scintilla/doc/ScintillaHistory.html	(版本 44)
+++ scintilla/doc/ScintillaHistory.html	(版本 45)
@@ -585,10 +585,57 @@
 	<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/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>
     <ul>
Index: scintilla/doc/ScintillaUsage.html
===================================================================
--- scintilla/doc/ScintillaUsage.html	(版本 44)
+++ scintilla/doc/ScintillaUsage.html	(版本 45)
@@ -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;
Index: scintilla/doc/index.html
===================================================================
--- scintilla/doc/index.html	(版本 44)
+++ scintilla/doc/index.html	(版本 45)
@@ -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="20250402" />
     <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.6<br />
+           Site last modified April 2 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +77,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <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>
Index: scintilla/include/Scintilla.h
===================================================================
--- scintilla/include/Scintilla.h	(版本 44)
+++ scintilla/include/Scintilla.h	(版本 45)
@@ -1419,10 +1419,12 @@
 	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 +1432,12 @@
 	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,8 +1447,8 @@
 	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 */
@@ -1451,7 +1455,7 @@
 	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 */
 };
 
Index: scintilla/include/Scintilla.iface
===================================================================
--- scintilla/include/Scintilla.iface	(版本 44)
+++ scintilla/include/Scintilla.iface	(版本 45)
@@ -2755,7 +2755,7 @@
 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)
Index: scintilla/include/ScintillaCall.h
===================================================================
--- scintilla/include/ScintillaCall.h	(版本 44)
+++ scintilla/include/ScintillaCall.h	(版本 45)
@@ -750,7 +750,7 @@
 	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);
Index: scintilla/include/ScintillaStructures.h
===================================================================
--- scintilla/include/ScintillaStructures.h	(版本 44)
+++ scintilla/include/ScintillaStructures.h	(版本 45)
@@ -88,10 +88,12 @@
 	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 @@
 	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,8 +116,8 @@
 	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 */
@@ -120,7 +124,7 @@
 	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 */
 };
 
Index: scintilla/qt/ScintillaEdit/ScintillaEdit.pro
===================================================================
--- scintilla/qt/ScintillaEdit/ScintillaEdit.pro	(版本 44)
+++ scintilla/qt/ScintillaEdit/ScintillaEdit.pro	(版本 45)
@@ -13,7 +13,7 @@
 CONFIG += lib_bundle
 CONFIG += c++1z
 
-VERSION = 5.5.5
+VERSION = 5.5.6
 
 SOURCES += \
     ScintillaEdit.cpp \
Index: scintilla/qt/ScintillaEditBase/PlatQt.cpp
===================================================================
--- scintilla/qt/ScintillaEditBase/PlatQt.cpp	(版本 44)
+++ scintilla/qt/ScintillaEditBase/PlatQt.cpp	(版本 45)
@@ -667,7 +667,7 @@
 				  ColourRGBA back)
 {
 	SetClip(rc);
-	DrawTextNoClip(rc, font, ybase, text, fore, back);
+	DrawTextNoClipUTF8(rc, font, ybase, text, fore, back);
 	PopClip();
 }
 
Index: scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
===================================================================
--- scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp	(版本 44)
+++ scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp	(版本 45)
@@ -373,6 +373,12 @@
 	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());
@@ -810,7 +816,7 @@
 			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:
Index: scintilla/qt/ScintillaEditBase/ScintillaEditBase.h
===================================================================
--- scintilla/qt/ScintillaEditBase/ScintillaEditBase.h	(版本 44)
+++ scintilla/qt/ScintillaEditBase/ScintillaEditBase.h	(版本 45)
@@ -141,6 +141,7 @@
 	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;
Index: scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
===================================================================
--- scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro	(版本 44)
+++ scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro	(版本 45)
@@ -13,7 +13,7 @@
 CONFIG += lib_bundle
 CONFIG += c++1z
 
-VERSION = 5.5.5
+VERSION = 5.5.6
 
 SOURCES += \
     PlatQt.cpp \
Index: scintilla/scripts/HeaderOrder.txt
===================================================================
--- scintilla/scripts/HeaderOrder.txt	(版本 44)
+++ scintilla/scripts/HeaderOrder.txt	(版本 45)
@@ -158,6 +158,9 @@
 // win32
 #include "WinTypes.h"
 #include "PlatWin.h"
+#include "ListBox.h"
+#include "SurfaceGDI.h"
+#include "SurfaceD2D.h"
 #include "HanjaDic.h"
 #include "ScintillaWin.h"
 
Index: scintilla/src/CaseConvert.cxx
===================================================================
--- scintilla/src/CaseConvert.cxx	(版本 44)
+++ scintilla/src/CaseConvert.cxx	(版本 45)
@@ -605,7 +605,7 @@
 			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 @@
 
 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 @@
 
 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;
Index: scintilla/src/DBCS.cxx
===================================================================
--- scintilla/src/DBCS.cxx	(版本 44)
+++ scintilla/src/DBCS.cxx	(版本 45)
@@ -5,6 +5,11 @@
 // 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;
@@ -15,33 +20,68 @@
 	// 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 +91,25 @@
 	}
 }
 
+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];
+}
+
+}
Index: scintilla/src/DBCS.h
===================================================================
--- scintilla/src/DBCS.h	(版本 44)
+++ scintilla/src/DBCS.h	(版本 45)
@@ -10,17 +10,44 @@
 
 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 {
+	constexpr unsigned int highStart = 0x80U;
+	constexpr unsigned int byteMultiply = 0x100U;
+	const unsigned char uch1 = ch1;
+	const unsigned char uch2 = ch2;
+	return ((uch1 - highStart) * byteMultiply) + 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
Index: scintilla/src/Document.cxx
===================================================================
--- scintilla/src/Document.cxx	(版本 44)
+++ scintilla/src/Document.cxx	(版本 45)
@@ -620,13 +620,16 @@
 	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();
@@ -1229,8 +1232,8 @@
 }
 
 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 +1253,16 @@
 	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,8 +1283,27 @@
 		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.
@@ -1287,6 +1313,8 @@
 	// 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) {
@@ -1702,25 +1730,6 @@
 	}
 }
 
-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 +2373,7 @@
 			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 +2406,7 @@
 						// 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 +2432,7 @@
 			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 +2461,7 @@
 						// 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 +2486,7 @@
 		} 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++) {
@@ -2975,7 +2984,9 @@
 	return pos;
 }
 
-static char BraceOpposite(char ch) noexcept {
+namespace {
+
+constexpr char BraceOpposite(char ch) noexcept {
 	switch (ch) {
 	case '(':
 		return ')';
@@ -2998,6 +3009,8 @@
 	}
 }
 
+}
+
 // 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);
@@ -3075,7 +3088,7 @@
 		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 +3114,13 @@
 		pdoc(pdoc_), end(end_) {
 	}
 
-	char CharAt(Sci::Position index) const noexcept override {
+	[[nodiscard]] char CharAt(Sci::Position index) const noexcept override {
 		if (index < 0 || index >= end)
 			return 0;
 		else
 			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 +3163,10 @@
 	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 +3191,11 @@
 	// 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 +3204,7 @@
 	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 +3256,10 @@
 			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
Index: scintilla/src/Editor.cxx
===================================================================
--- scintilla/src/Editor.cxx	(版本 44)
+++ scintilla/src/Editor.cxx	(版本 45)
@@ -106,8 +106,17 @@
 	    && ((mh.modificationType & finalMask) == finalMask);
 }
 
+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))
+			return false;
+	}
+	return true;
 }
 
+}
+
 Timer::Timer() noexcept :
 		ticking(false), ticksToWait(0), tickerID{} {}
 
@@ -114,15 +123,6 @@
 Idler::Idler() noexcept :
 		state(false), idlerID(nullptr) {}
 
-static 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))
-			return false;
-	}
-	return true;
-}
-
 Editor::Editor() : durationWrapOneByte(0.000001, 0.00000001, 0.00001) {
 	ctrlID = 0;
 
@@ -3143,7 +3143,7 @@
 		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);
@@ -4402,7 +4402,9 @@
 	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 +4413,12 @@
 	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;
@@ -4756,10 +4764,6 @@
 	}
 }
 
-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);
Index: scintilla/src/UniConversion.cxx
===================================================================
--- scintilla/src/UniConversion.cxx	(版本 44)
+++ scintilla/src/UniConversion.cxx	(版本 45)
@@ -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 @@
 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 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 @@
 	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,15 +175,15 @@
 			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);
@@ -156,16 +190,16 @@
 			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 @@
 	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 @@
 			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 @@
 		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;
 }
 
Index: scintilla/src/UniConversion.h
===================================================================
--- scintilla/src/UniConversion.h	(版本 44)
+++ scintilla/src/UniConversion.h	(版本 45)
@@ -99,8 +99,12 @@
 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 {
Index: scintilla/test/performanceTests.py
===================================================================
--- scintilla/test/performanceTests.py	(版本 44)
+++ scintilla/test/performanceTests.py	(版本 45)
@@ -145,5 +145,27 @@
 		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")
Index: scintilla/test/unit/testDocument.cxx
===================================================================
--- scintilla/test/unit/testDocument.cxx	(版本 44)
+++ scintilla/test/unit/testDocument.cxx	(版本 45)
@@ -1042,6 +1042,137 @@
 	}
 }
 
+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);
Index: scintilla/test/unit/testUniConversion.cxx
===================================================================
--- scintilla/test/unit/testUniConversion.cxx	(版本 44)
+++ scintilla/test/unit/testUniConversion.cxx	(版本 45)
@@ -121,6 +121,9 @@
 		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 @@
 		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 @@
 		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 @@
 		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 @@
 		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 @@
 		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 @@
 		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 @@
 		REQUIRE(tlen == 2U);
 		REQUIRE(tbuf[0] == 'a');
 		REQUIRE(tbuf[1] == 0xF1);
+		// Invalid so can't round trip
 	}
 
 	// UTF32FromUTF8
@@ -193,6 +211,9 @@
 		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 @@
 		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 @@
 		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 @@
 		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 @@
 		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") {
Index: scintilla/version.txt
===================================================================
--- scintilla/version.txt	(版本 44)
+++ scintilla/version.txt	(版本 45)
@@ -1 +1 @@
-555
+556
Index: scintilla/win32/ListBox.cxx
===================================================================
--- scintilla/win32/ListBox.cxx	(版本 0)
+++ scintilla/win32/ListBox.cxx	(版本 45)
@@ -0,0 +1,988 @@
+// 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 {
+
+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;
+	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();
+	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::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_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));
+					if (lbx) {
+						lbx->OnSelChange();
+					}
+				}
+			}
+			return 0;
+
+		case WM_LBUTTONUP:
+			return 0;
+
+		case WM_LBUTTONDBLCLK: {
+				if (lbx) {
+					lbx->OnDoubleClick();
+				}
+			}
+			return 0;
+
+		case WM_MBUTTONDOWN:
+			// disable the scroll wheel button click action
+			return 0;
+
+		default:
+			break;
+		}
+
+		WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+		if (prevWndProc) {
+			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
+		}
+		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));
+		}
+		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 = reinterpret_cast<MEASUREITEMSTRUCT *>(lParam);
+			pMeasureItem->itemHeight = ItemHeight();
+		}
+		break;
+
+	case WM_DRAWITEM:
+		Draw(reinterpret_cast<DRAWITEMSTRUCT *>(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 = reinterpret_cast<MINMAXINFO*>(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 = reinterpret_cast<CREATESTRUCT *>(lParam);
+		SetWindowPointer(hWnd, pCreate->lpCreateParams);
+	}
+	// Find C++ object associated with window.
+	ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd));
+	if (lbx) {
+		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;
+
+}
Index: scintilla/win32/ListBox.h
===================================================================
--- scintilla/win32/ListBox.h	(版本 0)
+++ scintilla/win32/ListBox.h	(版本 45)
@@ -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
Index: scintilla/win32/PlatWin.cxx
===================================================================
--- scintilla/win32/PlatWin.cxx	(版本 44)
+++ scintilla/win32/PlatWin.cxx	(版本 45)
@@ -63,10 +63,9 @@
 
 #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;
@@ -73,211 +72,8 @@
 
 namespace Scintilla::Internal {
 
-UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept;
+HINSTANCE hinstPlatformRes{};
 
-#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
-
 void *PointerFromWindow(HWND hWnd) noexcept {
 	return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
 }
@@ -294,8 +90,8 @@
 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,179 +139,8 @@
 	}
 }
 
-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 {
 	constexpr DWORD monitorFlags = MONITOR_DEFAULTTONEAREST;
 
@@ -549,64 +174,6 @@
 	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,2128 +199,99 @@
 	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 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 != 0;
-}
-
-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);
+void AdjustWindowRectForDpi(LPRECT lpRect, DWORD dwStyle, UINT dpi) noexcept {
+	if (fnAdjustWindowRectExForDpi) {
+		fnAdjustWindowRectExForDpi(lpRect, dwStyle, false, WS_EX_WINDOWEDGE, dpi);
 	} else {
-		pen = ::CreatePen(PS_INSIDEFRAME, penWidth, penColour);
+		::AdjustWindowRectEx(lpRect, dwStyle, false, WS_EX_WINDOWEDGE);
 	}
-	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(), 72);
-}
-
-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);
-	::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 BITMAPV5HEADER BitMapHeader(int width, int height) noexcept {
+	constexpr int pixelBits = 32;
 
-constexpr byte AlphaScaled(unsigned char component, unsigned int alpha) noexcept {
-	return static_cast<byte>(component * alpha / 255);
-}
+	// 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;
 
-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());
+	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;
 }
 
-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}} };
+HBITMAP BitMapSection(HDC hdc, int width, int height, DWORD **pixels) noexcept {
+	const BITMAPV5HEADER bi = BitMapHeader(width, height);
 	void *image = nullptr;
-	hbmMem = CreateDIBSection(hMemDC, &bpih, DIB_RGB_COLORS, &image, {}, 0);
-	if (!hbmMem || !image) {
-		return;
+	HBITMAP hbm = ::CreateDIBSection(hdc, reinterpret_cast<const BITMAPINFO *>(&bi), DIB_RGB_COLORS, &image, {}, 0);
+	if (pixels) {
+		*pixels = static_cast<DWORD *>(image);
 	}
-	pixels = static_cast<DWORD *>(image);
-	hbmOld = SelectBitmap(hMemDC, hbmMem);
+	return hbm;
 }
 
-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);
-}
-
-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() {
-}
-
-#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) {
+GDIBitMap::~GDIBitMap() noexcept {
 	Release();
-	SetScale(wid);
 }
 
-void SurfaceD2D::Init(SurfaceID sid, WindowID wid) {
+void GDIBitMap::Create(HDC hdcBase, int width, int height, DWORD **pixels) noexcept {
 	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 / 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)) {
+	hdc = CreateCompatibleDC(hdcBase);
+	if (!hdc) {
 		return;
 	}
 
-	const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_HOLLOW);
-	PLATFORM_ASSERT(geometry);
-	if (!geometry) {
+	hbm = BitMapSection(hdc, width, height, pixels);
+	if (!hbm) {
 		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());
-	}
+	hbmOriginal = SelectBitmap(hdc, hbm);
 }
 
-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 GDIBitMap::Release() noexcept {
+	if (hbmOriginal) {
+		// Deselect HBITMAP from HDC so it may be deleted.
+		SelectBitmap(hdc, hbmOriginal);
 	}
-}
-
-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());
+	hbmOriginal = {};
+	if (hbm) {
+		::DeleteObject(hbm);
 	}
-}
-
-void SurfaceD2D::FillRectangle(PRectangle rc, Fill fill) {
-	if (pRenderTarget) {
-		D2DPenColourAlpha(fill.colour);
-		const D2D1_RECT_F rectangle = RectangleFromPRectangle(rc);
-		pRenderTarget->FillRectangle(&rectangle, pBrush.Get());
+	hbm = {};
+	if (hdc) {
+		::DeleteDC(hdc);
 	}
+	hdc = {};
 }
 
-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.");
+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 = {};
 	}
-	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 {
@@ -2765,7 +303,7 @@
 PRectangle Window::GetPosition() const {
 	RECT rc;
 	::GetWindowRect(HwndFromWindowID(wid), &rc);
-	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
+	return PRectangleFromRECT(rc);
 }
 
 void Window::SetPosition(PRectangle rc) {
@@ -2829,7 +367,7 @@
 	RECT rc={0,0,0,0};
 	if (wid)
 		::GetClientRect(HwndFromWindowID(wid), &rc);
-	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
+	return PRectangleFromRECT(rc);
 }
 
 void Window::Show(bool show) {
@@ -2862,9 +400,7 @@
 }
 
 class CursorHelper {
-	HDC hMemDC {};
-	HBITMAP hBitmap {};
-	HBITMAP hOldBitmap {};
+	GDIBitMap bm;
 	DWORD *pixels = nullptr;
 	const int width;
 	const int height;
@@ -2880,47 +416,15 @@
 	};
 
 public:
-	~CursorHelper() {
-		if (hOldBitmap) {
-			SelectBitmap(hMemDC, hOldBitmap);
-		}
-		if (hBitmap) {
-			::DeleteObject(hBitmap);
-		}
-		if (hMemDC) {
-			::DeleteDC(hMemDC);
-		}
-	}
+	~CursorHelper() = default;
 
 	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);
-		}
+		bm.Create({}, width, height, &pixels);
 	}
 
-	[[nodiscard]] bool HasBitmap() const noexcept {
-		return hOldBitmap != nullptr;
+	[[nodiscard]] explicit operator bool() const noexcept {
+		return static_cast<bool>(bm);
 	}
 
 	HCURSOR Create() noexcept {
@@ -2930,8 +434,7 @@
 		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 = {};
+			HBITMAP hBitmap = bm.Extract();
 			ICONINFO info = {false, static_cast<DWORD>(width - 1), 0, hMonoBitmap, hBitmap};
 			cursor = ::CreateIconIndirect(&info);
 			::DeleteObject(hMonoBitmap);
@@ -2946,16 +449,9 @@
 			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
-		);
+		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
+			D2D1_RENDER_TARGET_TYPE_DEFAULT,
+			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED });
 
 		DCRenderTarget pTarget;
 		HRESULT hr = CreateDCRenderTarget(&drtp, pTarget);
@@ -2964,7 +460,7 @@
 		}
 
 		const RECT rc = {0, 0, width, height};
-		hr = pTarget->BindDC(hMemDC, &rc);
+		hr = pTarget->BindDC(bm.DC(), &rc);
 		if (FAILED(hr)) {
 			return false;
 		}
@@ -3042,19 +538,20 @@
 			pen = ::CreatePen(PS_INSIDEFRAME, 1, strokeColour);
 		}
 
-		HPEN penOld = SelectPen(hMemDC, pen);
+		HPEN penOld = SelectPen(bm.DC(), pen);
 		HBRUSH brush = ::CreateSolidBrush(fillColour);
-		HBRUSH brushOld = SelectBrush(hMemDC, brush);
-		::Polygon(hMemDC, points, static_cast<int>(nPoints));
-		SelectPen(hMemDC, penOld);
-		SelectBrush(hMemDC, brushOld);
+		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);
 
 		// 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 |= 0xFF000000U;
+				*pixels |= opaque;
 			}
 			pixels++;
 		}
@@ -3123,7 +620,7 @@
 	}
 
 	CursorHelper cursorHelper(width, height);
-	if (!cursorHelper.HasBitmap()) {
+	if (!cursorHelper) {
 		return {};
 	}
 
@@ -3178,915 +675,6 @@
 	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;
-
-		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);
-		}
-	}
-}
-
-// 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;
-
-		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));
-					if (lbx) {
-						lbx->OnSelChange();
-					}
-				}
-			}
-			return 0;
-
-		case WM_LBUTTONUP:
-			return 0;
-
-		case WM_LBUTTONDBLCLK: {
-				if (lbx) {
-					lbx->OnDoubleClick();
-				}
-			}
-			return 0;
-
-		case WM_MBUTTONDOWN:
-			// disable the scroll wheel button click action
-			return 0;
-
-		default:
-			break;
-		}
-
-		WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
-		if (prevWndProc) {
-			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
-		}
-		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));
-		}
-		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);
-		}
-		break;
-
-	case WM_PAINT: {
-			PAINTSTRUCT ps;
-			::BeginPaint(hWnd, &ps);
-			::EndPaint(hWnd, &ps);
-		}
-		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();
-		}
-		break;
-
-	case WM_DRAWITEM:
-		Draw(reinterpret_cast<DRAWITEMSTRUCT *>(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 = reinterpret_cast<MINMAXINFO*>(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 = reinterpret_cast<CREATESTRUCT *>(lParam);
-		SetWindowPointer(hWnd, pCreate->lpCreateParams);
-	}
-	// Find C++ object associated with window.
-	ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd));
-	if (lbx) {
-		return lbx->WndProc(hWnd, iMessage, wParam, lParam);
-	}
-	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-}
-
-namespace {
-
-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);
-	}
-}
-
-}
-
 Menu::Menu() noexcept : mid{} {
 }
 
@@ -4108,12 +696,17 @@
 	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,8 +741,12 @@
 }
 #endif
 
-static bool assertionPopUps = true;
+namespace {
 
+bool assertionPopUps = true;
+
+}
+
 bool Platform::ShowAssertionPopUps(bool assertionPopUps_) noexcept {
 	const bool ret = assertionPopUps;
 	assertionPopUps = assertionPopUps_;
@@ -4182,25 +779,10 @@
 	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);
 	}
Index: scintilla/win32/PlatWin.h
===================================================================
--- scintilla/win32/PlatWin.h	(版本 44)
+++ scintilla/win32/PlatWin.h	(版本 45)
@@ -13,7 +13,11 @@
 #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;
 
 extern void Platform_Finalise(bool fromDllMain) noexcept;
@@ -24,6 +28,10 @@
 	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 @@
 	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 @@
 	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 @@
 
 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 @@
 	}
 };
 
-#if defined(USE_D2D)
-extern bool LoadD2D() noexcept;
-extern ID2D1Factory1 *pD2DFactory;
-extern IDWriteFactory1 *pIDWriteFactory;
+// 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 DCRenderTarget = ComPtr<ID2D1DCRenderTarget>;
+// 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;
 
-using D3D11Device = ComPtr<ID3D11Device1>;
+	~VarBuffer() noexcept {
+		if (buffer != bufferStandard) {
+			delete[]buffer;
+			buffer = nullptr;
+		}
+	}
+};
 
-HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept;
-extern HRESULT CreateD3D(D3D11Device &device) noexcept;
+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>;
 
-using WriteRenderingParams = ComPtr<IDWriteRenderingParams1>;
+// Manage the lifetime of a memory HBITMAP and its HDC so there are no leaks.
+class GDIBitMap {
+	HDC hdc{};
+	HBITMAP hbm{};
+	HBITMAP hbmOriginal{};
 
-struct RenderingParams {
-	WriteRenderingParams defaultRenderingParams;
-	WriteRenderingParams customRenderingParams;
-};
+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;
 
-struct ISetRenderingParams {
-	virtual void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) = 0;
+	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
 
 }
 
Index: scintilla/win32/ScintRes.rc
===================================================================
--- scintilla/win32/ScintRes.rc	(版本 44)
+++ scintilla/win32/ScintRes.rc	(版本 45)
@@ -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.6"
+#define VERSION_WORDS 5, 5, 6, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
Index: scintilla/win32/Scintilla.vcxproj
===================================================================
--- scintilla/win32/Scintilla.vcxproj	(版本 44)
+++ scintilla/win32/Scintilla.vcxproj	(版本 45)
@@ -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>
Index: scintilla/win32/ScintillaWin.cxx
===================================================================
--- scintilla/win32/ScintillaWin.cxx	(版本 44)
+++ scintilla/win32/ScintillaWin.cxx	(版本 45)
@@ -19,6 +19,7 @@
 #include <string>
 #include <string_view>
 #include <vector>
+#include <array>
 #include <map>
 #include <set>
 #include <optional>
@@ -66,6 +67,7 @@
 #include "Geometry.h"
 #include "Platform.h"
 
+#include "CharacterType.h"
 #include "CharacterCategoryMap.h"
 #include "Position.h"
 #include "UniqueString.h"
@@ -86,6 +88,7 @@
 #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 @@
 
 #include "WinTypes.h"
 #include "PlatWin.h"
+#if defined(USE_D2D)
+#include "SurfaceD2D.h"
+#endif
 #include "HanjaDic.h"
 #include "ScintillaWin.h"
 
@@ -124,7 +130,7 @@
 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);
 
 }
@@ -262,7 +268,7 @@
 	HWND hwnd;
 public:
 	HIMC hIMC;
-	IMContext(HWND hwnd_) noexcept :
+	explicit IMContext(HWND hwnd_) noexcept :
 		hwnd(hwnd_), hIMC(::ImmGetContext(hwnd_)) {
 	}
 	// Deleted so IMContext objects can not be copied.
@@ -275,26 +281,26 @@
 			::ImmReleaseContext(hwnd, hIMC);
 	}
 
-	unsigned int GetImeCaretPos() const noexcept {
+	[[nodiscard]] unsigned int GetImeCaretPos() const noexcept {
 		return ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, nullptr, 0);
 	}
 
-	std::vector<BYTE> GetImeAttributes() const {
+	[[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;
 	}
 };
@@ -306,7 +312,7 @@
 	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 +486,7 @@
 	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 +500,6 @@
 #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 +511,7 @@
 	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 +519,9 @@
 		    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,7 +544,7 @@
 	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;
@@ -553,10 +556,10 @@
 	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 +582,7 @@
 	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 +607,9 @@
 	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 +618,7 @@
 	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 +629,11 @@
 	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 +659,13 @@
 	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 +838,14 @@
 
 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 +870,25 @@
 		}
 
 	} 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);
+		const FLOAT dpiTarget = dpiDefault * integralDeviceScaleFactor;
 
-		D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp{};
-		dhrtp.hwnd = hw;
-		dhrtp.pixelSize = ::GetSizeUFromRect(rc, integralDeviceScaleFactor);
-		dhrtp.presentOptions = (technology == Technology::DirectWriteRetain) ?
+		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);
@@ -1134,7 +1143,7 @@
 }
 
 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 +1152,7 @@
 }
 
 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 +1204,19 @@
 			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 +1279,24 @@
 	// 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();
@@ -1324,7 +1331,7 @@
 
 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 {
@@ -1378,7 +1385,7 @@
 
 	if (utf16Len > 0) {
 		std::string documentStr(documentStrLen, '\0');
-		pdoc->GetCharRange(&documentStr[0], selStart, documentStrLen);
+		pdoc->GetCharRange(documentStr.data(), selStart, documentStrLen);
 
 		std::wstring uniStr = StringDecode(documentStr, CodePageOfDocument());
 		const bool converted = HanjaDict::GetHangulOfHanja(uniStr);
@@ -1387,7 +1394,7 @@
 			documentStr = StringEncode(uniStr, CodePageOfDocument());
 			UndoGroup ug(pdoc);
 			ClearSelection();
-			InsertPaste(&documentStr[0], documentStr.size());
+			InsertPaste(documentStr.data(), documentStr.size());
 		}
 	}
 }
@@ -1410,7 +1417,7 @@
 	// 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);
+	pdoc->GetCharRange(oneChar.data(), currentPos, oneCharLen);
 
 	std::wstring uniChar = StringDecode(oneChar, CodePageOfDocument());
 
@@ -1419,7 +1426,7 @@
 		// Set the candidate box position since IME may show it.
 		SetCandidateWindowPos();
 		// IME_ESC_HANJA_MODE appears to receive the first character only.
-		if (::ImmEscapeW(GetKeyboardLayout(0), imc.hIMC, IME_ESC_HANJA_MODE, &uniChar[0])) {
+		if (::ImmEscapeW(GetKeyboardLayout(0), imc.hIMC, IME_ESC_HANJA_MODE, uniChar.data())) {
 			SetSelection(currentPos, currentPos + oneCharLen);
 		}
 	}
@@ -1598,8 +1605,13 @@
 	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 {
 
 UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept {
@@ -1646,30 +1658,28 @@
 		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 +1702,51 @@
 			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 +1792,7 @@
 	}
 	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());
@@ -1961,20 +1969,19 @@
 
 	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;
 
@@ -2487,29 +2494,25 @@
 }
 
 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 +2549,14 @@
 	// 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 +2607,7 @@
 void ScintillaWin::HideCursorIfPreferred() noexcept {
 	// SPI_GETMOUSEVANISH from OS.
 	if (typingWithoutCursor && !cursorIsHidden) {
-		::SetCursor(NULL);
+		::SetCursor({});
 		cursorIsHidden = true;
 	}
 }
@@ -2618,7 +2622,7 @@
 	};
 	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 +2674,7 @@
 }
 
 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
@@ -2792,63 +2796,85 @@
 
 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 (int byte1 = highByteFirst; byte1 <= highByteLast; byte1++) {
+		const char ch1 = byte1 & 0xFF;	// & 0xFF avoids warnings but has no real effect.
+		if (DBCSIsLeadByte(codePage, ch1)) {
+			for (int byte2 = minTrailByte; byte2 <= highByteLast; byte2++) {
+				const char ch2 = byte2 & 0xFF;
+				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());
+	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
+};
 
-			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);
-
-			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 +2882,41 @@
 	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 +2960,7 @@
 	HGLOBAL hand {};
 public:
 	void *ptr {};
-	GlobalMemory() noexcept {
-	}
+	GlobalMemory() noexcept = default;
 	explicit GlobalMemory(HGLOBAL hand_) noexcept : hand(hand_) {
 		if (hand) {
 			ptr = ::GlobalLock(hand);
@@ -2970,10 +2993,10 @@
 	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 +3005,8 @@
 // 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 +3021,7 @@
 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 +3033,7 @@
 			::CloseClipboard();
 		}
 	}
-	constexpr operator bool() const noexcept {
+	explicit constexpr operator bool() const noexcept {
 		return opened;
 	}
 };
@@ -3063,7 +3087,7 @@
 	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 +3160,7 @@
 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 +3223,7 @@
 		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) {
@@ -3323,11 +3343,11 @@
 			// 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;
+			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.lfHeight = -::MulDiv(sizeZoomed, dpi, pointsPerInch*FontSizeMultiplier);
 			lf.lfWeight = static_cast<LONG>(vs.styles[styleHere].weight);
 			lf.lfItalic = vs.styles[styleHere].italic ? 1 : 0;
 			lf.lfCharSet = DEFAULT_CHARSET;
@@ -3375,7 +3395,7 @@
 		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);
@@ -3453,7 +3473,7 @@
 		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)
@@ -3531,7 +3551,7 @@
 	}
 
 	if (selectedText.rectangular) {
-		::SetClipboardData(cfColumnSelect, 0);
+		::SetClipboardData(cfColumnSelect, {});
 
 		GlobalMemory borlandSelection;
 		borlandSelection.Allocate(1);
@@ -3542,8 +3562,8 @@
 	}
 
 	if (selectedText.lineCopy) {
-		::SetClipboardData(cfLineSelect, 0);
-		::SetClipboardData(cfVSLineTag, 0);
+		::SetClipboardData(cfLineSelect, {});
+		::SetClipboardData(cfVSLineTag, {});
 	}
 }
 
@@ -3582,12 +3602,13 @@
 	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 +3830,7 @@
 
 	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 +3845,7 @@
 	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 +3888,9 @@
 }
 
 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 +3903,7 @@
 		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,105 +3924,113 @@
 	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();
+		const int scaleFactor = 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;
+		// Create a Direct2D render target.
 
-					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 FLOAT dpiTarget = dpiDefault * scaleFactor;
 
-					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 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);
@@ -4051,19 +4076,17 @@
 		} 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.
Index: scintilla/win32/SurfaceD2D.cxx
===================================================================
--- scintilla/win32/SurfaceD2D.cxx	(版本 0)
+++ scintilla/win32/SurfaceD2D.cxx	(版本 45)
@@ -0,0 +1,1742 @@
+// 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++) {
+			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
+
+}
+
+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();
+}
+
+}
Index: scintilla/win32/SurfaceD2D.h
===================================================================
--- scintilla/win32/SurfaceD2D.h	(版本 0)
+++ scintilla/win32/SurfaceD2D.h	(版本 45)
@@ -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
Index: scintilla/win32/SurfaceGDI.cxx
===================================================================
--- scintilla/win32/SurfaceGDI.cxx	(版本 0)
+++ scintilla/win32/SurfaceGDI.cxx	(版本 45)
@@ -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>();
+}
+
+}
Index: scintilla/win32/SurfaceGDI.h
===================================================================
--- scintilla/win32/SurfaceGDI.h	(版本 0)
+++ scintilla/win32/SurfaceGDI.h	(版本 45)
@@ -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
Index: scintilla/win32/WinTypes.h
===================================================================
--- scintilla/win32/WinTypes.h	(版本 44)
+++ scintilla/win32/WinTypes.h	(版本 45)
@@ -52,6 +52,13 @@
 	return fp;
 }
 
+inline void ReleaseLibrary(HMODULE &hLib) noexcept {
+	if (hLib) {
+		FreeLibrary(hLib);
+		hLib = {};
+	}
 }
 
+}
+
 #endif
Index: scintilla/win32/deps.mak
===================================================================
--- scintilla/win32/deps.mak	(版本 44)
+++ scintilla/win32/deps.mak	(版本 45)
@@ -3,6 +3,19 @@
 	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 @@
 	../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 @@
 	../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 @@
 	../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 @@
 	../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 \
Index: scintilla/win32/makefile
===================================================================
--- scintilla/win32/makefile	(版本 44)
+++ scintilla/win32/makefile	(版本 45)
@@ -118,6 +118,9 @@
 	$(SRC_OBJS) \
 	$(DIR_O)/HanjaDic.o \
 	$(DIR_O)/PlatWin.o \
+	$(DIR_O)/ListBox.o \
+	$(DIR_O)/SurfaceGDI.o \
+	$(DIR_O)/SurfaceD2D.o \
 	$(DIR_O)/ScintillaBase.o \
 	$(DIR_O)/ScintillaWin.o
 
Index: scintilla/win32/nmdeps.mak
===================================================================
--- scintilla/win32/nmdeps.mak	(版本 44)
+++ scintilla/win32/nmdeps.mak	(版本 45)
@@ -3,6 +3,19 @@
 	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 @@
 	../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 @@
 	../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 @@
 	../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 @@
 	../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 \
Index: scintilla/win32/scintilla.mak
===================================================================
--- scintilla/win32/scintilla.mak	(版本 44)
+++ scintilla/win32/scintilla.mak	(版本 45)
@@ -10,7 +10,7 @@
 
 .SUFFIXES: .cxx
 
-DIR_O=.
+DIR_O=obj
 DIR_BIN=..\bin
 
 COMPONENT=$(DIR_BIN)\Scintilla.dll
@@ -18,6 +18,10 @@
 
 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.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,8 +70,11 @@
 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) \
 	$(DIR_O)\*.res $(DIR_BIN)\*.map $(DIR_BIN)\*.exp $(DIR_BIN)\*.pdb \
@@ -113,6 +121,9 @@
 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)
Index: scite/.hg_archival.txt
===================================================================
--- scite/.hg_archival.txt	(版本 44)
+++ scite/.hg_archival.txt	(版本 45)
@@ -1,6 +1,6 @@
 repo: dfc7523942ae501c035e4c36e791803c09d112e5
-node: 7ad12cae834a5036ed1bb16d7d457355b67a1c21
+node: 3ccc743fd9bcaa75e4da3505e37273b57c0234fc
 branch: default
-latesttag: rel-5-5-5
+latesttag: rel-5-5-6
 latesttagdistance: 1
 changessincelatesttag: 1
Index: scite/.hgtags
===================================================================
--- scite/.hgtags	(版本 44)
+++ scite/.hgtags	(版本 45)
@@ -220,3 +220,8 @@
 188da63bb53aee4409b08faaeaaebd205a5fb65b rel-5-5-3
 d2c65e0bd078c8e342690d093faab60491af345c rel-5-5-4
 895ebcb741361ebcf99e5a5cd23e66c08ae66dae rel-5-5-5
+9581d2043bfb548611f2d5df151a5d9dc3ce82f9 rel-5-5-6
+9581d2043bfb548611f2d5df151a5d9dc3ce82f9 rel-5-5-6
+0000000000000000000000000000000000000000 rel-5-5-6
+0000000000000000000000000000000000000000 rel-5-5-6
+831ee89e343fe6a652470a0fb046642e201e65a7 rel-5-5-6
Index: scite/doc/SciTE.html
===================================================================
--- scite/doc/SciTE.html	(版本 44)
+++ scite/doc/SciTE.html	(版本 45)
@@ -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="20250402" />
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <script type="text/javascript">
    	function IsRemote() {
@@ -61,8 +61,8 @@
           X</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.6<br />
+           Site last modified April 2 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +77,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.5.6 improves search performance and autocompletion drawing on Windows.</li>
       <li>Version 5.5.5 can remember selection with undo and redo.</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 regular expression behaviour for empty matches like ^$.</li>
       <li>Version 5.5.2 adds a stretch attribute to style settings for condensed and expanded text.</li>
-      <li>Version 5.5.1 fixes a flickering cursor bug on Win32 and improves HTML styling.</li>
     </ul>
     <ul id="menu">
       <li><a href="https://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
Index: scite/doc/SciTEDoc.html
===================================================================
--- scite/doc/SciTEDoc.html	(版本 44)
+++ scite/doc/SciTEDoc.html	(版本 45)
@@ -9,6 +9,7 @@
     <title>
       SciTE
     </title>
+    <link rel="canonical" href="https://scintilla.org/SciTEDoc.html" />
 <style type="text/css">
         table {
             border: 1px solid #1F1F1F;
Index: scite/doc/SciTEDownload.html
===================================================================
--- scite/doc/SciTEDownload.html	(版本 44)
+++ scite/doc/SciTEDownload.html	(版本 45)
@@ -9,6 +9,7 @@
     <title>
       Download Scintilla and SciTE
     </title>
+    <link rel="canonical" href="https://scintilla.org/SciTEDownload.html" />
   <style type="text/css">
     h3 {
 	background-color: #CCCCFF;
@@ -30,9 +31,9 @@
     <table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
       <tr>
         <td>
-          <font size="4"> <a href="https://www.scintilla.org/scite555.zip">
+          <font size="4"> <a href="https://www.scintilla.org/scite556.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/scite555.tgz">
+	<a href="https://www.scintilla.org/scite556.tgz">
           GTK/Linux</a>&nbsp;&nbsp;</font>
         </td>
       </tr>
@@ -45,7 +46,7 @@
       containing very few restrictions.
     </p>
     <h2>
-       Release 5.5.5
+       Release 5.5.6
     </h2>
     <h3>
        Source Code
@@ -53,8 +54,8 @@
        The source code package contains all of the source code for Scintilla and SciTE but no binary
 	executable code and is available in
        <ul>
-       <li><a href="https://www.scintilla.org/scite555.zip">zip format</a> (5.3M) commonly used on Windows</li>
-       <li><a href="https://www.scintilla.org/scite555.tgz">tgz format</a> (4.6M) commonly used on Linux and compatible operating systems</li>
+       <li><a href="https://www.scintilla.org/scite556.zip">zip format</a> (5.3M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/scite556.tgz">tgz format</a> (4.6M) commonly used on Linux and compatible operating systems</li>
        </ul>
        Instructions for building on both Windows and Linux are included in the readme file.
     <h3>
@@ -68,21 +69,21 @@
        is no longer tested.
        <ul>
        <li>
-        <a href="https://www.scintilla.org/wscite555.zip">Full 64-bit download</a> (2.9M) includes the SciTE executable, any required DLLs,
+        <a href="https://www.scintilla.org/wscite556.zip">Full 64-bit download</a> (2.9M) includes the SciTE executable, any required DLLs,
         configuration files and documentation. After downloading the file, unzip it, and run
         SciTE.EXE. The files required to run SciTE are SciTE.EXE, SciLexer.DLL, and
         SciTEGlobal.properties.
        </li>
        <li>
-         <a href="https://www.scintilla.org/wscite32_555.zip">Full 32-bit download</a> (2.6M) is similar but will run on 32-bit Windows
+         <a href="https://www.scintilla.org/wscite32_556.zip">Full 32-bit download</a> (2.6M) is similar but will run on 32-bit Windows
          with the executable called SciTE32.EXE.
        </li>
        <li>
-         <a href="https://www.scintilla.org/Sc555.exe">Single file 64-bit executable called Sc1</a> (3.8M) does not need any DLL or
+         <a href="https://www.scintilla.org/Sc556.exe">Single file 64-bit executable called Sc1</a> (3.9M) does not need any DLL or
          properties files as these are linked into the executable. You may still create properties files if you wish.
        </li>
        <li>
-         <a href="https://www.scintilla.org/Sc32_555.exe">Single file 32-bit download</a> (3.2M) is similar but will run on 32-bit Windows.
+         <a href="https://www.scintilla.org/Sc32_556.exe">Single file 32-bit download</a> (3.2M) is similar but will run on 32-bit Windows.
        </li>
        </ul>
     </p>
@@ -108,7 +109,7 @@
       If the target system is 32-bit, you will need to build SciTE from source.
     </p>
     <p>
-       A <a href="https://www.scintilla.org/gscite555.tgz">full download</a> (3.8M) includes the 64-bit SciTE executable,
+       A <a href="https://www.scintilla.org/gscite556.tgz">full download</a> (3.8M) includes the 64-bit SciTE executable,
       shared libraries for Scintilla (libscintilla.so) and Lexilla (liblexilla.so)
       configuration files and documentation.
       After downloading the file, gunzip and untar it, and run
Index: scite/doc/SciTEExtension.html
===================================================================
--- scite/doc/SciTEExtension.html	(版本 44)
+++ scite/doc/SciTEExtension.html	(版本 45)
@@ -9,6 +9,7 @@
     <title>
       SciTE Extension Interface
     </title>
+    <link rel="canonical" href="https://scintilla.org/SciTEExtension.html" />
     <style type="text/css">
         .example {
             color: #00A000;
Index: scite/doc/SciTEHistory.html
===================================================================
--- scite/doc/SciTEHistory.html	(版本 44)
+++ scite/doc/SciTEHistory.html	(版本 45)
@@ -10,6 +10,7 @@
     <title>
       SciTE
     </title>
+    <link rel="canonical" href="https://scintilla.org/SciTEHistory.html" />
     <style type="text/css">
         table {
             border-collapse: collapse;
@@ -616,6 +617,11 @@
 	<td>Pawel Z Wronek</td>
 	<td>Ekopalypse</td>
 	<td>HoTschir</td>
+	<td>Joachim Mairboeck</td>
+      </tr><tr>
+	<td>Gianluca Vaccari</td>
+	<td>8day</td>
+	<td>Ahmet Sait</td>
       </tr>
     </table>
     <p>
@@ -625,6 +631,61 @@
     </p>
     <h2 id="Releases">Releases</h2>
     <h3>
+       <a href="https://www.scintilla.org/scite556.zip">Release 5.5.6</a>
+    </h3>
+    <ul>
+	<li>SciTE</li>
+	<ul>
+		<li>
+		Released 2 April 2025.
+		</li>
+	</ul>
+	<li>Lexilla 5.4.4</li>
+	<ul>
+		<li>
+		Fix building for ARM64.
+		<a href="https://github.com/ScintillaOrg/lexilla/pull/308">Pull request #308</a>.
+		</li>
+	</ul>
+	<li>Scintilla 5.5.6</li>
+	<ul>
+		<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>
+    </ul>
+    <h3>
        <a href="https://www.scintilla.org/scite555.zip">Release 5.5.5</a>
     </h3>
     <ul>
Index: scite/doc/SciTEImage.html
===================================================================
--- scite/doc/SciTEImage.html	(版本 44)
+++ scite/doc/SciTEImage.html	(版本 45)
@@ -9,6 +9,7 @@
     <title>
       Scintilla and SciTE
     </title>
+    <link rel="canonical" href="https://scintilla.org/SciTEImage.html" />
   </head>
   <body bgcolor="#FFFFFF" text="#000000">
     <table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
Index: scite/doc/SciTERegEx.html
===================================================================
--- scite/doc/SciTERegEx.html	(版本 44)
+++ scite/doc/SciTERegEx.html	(版本 45)
@@ -9,6 +9,7 @@
     <title>
       SciTE Regular Expressions
     </title>
+    <link rel="canonical" href="https://scintilla.org/SciTERegEx.html" />
 <style type="text/css">
         h3 {
             background-color: #FEC;
Index: scite/gtk/DirectorExtension.cxx
===================================================================
--- scite/gtk/DirectorExtension.cxx	(版本 44)
+++ scite/gtk/DirectorExtension.cxx	(版本 45)
@@ -40,6 +40,7 @@
 #include <ctime>
 #include <cerrno>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/gtk/SciTEGTK.cxx
===================================================================
--- scite/gtk/SciTEGTK.cxx	(版本 44)
+++ scite/gtk/SciTEGTK.cxx	(版本 45)
@@ -14,6 +14,7 @@
 #include <cerrno>
 #include <csignal>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/lua/src/luaconf.h
===================================================================
--- scite/lua/src/luaconf.h	(版本 44)
+++ scite/lua/src/luaconf.h	(版本 45)
@@ -788,8 +788,10 @@
 #pragma clang diagnostic ignored "-Wconversion"
 #pragma clang diagnostic ignored "-Wcomma"
 #pragma clang diagnostic ignored "-Wstring-plus-int"
+#if !defined(__APPLE__)
 #pragma clang diagnostic ignored "-Wcast-function-type-mismatch"
 #endif
+#endif
 
 #endif
 
Index: scite/scripts/HeaderOrder.txt
===================================================================
--- scite/scripts/HeaderOrder.txt	(版本 44)
+++ scite/scripts/HeaderOrder.txt	(版本 45)
@@ -31,6 +31,8 @@
 // C++ standard library
 #include <stdexcept>
 #include <system_error>
+#include <utility>
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/src/Cookie.cxx
===================================================================
--- scite/src/Cookie.cxx	(版本 44)
+++ scite/src/Cookie.cxx	(版本 45)
@@ -22,13 +22,13 @@
 
 std::string_view ExtractLine(std::string_view sv) noexcept {
 	std::string_view remainder = sv;
-	while ((remainder.length() > 0) && (remainder[0] != '\r') && (remainder[0] != '\n')) {
+	while (!remainder.empty() && !IsEOLCharacter(remainder[0])) {
 		remainder.remove_prefix(1);
 	}
-	if ((remainder.length() > 1) && (remainder[0] == '\r') && (remainder[1] == '\n')) {
+	if (remainder.starts_with("\r\n")) {
 		remainder.remove_prefix(1);
 	}
-	if (remainder.length() > 0) {
+	if (!remainder.empty()) {
 		remainder.remove_prefix(1);
 	}
 	sv.remove_suffix(remainder.length());
@@ -54,12 +54,12 @@
 	const size_t posCoding = s.find(codingCookie);
 	if (posCoding != std::string_view::npos) {
 		s.remove_prefix(posCoding + codingCookie.length());
-		if ((s.length() > 0) && ((s[0] == ':') || (s[0] == '='))) {
+		if (!s.empty() && ((s[0] == ':') || (s[0] == '='))) {
 			s.remove_prefix(1);
-			if ((s.length() > 0) && ((s[0] == '\"') || (s[0] == '\''))) {
+			if (!s.empty() && ((s[0] == '\"') || (s[0] == '\''))) {
 				s.remove_prefix(1);
 			}
-			while ((s.length() > 0) && (isSpaceChar(s[0]))) {
+			while (!s.empty() && (isSpaceChar(s[0]))) {
 				s.remove_prefix(1);
 			}
 			size_t endCoding = 0;
Index: scite/src/Credits.cxx
===================================================================
--- scite/src/Credits.cxx	(版本 44)
+++ scite/src/Credits.cxx	(版本 45)
@@ -11,6 +11,7 @@
 #include <cstring>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -519,6 +520,10 @@
             "Pawel Z Wronek",
             "Ekopalypse",
             "HoTschir",
+            "Joachim Mairboeck",
+            "Gianluca Vaccari",
+            "8day",
+            "Ahmet Sait",
 
 //--Autogenerated -- end of automatically generated section
         };
@@ -529,9 +534,9 @@
 	std::vector<char> buf(len*2);
 	for (size_t i = 0; i < len; i++) {
 		buf[i*2] = sv[i];
-		buf[i*2 + 1] = attr;
+		buf[(i*2) + 1] = attr;
 	}
-	wsci.AddStyledText(len*2, &buf[0]);
+	wsci.AddStyledText(len*2, buf.data());
 }
 
 void SetAboutStyle(GUI::ScintillaWindow &wsci, int style, Scintilla::Colour fore) {
@@ -541,10 +546,15 @@
 // Implement low quality pseudo-random colours for the pretties.
 // Pseudo-random algorithm based on R. G. Dromey "How to Solve it by Computer" page 122.
 
+constexpr int byteValues = 256;
+constexpr unsigned int maxByte = 0xff;
+constexpr unsigned int halfByte = 0x7f;
+
+constexpr int mult = 109;
+constexpr int incr = 853;
+constexpr int modulus = 4096;
+
 class RandomColour {
-	int mult;
-	int incr;
-	int modulus;
 	int randomValue;
 	int NextRandom() noexcept {
 		randomValue = (mult * randomValue + incr) % modulus;
@@ -562,13 +572,10 @@
 	int g;
 	int b;
 	RandomColour() noexcept :
-		mult(109),
-		incr(853),
-		modulus(4096),
 		randomValue(time(nullptr) % modulus),
-		r(NextRandom() % 256),
-		g(NextRandom() % 256),
-		b(NextRandom() % 256) {
+		r(NextRandom() % byteValues),
+		g(NextRandom() % byteValues),
+		b(NextRandom() % byteValues) {
 	}
 	void Next() noexcept {
 		HackColour(r);
@@ -608,22 +615,25 @@
 
 		wsci.SetCodePage(SA::CpUtf8);
 
-		wsci.StyleSetSize(StyleDefault, fontSize);
-		wsci.StyleSetBack(StyleDefault, ColourRGB(0xff, 0xff, 0xff));
+        constexpr Scintilla::Colour white = ColourRGB(maxByte, maxByte, maxByte);
+        constexpr Scintilla::Colour black = ColourRGB(0, 0, 0);
+
+        wsci.StyleSetSize(StyleDefault, fontSize);
+		wsci.StyleSetBack(StyleDefault, white);
 		wsci.StyleClearAll();
 
-		SetAboutStyle(wsci, 0, ColourRGB(0xff, 0xff, 0xff));
+		SetAboutStyle(wsci, 0, white);
 		wsci.StyleSetSize(0, fontSize);
-		wsci.StyleSetBack(0, ColourRGB(0, 0, 0x80));
+		wsci.StyleSetBack(0, ColourRGB(0, 0, halfByte));
 		wsci.StyleSetEOLFilled(0, true);
 		wsci.StyleSetBold(0, true);
 		AddStyledText(wsci, "\t\t\t\t", 0);
 		AddStyledText(wsci, appTitle, 0);
 		AddStyledText(wsci, "\n", 0);
-		SetAboutStyle(wsci, 1, ColourRGB(0, 0, 0));
+		SetAboutStyle(wsci, 1, black);
 		constexpr int trsSty = 5; // define the stylenumber to assign font for translators.
 		std::string translator = GetTranslationToAbout("TranslationCredit", false);
-		SetAboutStyle(wsci, trsSty, ColourRGB(0, 0, 0));
+		SetAboutStyle(wsci, trsSty, black);
 		if constexpr (sizeof(void *) == 4) {
 			AddStyledText(wsci, "32-bit\n", 1);
 		}
@@ -630,19 +640,19 @@
 		AddStyledText(wsci, GetTranslationToAbout("Version"), trsSty);
 		AddStyledText(wsci, sVersion, 1);
 		AddStyledText(wsci, "    " __DATE__ " " __TIME__ "\n", 1);
-		SetAboutStyle(wsci, 2, ColourRGB(0, 0, 0));
+		SetAboutStyle(wsci, 2, black);
 		wsci.StyleSetItalic(2, true);
 		AddStyledText(wsci, GetTranslationToAbout("by"), trsSty);
 		AddStyledText(wsci, " Neil Hodgson.\n", 2);
-		SetAboutStyle(wsci, 3, ColourRGB(0, 0, 0));
+		SetAboutStyle(wsci, 3, black);
 		AddStyledText(wsci, COPYRIGHT_DATES ".\n", 3);
-		SetAboutStyle(wsci, 4, ColourRGB(0, 0x7f, 0x7f));
+		SetAboutStyle(wsci, 4, ColourRGB(0, halfByte, halfByte));
 		AddStyledText(wsci, "http://www.scintilla.org\n", 4);
 		AddStyledText(wsci, "Lua scripting language by TeCGraf, PUC-Rio\n", 3);
 		AddStyledText(wsci, "    http://www.lua.org\n", 4);
-		if (translator.length()) {
+		if (!translator.empty()) {
 			AddStyledText(wsci, translator, trsSty);
-			AddStyledText(wsci, "\n", 5);
+			AddStyledText(wsci, "\n", trsSty);
 		}
 		AddStyledText(wsci, GetTranslationToAbout("Contributors:"), trsSty);
 		for (unsigned int co = 0; co < std::size(contributors); co++) {
Index: scite/src/EditorConfig.cxx
===================================================================
--- scite/src/EditorConfig.cxx	(版本 44)
+++ scite/src/EditorConfig.cxx	(版本 45)
@@ -8,6 +8,7 @@
 
 #include <cassert>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -57,7 +58,7 @@
 	std::string configString = fpec.Read();
 	if (configString.size() > 0) {
 		const std::string_view svUtf8BOM(UTF8BOM);
-		if (StartsWith(configString, svUtf8BOM)) {
+		if (configString.starts_with(svUtf8BOM)) {
 			configString.erase(0, svUtf8BOM.length());
 		}
 		// Carriage returns aren't wanted
@@ -64,9 +65,9 @@
 		Remove(configString, std::string("\r"));
 		std::vector<std::string> configLines = StringSplit(configString, '\n');
 		for (std::string &line : configLines) {
-			if (line.empty() || StartsWith(line, "#") || StartsWith(line, ";")) {
+			if (line.empty() || line.starts_with("#") || line.starts_with(";")) {
 				// Drop comments
-			} else if (StartsWith(line, "[")) {
+			} else if (line.starts_with("[")) {
 				// Pattern
 				lines.push_back(line);
 			} else if (Contains(line, '=')) {
@@ -103,7 +104,7 @@
 	std::string fullPath = absolutePath.AsUTF8();
 #if defined(_WIN32)
 	// Convert Windows path separators to Unix
-	std::replace(fullPath.begin(), fullPath.end(), '\\', '/');
+	std::ranges::replace(fullPath, '\\', '/');
 #endif
 	for (const ECForDirectory &level : config) {
 		std::string relPath;
@@ -111,8 +112,8 @@
 			relPath = fullPath.substr(level.directory.length());
 		}
 		bool inActiveSection = false;
-		for (auto line : level.lines) {
-			if (StartsWith(line, "[")) {
+		for (const std::string &line : level.lines) {
+			if (line.starts_with("[")) {
 				const std::string pattern = line.substr(1, line.size() - 2);
 				inActiveSection = PathMatch(pattern, relPath);
 				// PatternMatch only works with literal filenames, '?', '*', '**', '[]', '[!]', '{,}', '{..}', '\x'.
Index: scite/src/ExportHTML.cxx
===================================================================
--- scite/src/ExportHTML.cxx	(版本 44)
+++ scite/src/ExportHTML.cxx	(版本 45)
@@ -12,6 +12,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/src/ExportPDF.cxx
===================================================================
--- scite/src/ExportPDF.cxx	(版本 44)
+++ scite/src/ExportPDF.cxx	(版本 45)
@@ -12,6 +12,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -498,6 +499,9 @@
 		}
 	}
 	// patch in default foregrounds
+	if (pr.style[StyleDefault].fore.empty()) {
+		pr.style[StyleDefault].fore = "0 0 0 ";
+	}
 	for (int j = 0; j <= StyleMax; j++) {
 		if (pr.style[j].fore.empty()) {
 			pr.style[j].fore = pr.style[StyleDefault].fore;
Index: scite/src/ExportRTF.cxx
===================================================================
--- scite/src/ExportRTF.cxx	(版本 44)
+++ scite/src/ExportRTF.cxx	(版本 45)
@@ -12,6 +12,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -79,42 +80,39 @@
 #define RTF_EOLN "\\par\n"
 #define RTF_TAB "\\tab "
 
-#define MAX_STYLEDEF 128
 #define RTF_FONTFACE "Courier New"
 #define RTF_COLOR "#000000"
 
-static size_t FindCaseInsensitive(const std::vector<std::string> &values, const std::string &s) {
+namespace {
+
+size_t FindCaseInsensitive(const std::vector<std::string> &values, const std::string &s) noexcept {
 	for (size_t i = 0; i < values.size(); i++)
-		if (EqualCaseInsensitive(s.c_str(), values[i].c_str()))
+		if (EqualCaseInsensitive(s, values[i]))
 			return i;
 	return values.size();
 }
 
 // extract the next RTF control word from *style
-static void GetRTFNextControl(const char **style, char *control) noexcept {
+std::string_view GetRTFNextControl(const char **style) noexcept {
 	const char *pos = *style;
-	*control = '\0';
-	if ('\0' == *pos) return;
+	if ('\0' == *pos) return {};
 	pos++; // implicit skip over leading '\'
 	while ('\0' != *pos && '\\' != *pos) { pos++; }
-	ptrdiff_t len = pos - *style;
-	memcpy(control, *style, len);
-	*(control + len) = '\0';
+	const std::string_view ret(*style, pos - *style);
 	*style = pos;
+	return ret;
 }
 
 // extracts control words that are different between two styles
-static std::string GetRTFStyleChange(const char *last, const char *current) { // \f0\fs20\cf0\highlight0\b0\i0
-	char lastControl[MAX_STYLEDEF] = "";
-	char currentControl[MAX_STYLEDEF] = "";
-	const char *lastPos = last;
-	const char *currentPos = current;
+std::string GetRTFStyleChange(const std::string &last, const std::string &current) { // \f0\fs20\cf0\highlight0\b0\i0
+	const char *lastPos = last.c_str();
+	const char *currentPos = current.c_str();
 	std::string delta;
 	// font face, size, color, background, bold, italic
 	for (int i = 0; i < 6; i++) {
-		GetRTFNextControl(&lastPos, lastControl);
-		GetRTFNextControl(&currentPos, currentControl);
-		if (strcmp(lastControl, currentControl)) {	// changed
+		const std::string_view lastControl = GetRTFNextControl(&lastPos);
+		const std::string_view currentControl = GetRTFNextControl(&currentPos);
+		if (lastControl != currentControl) {	// changed
 			delta += currentControl;
 		}
 	}
@@ -122,6 +120,8 @@
 	return delta;
 }
 
+}
+
 void SciTEBase::SaveToStreamRTF(std::ostream &os, SA::Position start, SA::Position end) {
 	const SA::Position lengthDoc = LengthDocument();
 	if (end < 0)
@@ -216,9 +216,11 @@
 		styles.push_back(osStyle.str());
 	}
 	os << RTF_FONTDEFCLOSE RTF_COLORDEFOPEN;
-	for (const std::string &color : colors) {
-		os << "\\red" << IntFromHexByte(color.c_str() + 1) << "\\green" << IntFromHexByte(color.c_str() + 3) <<
-		   "\\blue" << IntFromHexByte(color.c_str() + 5) << ";";
+	for (std::string color : colors) {
+		color.append("0000000");	// Ensure substr safe by providing at least 7 characters
+		os << "\\red" << IntFromHexByte(color.substr(1,2)) <<
+			"\\green" << IntFromHexByte(color.substr(3,2)) <<
+		   "\\blue" << IntFromHexByte(color.substr(5,2)) << ";";
 	}
 	os << RTF_COLORDEFCLOSE RTF_HEADERCLOSE RTF_BODYOPEN RTF_SETFONTFACE "0"
 	   RTF_SETFONTSIZE << defaultStyle.size << RTF_SETCOLOR "0 ";
@@ -237,7 +239,7 @@
 		if (style > StyleMax)
 			style = 0;
 		if (style != styleCurrent) {
-			const std::string deltaStyle = GetRTFStyleChange(lastStyle.c_str(), styles[style].c_str());
+			const std::string deltaStyle = GetRTFStyleChange(lastStyle, styles[style]);
 			lastStyle = styles[style];
 			if (!deltaStyle.empty())
 				os << deltaStyle;
Index: scite/src/ExportTEX.cxx
===================================================================
--- scite/src/ExportTEX.cxx	(版本 44)
+++ scite/src/ExportTEX.cxx	(版本 45)
@@ -12,6 +12,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -53,7 +54,9 @@
 
 //---------- Save to TeX ----------
 
-static char *getTexRGB(char *texcolor, size_t count, const char *stylecolor) noexcept {
+namespace {
+
+char *getTexRGB(char *texcolor, size_t count, const char *stylecolor) noexcept {
 	//texcolor[rgb]{0,0.5,0}{....}
 	const double rf = IntFromHexByte(stylecolor + 1) / 256.0;
 	const double gf = IntFromHexByte(stylecolor + 3) / 256.0;
@@ -67,7 +70,7 @@
 }
 
 #define CHARZ ('z' - 'b')
-static char *texStyle(int style) noexcept {
+char *texStyle(int style) noexcept {
 	static char buf[10];
 	int i = 0;
 	do {
@@ -78,7 +81,7 @@
 	return buf;
 }
 
-static void defineTexStyle(const StyleDefinition &style, FILE *fp, int istyle) {
+void defineTexStyle(const StyleDefinition &style, FILE *fp, int istyle) {
 	int closing_brackets = 2;
 	char rgb[200] = "";
 	fprintf(fp, "\\newcommand{\\scite%s}[1]{\\noindent{\\ttfamily{", texStyle(istyle));
@@ -105,6 +108,8 @@
 	fputc('\n', fp);
 }
 
+}
+
 void SciTEBase::SaveToTEX(const FilePath &saveName) {
 	RemoveFindMarks();
 	wEditor.ColouriseAll();
Index: scite/src/ExportXML.cxx
===================================================================
--- scite/src/ExportXML.cxx	(版本 44)
+++ scite/src/ExportXML.cxx	(版本 45)
@@ -12,6 +12,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/src/FilePath.cxx
===================================================================
--- scite/src/FilePath.cxx	(版本 44)
+++ scite/src/FilePath.cxx	(版本 45)
@@ -11,6 +11,8 @@
 #include <ctime>
 #include <cerrno>
 
+#include <utility>
+#include <compare>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -64,12 +66,9 @@
 const GUI::gui_char configFileVisibilityString[] = GUI_TEXT("");
 #endif
 
-const GUI::gui_char fileRead[] = GUI_TEXT("rb");
-const GUI::gui_char fileWrite[] = GUI_TEXT("wb");
-
 namespace {
-const GUI::gui_char currentDirectory[] = GUI_TEXT(".");
-const GUI::gui_char parentDirectory[] = GUI_TEXT("..");
+const GUI::gui_string_view currentDirectory = GUI_TEXT(".");
+const GUI::gui_string_view parentDirectory = GUI_TEXT("..");
 }
 
 FilePath::FilePath() noexcept = default;
@@ -76,9 +75,9 @@
 
 FilePath::FilePath(const GUI::gui_char *fileName_) : fileName(fileName_ ? fileName_ : GUI_TEXT("")) {}
 
-FilePath::FilePath(const GUI::gui_string_view fileName_) : fileName(fileName_) {}
+FilePath::FilePath(GUI::gui_string_view fileName_) : fileName(fileName_) {}
 
-FilePath::FilePath(const GUI::gui_string &fileName_) : fileName(fileName_) {}
+FilePath::FilePath(GUI::gui_string fileName_) noexcept : fileName(std::move(fileName_)) {}
 
 FilePath::FilePath(FilePath const &directory, FilePath const &name) {
 	Set(directory, name);
@@ -97,7 +96,7 @@
 		fileName = name.fileName;
 	} else {
 		fileName = directory.fileName;
-		if (fileName.size() && (fileName[fileName.size()-1] != pathSepChar))
+		if (!fileName.empty() && !fileName.ends_with(pathSepChar))
 			fileName += pathSepString;
 		fileName += name.fileName;
 	}
@@ -127,28 +126,27 @@
 
 #endif
 
-bool FilePath::operator==(const FilePath &other) const noexcept {
-	return SameNameAs(other);
-}
-
-bool FilePath::operator<(const FilePath &other) const noexcept {
+std::weak_ordering FilePath::operator<=>(const FilePath &other) const noexcept {
 #ifdef _WIN32
-	return CSTR_LESS_THAN == Compare(fileName, other.fileName);
+	switch (Compare(fileName, other.fileName)) {
+	case CSTR_EQUAL:
+		return std::weak_ordering::equivalent;
+	case CSTR_LESS_THAN:
+		return std::weak_ordering::less;
+	default:
+		return std::weak_ordering::greater;
+	}
 #else
-	return fileName < other.fileName;
+	return fileName <=> other.fileName;
 #endif
 }
 
 bool FilePath::SameNameAs(const FilePath &other) const noexcept {
-#ifdef _WIN32
-	return CSTR_EQUAL == Compare(fileName, other.fileName);
-#else
 	return fileName == other.fileName;
-#endif
 }
 
 bool FilePath::IsSet() const noexcept {
-	return fileName.length() > 0;
+	return !fileName.empty();
 }
 
 bool FilePath::IsUntitled() const noexcept {
@@ -157,7 +155,7 @@
 }
 
 bool FilePath::IsAbsolute() const noexcept {
-	if (fileName.length() == 0)
+	if (fileName.empty())
 		return false;
 #if defined(__unix__) || defined(__APPLE__)
 	if (fileName[0] == '/')
@@ -188,7 +186,7 @@
 #endif
 }
 
-int FilePath::RootLength() noexcept {
+size_t FilePath::RootLength() noexcept {
 #ifdef _WIN32
 	return 3;
 #else
@@ -205,27 +203,23 @@
 }
 
 FilePath FilePath::Name() const {
-	const size_t dirEnd = fileName.rfind(pathSepChar);
-	if (dirEnd != GUI::gui_string::npos)
+	if (const size_t dirEnd = fileName.rfind(pathSepChar); dirEnd != GUI::gui_string::npos)
 		return fileName.substr(dirEnd + 1);
-	else
-		return fileName;
+	return fileName;
 }
 
 FilePath FilePath::BaseName() const {
-	const size_t dirEnd = fileName.rfind(pathSepChar);
 	const size_t extStart = fileName.rfind('.');
-	if (dirEnd != GUI::gui_string::npos) {
+	if (const size_t dirEnd = fileName.rfind(pathSepChar); dirEnd != GUI::gui_string::npos) {
 		if (extStart > dirEnd) {
-			return FilePath(fileName.substr(dirEnd + 1, extStart - dirEnd - 1));
-		} else {
-			return FilePath(fileName.substr(dirEnd + 1));
+			return { fileName.substr(dirEnd + 1, extStart - dirEnd - 1) };
 		}
-	} else if (extStart != GUI::gui_string::npos) {
-		return FilePath(fileName.substr(0, extStart));
-	} else {
-		return fileName;
+		return { fileName.substr(dirEnd + 1) };
 	}
+	if (extStart != GUI::gui_string::npos) {
+		return { fileName.substr(0, extStart) };
+	}
+	return fileName;
 }
 
 FilePath FilePath::Extension() const {
@@ -233,24 +227,20 @@
 	const size_t extStart = fileName.rfind('.');
 	if ((extStart != GUI::gui_string::npos) && ((dirEnd == GUI::gui_string::npos) || (extStart > dirEnd)))
 		return fileName.substr(extStart + 1);
-	else
-		return GUI_TEXT("");
+	return GUI_TEXT("");
 }
 
 FilePath FilePath::Directory() const {
 	if (IsRoot()) {
-		return FilePath(fileName);
-	} else {
-		size_t lenDirectory = fileName.rfind(pathSepChar);
-		if (lenDirectory != GUI::gui_string::npos) {
-			if (lenDirectory < static_cast<size_t>(RootLength())) {
-				lenDirectory = static_cast<size_t>(RootLength());
-			}
-			return FilePath(fileName.substr(0, lenDirectory));
-		} else {
-			return FilePath();
+		return { fileName };
+	}
+	if (size_t lenDirectory = fileName.rfind(pathSepChar); lenDirectory != GUI::gui_string::npos) {
+		if (lenDirectory < RootLength()) {
+			lenDirectory = RootLength();
 		}
+		return { fileName.substr(0, lenDirectory) };
 	}
+	return {};
 }
 
 namespace {
@@ -298,12 +288,12 @@
 
 FilePath FilePath::NormalizePath() const {
 	if (fileName.empty()) {
-		return FilePath();
+		return {};
 	}
 	GUI::gui_string path(fileName);
 #ifdef _WIN32
 	// Convert Unix path separators to Windows
-	std::replace(path.begin(), path.end(), L'/', pathSepChar);
+	std::ranges::replace(path, L'/', pathSepChar);
 #endif
 	GUI::gui_string_view source = path;
 	GUI::gui_string absPathString;
@@ -341,7 +331,7 @@
 			break;
 		source.remove_prefix(separator+1);
 	}
-	return FilePath(absPathString);
+	return { absPathString };
 }
 
 GUI::gui_string FilePath::RelativePathTo(const FilePath &filePath) const {
@@ -365,10 +355,11 @@
 #ifdef _WIN32
 	// The run-time libraries for GCC and Visual C++ give different results for _fullpath
 	// so use the OS.
-	GUI::gui_char absPath[2000] {};
+	constexpr size_t maxAbsPath = 2000;
+	GUI::gui_char absPath[maxAbsPath] {};
 	GUI::gui_char *fileBit = nullptr;
-	::GetFullPathNameW(AsInternal(), sizeof(absPath)/sizeof(absPath[0]), absPath, &fileBit);
-	return FilePath(absPath);
+	::GetFullPathNameW(AsInternal(), std::size(absPath), absPath, &fileBit);
+	return { absPath };
 #else
 	if (IsAbsolute()) {
 		return NormalizePath();
@@ -397,9 +388,9 @@
 		if (!gswd.empty() && (gswd.back() == pathSepChar)) {
 			gswd.pop_back();
 		}
-		return FilePath(gswd);
+		return { gswd };
 	}
-	return FilePath();
+	return {};
 }
 
 bool FilePath::SetWorkingDirectory() const noexcept {
@@ -466,16 +457,15 @@
 
 	closedir(dp);
 #endif
-	std::sort(files.begin(), files.end());
-	std::sort(directories.begin(), directories.end());
+	std::ranges::sort(files);
+	std::ranges::sort(directories);
 }
 
 FILE *FilePath::Open(const GUI::gui_char *mode) const noexcept {
 	if (IsSet()) {
 		return fopen(fileName.c_str(), mode);
-	} else {
-		return nullptr;
 	}
+	return nullptr;
 }
 
 std::string FilePath::Read() const {
@@ -512,8 +502,7 @@
 	FileStatus statusFile;
 	if (stat(AsInternal(), &statusFile) != -1)
 		return statusFile.st_mtime;
-	else
-		return 0;
+	return 0;
 }
 
 long long FilePath::GetFileLength() const noexcept {
@@ -523,7 +512,8 @@
 	WIN32_FILE_ATTRIBUTE_DATA fad {};
 	if (!GetFileAttributesEx(AsInternal(), GetFileExInfoStandard, &fad))
 		return 0;
-	return (static_cast<unsigned long long>(fad.nFileSizeHigh) << 32) + fad.nFileSizeLow;
+	constexpr size_t bitsDWORD = 32;
+	return (static_cast<unsigned long long>(fad.nFileSizeHigh) << bitsDWORD) + fad.nFileSizeLow;
 #else
 	struct stat statusFile;
 	if (stat(AsInternal(), &statusFile) != -1)
@@ -621,7 +611,7 @@
 
 namespace {
 
-typedef DWORD(STDAPICALLTYPE *GetLongSig)(const GUI::gui_char *lpszShortPath, GUI::gui_char *lpszLongPath, DWORD cchBuffer);
+using GetLongSig = DWORD(STDAPICALLTYPE *)(const GUI::gui_char *lpszShortPath, GUI::gui_char *lpszLongPath, DWORD cchBuffer);
 GetLongSig pfnGetLong = nullptr;
 bool kernelTried = false;
 
@@ -654,13 +644,13 @@
 	}
 	GUI::gui_string gsLong(1, L'\0');
 	// Call with too-short string returns size + terminating NUL
-	const DWORD size = (pfnGetLong)(shortPath, &gsLong[0], 0);
+	const DWORD size = (pfnGetLong)(shortPath, gsLong.data(), 0);
 	if (size == 0) {
 		return false;
 	}
 	gsLong.resize(size);
 	// Call with correct size string returns size without terminating NUL
-	const DWORD characters = (pfnGetLong)(shortPath, &gsLong[0], size);
+	const DWORD characters = (pfnGetLong)(shortPath, gsLong.data(), size);
 	if (characters != 0) {
 		longPath.assign(gsLong, 0, characters);
 	}
@@ -754,11 +744,13 @@
 
 	if (running && pi.hProcess && pi.hThread) {
 		// Wait until child process exits but time out after 5 seconds.
-		::WaitForSingleObject(pi.hProcess, 5 * 1000);
+		constexpr DWORD maxWait = 5 * 1000;
+		::WaitForSingleObject(pi.hProcess, maxWait);
 
 		DWORD bytesRead = 0;
 		DWORD bytesAvail = 0;
-		char buffer[8 * 1024] {};
+		constexpr size_t pipeBufferSize = 8 * 1024;
+		char buffer[pipeBufferSize] {};
 
 		if (::PeekNamedPipe(hPipeRead, buffer, sizeof(buffer), &bytesRead, &bytesAvail, nullptr)) {
 			if (bytesAvail > 0) {
Index: scite/src/FilePath.h
===================================================================
--- scite/src/FilePath.h	(版本 44)
+++ scite/src/FilePath.h	(版本 45)
@@ -11,12 +11,13 @@
 extern const GUI::gui_char pathSepString[];
 extern const GUI::gui_char listSepString[];
 extern const GUI::gui_char configFileVisibilityString[];
-extern const GUI::gui_char fileRead[];
-extern const GUI::gui_char fileWrite[];
 
+constexpr const GUI::gui_char *fileRead = GUI_TEXT("rb");
+constexpr const GUI::gui_char *fileWrite = GUI_TEXT("wb");
+
 class FilePath;
 
-typedef std::vector<FilePath> FilePathSet;
+using FilePathSet = std::vector<FilePath>;
 
 struct FileCloser {
 	// Called by unique_ptr to close the file
@@ -34,8 +35,8 @@
 public:
 	FilePath() noexcept;
 	FilePath(const GUI::gui_char *fileName_);
-	FilePath(const GUI::gui_string_view fileName_);
-	FilePath(const GUI::gui_string &fileName_);
+	FilePath(GUI::gui_string_view fileName_);
+	FilePath(GUI::gui_string fileName_) noexcept;
 	FilePath(FilePath const &directory, FilePath const &name);
 	FilePath(FilePath const &) = default;
 	FilePath(FilePath &&) noexcept = default;
@@ -49,13 +50,13 @@
 	void SetDirectory(FilePath const &directory);
 	virtual void Init() noexcept;
 	[[nodiscard]]bool SameNameAs(const FilePath &other) const noexcept;
-	bool operator==(const FilePath &other) const noexcept;
-	bool operator<(const FilePath &other) const noexcept;
+	bool operator==(const FilePath &other) const noexcept = default;
+	std::weak_ordering operator<=>(const FilePath &other) const noexcept;
 	bool IsSet() const noexcept;
 	bool IsUntitled() const noexcept;
 	bool IsAbsolute() const noexcept;
 	bool IsRoot() const noexcept;
-	static int RootLength() noexcept;
+	static size_t RootLength() noexcept;
 	const GUI::gui_char *AsInternal() const noexcept;
 	std::string AsUTF8() const;
 	FilePath Name() const;
Index: scite/src/FileWorker.cxx
===================================================================
--- scite/src/FileWorker.cxx	(版本 44)
+++ scite/src/FileWorker.cxx	(版本 45)
@@ -10,6 +10,8 @@
 #include <cstring>
 #include <cstdio>
 
+#include <utility>
+#include <compare>
 #include <string>
 #include <vector>
 #include <memory>
@@ -29,12 +31,11 @@
 
 constexpr double timeBetweenProgress = 0.4;
 
-FileWorker::FileWorker(WorkerListener *pListener_, const FilePath &path_, size_t size_, FILE *fp_) :
-	pListener(pListener_), path(path_), size(size_), err(0), fp(fp_), sleepTime(0), nextProgress(timeBetweenProgress) {
+FileWorker::FileWorker(WorkerListener *pListener_, FilePath path_, size_t size_, FILE *fp_) noexcept :
+	pListener(pListener_), path(std::move(path_)), size(size_), err(0), fp(fp_), sleepTime(0), nextProgress(timeBetweenProgress) {
 }
 
-FileWorker::~FileWorker() noexcept {
-}
+FileWorker::~FileWorker() noexcept = default;
 
 double FileWorker::Duration() noexcept {
 	return et.Duration();
@@ -100,10 +101,18 @@
 	convert = Utf8_16::Writer::Allocate(unicodeMode, blockSize);
 }
 
-static constexpr bool IsUTF8TrailByte(int ch) noexcept {
-	return (ch >= 0x80) && (ch < (0x80 + 0x40));
+namespace {
+
+constexpr int minUTF8Trail = 0x80;
+constexpr int minUTF8Lead = 0x80 + 0x40;
+
+constexpr bool IsUTF8TrailByte(char ch) noexcept {
+	const unsigned char uch = ch;
+	return (uch >= minUTF8Trail) && (uch < minUTF8Lead);
 }
 
+}
+
 void FileStorer::Execute() noexcept {
 	try {
 		if (fp) {
@@ -114,11 +123,12 @@
 				size_t grabSize = std::min(lengthDoc - startBlock, blockSize);
 				if ((unicodeMode != UniMode::uni8Bit) && (startBlock + grabSize < lengthDoc)) {
 					// Round down so only whole characters retrieved.
+					constexpr size_t maxRounding = 5;
 					size_t startLast = grabSize;
-					while ((startLast > 0) && ((grabSize - startLast) < 6) &&
-						IsUTF8TrailByte(static_cast<unsigned char>(documentBytes[startBlock + startLast])))
+					while ((startLast > 0) && ((grabSize - startLast) <= maxRounding) &&
+						IsUTF8TrailByte(documentBytes[startBlock + startLast]))
 						startLast--;
-					if ((grabSize - startLast) < 5)
+					if ((grabSize - startLast) < maxRounding)
 						grabSize = startLast;
 				}
 				const size_t written = convert->fwrite(documentView.substr(startBlock, grabSize), fp);
Index: scite/src/FileWorker.h
===================================================================
--- scite/src/FileWorker.h	(版本 44)
+++ scite/src/FileWorker.h	(版本 45)
@@ -21,7 +21,7 @@
 	int sleepTime;
 	double nextProgress;
 
-	FileWorker(WorkerListener *pListener_, const FilePath &path_, size_t size_, FILE *fp_);
+	FileWorker(WorkerListener *pListener_, FilePath path_, size_t size_, FILE *fp_) noexcept;
 	~FileWorker() noexcept override;
 	virtual double Duration() noexcept;
 	void Cancel() noexcept override {
Index: scite/src/GUI.h
===================================================================
--- scite/src/GUI.h	(版本 44)
+++ scite/src/GUI.h	(版本 45)
@@ -28,7 +28,7 @@
 	int right;
 	int bottom;
 
-	explicit constexpr Rectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) noexcept :
+	explicit constexpr Rectangle(int left_=0, int top_=0, int right_=0, int bottom_=0) noexcept :
 		left(left_), top(top_), right(right_), bottom(bottom_) {
 	}
 	bool Contains(Point pt) const noexcept {
@@ -37,12 +37,7 @@
 	}
 	int Width() const noexcept { return right - left; }
 	int Height() const noexcept { return bottom - top; }
-	bool operator==(const Rectangle &other) const noexcept {
-		return (left == other.left) &&
-		       (top == other.top) &&
-		       (right == other.right) &&
-		       (bottom == other.bottom);
-	}
+	constexpr bool operator==(const Rectangle &other) const noexcept = default;
 };
 
 #if defined(GTK) || defined(__APPLE__)
@@ -49,9 +44,9 @@
 
 // On GTK and macOS use UTF-8 char strings
 
-typedef char gui_char;
-typedef std::string gui_string;
-typedef std::string_view gui_string_view;
+using gui_char = char;
+using gui_string = std::string;
+using gui_string_view = std::string_view;
 
 #define GUI_TEXT(q) q
 
@@ -59,14 +54,16 @@
 
 // On Win32 use UTF-16 wide char strings
 
-typedef wchar_t gui_char;
-typedef std::wstring gui_string;
-typedef std::wstring_view gui_string_view;
+using gui_char = wchar_t;
+using gui_string = std::wstring;
+using gui_string_view = std::wstring_view;
 
 #define GUI_TEXT(q) L##q
 
 #endif
 
+constexpr int hexBase = 16;
+
 gui_string StringFromUTF8(const char *s);
 gui_string StringFromUTF8(const std::string &s);
 gui_string StringFromUTF8(std::string_view sv);
@@ -77,7 +74,7 @@
 
 std::string LowerCaseUTF8(std::string_view sv);
 
-typedef void *WindowID;
+using WindowID = void *;
 class Window {
 protected:
 	WindowID wid {};
@@ -114,7 +111,7 @@
 	void SetRedraw(bool redraw);
 };
 
-typedef void *MenuID;
+using MenuID = void *;
 class Menu {
 	MenuID mid {};
 public:
Index: scite/src/JobQueue.cxx
===================================================================
--- scite/src/JobQueue.cxx	(版本 44)
+++ scite/src/JobQueue.cxx	(版本 45)
@@ -13,6 +13,7 @@
 #include <cstdarg>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -36,24 +37,29 @@
 #include "JobQueue.h"
 
 JobSubsystem SubsystemFromChar(char c) noexcept {
-	if (c == '1')
+	switch (c) {
+	case '1':
 		return JobSubsystem::gui;
-	else if (c == '2')
+	case '2':
 		return JobSubsystem::shell;
-	else if (c == '3')
+	case '3':
 		return JobSubsystem::extension;
-	else if (c == '4')
+	case '4':
 		return JobSubsystem::help;
-	else if (c == '5')
+	case '5':
 		return JobSubsystem::otherHelp;
-	else if (c == '7')
+	case '6':
+		return JobSubsystem::grep;
+	case '7':
 		return JobSubsystem::immediate;
-	return JobSubsystem::cli;
+	default:
+		return JobSubsystem::cli;
+	}
 }
 
 namespace {
 
-void SetOptionFromValidString(bool &option, const std::string &s) {
+void SetOptionFromValidString(bool &option, const std::string &s) noexcept {
 	if (s.empty() || s[0] == '1' || s == "yes")
 		option = true;
 	else if (s[0] == '0' || s == "no")
@@ -78,7 +84,7 @@
 
 		std::vector<std::string> optValue = StringSplit(mode, ':');
 
-		if (optValue.size() == 0) {
+		if (optValue.empty()) {
 			continue;
 		}
 
@@ -152,12 +158,12 @@
 
 	propName = "command.is.filter.";
 	propName += itemSuffix;
-	if (props.GetWild(propName, fileNameExt).length())
+	if (!props.GetWild(propName, fileNameExt).empty())
 		isFilter = (props.GetNewExpandString(propName, fileNameExt) == "1");
 
 	propName = "command.subsystem.";
 	propName += itemSuffix;
-	if (props.GetWild(propName, fileNameExt).length()) {
+	if (!props.GetWild(propName, fileNameExt).empty()) {
 		std::string subsystemVal = props.GetNewExpandString(propName, fileNameExt);
 		jobType = SubsystemFromChar(subsystemVal[0]);
 	}
@@ -164,7 +170,7 @@
 
 	propName = "command.input.";
 	propName += itemSuffix;
-	if (props.GetWild(propName, fileNameExt).length()) {
+	if (!props.GetWild(propName, fileNameExt).empty()) {
 		input = props.GetNewExpandString(propName, fileNameExt);
 		flags |= jobHasInput;
 	}
@@ -171,7 +177,7 @@
 
 	propName = "command.quiet.";
 	propName += itemSuffix;
-	if (props.GetWild(propName, fileNameExt).length())
+	if (!props.GetWild(propName, fileNameExt).empty())
 		quiet = props.GetNewExpandString(propName, fileNameExt) == "1";
 	if (quiet)
 		flags |= jobQuiet;
@@ -196,8 +202,8 @@
 	Clear();
 }
 
-Job::Job(std::string_view command_, const FilePath &directory_, JobSubsystem jobType_, std::string_view input_, int flags_)
-	: command(command_), directory(directory_), jobType(jobType_), input(input_), flags(flags_) {
+Job::Job(std::string_view command_, FilePath directory_, JobSubsystem jobType_, std::string_view input_, int flags_)
+	: command(std::move(command_)), directory(std::move(directory_)), jobType(jobType_), input(input_), flags(flags_) {
 }
 
 void Job::Clear() noexcept {
@@ -220,8 +226,7 @@
 	timeCommands = false;
 }
 
-JobQueue::~JobQueue() {
-}
+JobQueue::~JobQueue() = default;
 
 bool JobQueue::TimeCommands() const noexcept {
 	return timeCommands;
@@ -266,7 +271,7 @@
 }
 
 void JobQueue::AddCommand(std::string_view command, const FilePath &directory, JobSubsystem jobType, std::string_view input, int flags) {
-	if ((commandCurrent < commandMax) && (command.length())) {
+	if ((commandCurrent < commandMax) && (!command.empty())) {
 		if (commandCurrent == 0)
 			jobUsesOutputPane = false;
 		jobQueue[commandCurrent] = Job(command, directory, jobType, input, flags);
Index: scite/src/JobQueue.h
===================================================================
--- scite/src/JobQueue.h	(版本 44)
+++ scite/src/JobQueue.h	(版本 45)
@@ -47,7 +47,7 @@
 	int flags;
 
 	Job() noexcept;
-	Job(std::string_view command_, const FilePath &directory_, JobSubsystem jobType_, std::string_view input_, int flags_);
+	Job(std::string_view command_, FilePath directory_, JobSubsystem jobType_, std::string_view input_, int flags_);
 	void Clear() noexcept;
 };
 
Index: scite/src/LuaExtension.cxx
===================================================================
--- scite/src/LuaExtension.cxx	(版本 44)
+++ scite/src/LuaExtension.cxx	(版本 45)
@@ -9,6 +9,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/src/MatchMarker.cxx
===================================================================
--- scite/src/MatchMarker.cxx	(版本 44)
+++ scite/src/MatchMarker.cxx	(版本 45)
@@ -24,6 +24,13 @@
 
 namespace SA = Scintilla;
 
+namespace {
+
+// Limit the search duration to 250 ms. Avoid to freeze editor for huge lines.
+constexpr double maxDuration = 0.25;
+
+}
+
 std::vector<LineRange> LinesBreak(SA::ScintillaCall *pSci) {
 	std::vector<LineRange> lineRanges;
 	if (pSci) {
@@ -97,8 +104,7 @@
 	SA::Span rangeFound = pSci->SpanSearchInTarget(textMatch);
 	while ((rangeFound.start >= 0) && (rangeFound.start != matchPrevious)) {
 		matchPrevious = rangeFound.start;
-		// Limit the search duration to 250 ms. Avoid to freeze editor for huge lines.
-		if (searchElapsedTime.Duration() > 0.25) {
+		if (searchElapsedTime.Duration() > maxDuration) {
 			// Clear all indicators because timer has expired.
 			pSci->IndicatorClearRange(0, pSci->Length());
 			lineRanges.clear();
Index: scite/src/PathMatch.cxx
===================================================================
--- scite/src/PathMatch.cxx	(版本 44)
+++ scite/src/PathMatch.cxx	(版本 45)
@@ -7,6 +7,7 @@
 
 #include <cassert>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -25,6 +26,8 @@
 
 namespace {
 
+constexpr int decimalbase = 10;
+
 int IntFromString(std::u32string_view s) noexcept {
 	if (s.empty()) {
 		return 0;
@@ -35,7 +38,7 @@
 	}
 	int value = 0;
 	while (!s.empty()) {
-		value = value * 10 + s.front() - '0';
+		value = value * decimalbase + s.front() - '0';
 		s.remove_prefix(1);
 	}
 	return negate ? -value : value;
@@ -214,7 +217,7 @@
 
 namespace {
 
-static void TestPatternMatch() {
+void TestPatternMatch() {
 	static bool done = false;
 	if (done) {
 		return;
@@ -316,7 +319,7 @@
 	}
 #if defined(_WIN32)
 	// Convert Windows path separators to Unix
-	std::replace(relPath.begin(), relPath.end(), '\\', '/');
+	std::ranges::replace(relPath, '\\', '/');
 #endif
 	if (!FilePath::CaseSensitive()) {
 		pattern = GUI::LowerCaseUTF8(pattern);
Index: scite/src/PropSetFile.cxx
===================================================================
--- scite/src/PropSetFile.cxx	(版本 44)
+++ scite/src/PropSetFile.cxx	(版本 45)
@@ -13,6 +13,7 @@
 #include <ctime>
 
 #include <stdexcept>
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -19,6 +20,7 @@
 #include <vector>
 #include <map>
 #include <set>
+#include <optional>
 #include <algorithm>
 #include <memory>
 #include <chrono>
@@ -50,10 +52,9 @@
 
 bool ImportFilter::IsValid(const std::string &name) const {
 	if (!includes.empty()) {
-		return includes.count(name) > 0;
-	} else {
-		return excludes.count(name) == 0;
+		return includes.contains(name);
 	}
+	return !excludes.contains(name);
 }
 
 bool PropSetFile::caseSensitiveFilenames = false;
@@ -114,14 +115,12 @@
 	const mapss::const_iterator keyPos = props.find(key);
 	if (keyPos != props.end()) {
 		return true;
-	} else {
-		if (superPS) {
-			// Failed here, so try in base property set
-			return superPS->Exists(key);
-		} else {
-			return false;
-		}
 	}
+	if (superPS) {
+		// Failed here, so try in base property set
+		return superPS->Exists(key);
+	}
+	return false;
 }
 
 std::string_view PropSetFile::Get(std::string_view key) const {
@@ -176,16 +175,25 @@
 	}
 }
 
+using OptArgument = std::optional<std::string_view>;
+
+OptArgument MatchCommand(std::string_view key, std::string_view command) {
+	if (key.starts_with(command)) {
+		return key.substr(command.length());
+	}
+	return {};
 }
 
+}
+
 std::string PropSetFile::Evaluate(std::string_view key) const {
 	if (key.find(' ') != std::string_view::npos) {
-		if (StartsWith(key, "escape ")) {
-			std::string val(Get(key.substr(7)));
+		if (OptArgument argEscape = MatchCommand(key, "escape ")) {
+			std::string val(Get(argEscape.value()));
 			ShellEscape(val);
 			return val;
-		} else if (StartsWith(key, "= ")) {
-			const std::string sExpressions(key.substr(2));
+		} else if (OptArgument argCompare = MatchCommand(key, "= ")) {
+			const std::string sExpressions(argCompare.value());
 			std::vector<std::string> parts = StringSplit(sExpressions, ';');
 			if (parts.size() > 1) {
 				bool equal = true;
@@ -196,14 +204,14 @@
 				}
 				return equal ? "1" : "0";
 			}
-		} else if (StartsWith(key, "star ")) {
-			const std::string sKeybase(key.substr(5));
+		} else if (OptArgument argStar = MatchCommand(key, "star ")) {
+			const std::string sKeybase(argStar.value());
 			// Create set of variables with values
 			mapss values;
 			// For this property set and all base sets
 			for (const PropSetFile *psf = this; psf; psf = psf->superPS) {
 				mapss::const_iterator it = psf->props.lower_bound(sKeybase);
-				while ((it != psf->props.end()) && (it->first.find(sKeybase) == 0)) {
+				while ((it != psf->props.end()) && (it->first.starts_with(sKeybase))) {
 					const mapss::iterator itDestination = values.find(it->first);
 					if (itDestination == values.end()) {
 						// Not present so add
@@ -218,15 +226,15 @@
 				combination += itV->second;
 			}
 			return combination;
-		} else if (StartsWith(key, "scale ")) {
-			const int scaleFactor = GetInt("ScaleFactor", 100);
-			std::string val(key.substr(6));
-			if (scaleFactor == 100) {
+		} else if (OptArgument argScale = MatchCommand(key, "scale ")) {
+			constexpr int divisor = 100;
+			const int scaleFactor = GetInt("ScaleFactor", divisor);
+			std::string val(argScale.value());
+			if (scaleFactor == divisor) {
 				return val;
-			} else {
-				const int value = IntegerFromString(val, 1);
-				return StdStringFromInteger(value * scaleFactor / 100);
 			}
+			const int value = IntegerFromString(val, 1);
+			return StdStringFromInteger(value * scaleFactor / divisor);
 		}
 	} else {
 		return std::string(Get(key));
@@ -234,6 +242,10 @@
 	return "";
 }
 
+namespace {
+
+constexpr int maxIterations = 200;
+
 // There is some inconsistency between GetExpanded("foo") and Expand("$(foo)").
 // A solution is to keep a stack of variables that have been expanded, so that
 // recursive expansions can be skipped.  For now I'll just use the C++ stack
@@ -241,21 +253,21 @@
 
 struct VarChain {
 	VarChain() = default;
-	explicit VarChain(std::string_view var_, const VarChain *link_=nullptr) noexcept : var(var_), link(link_) {}
+	explicit VarChain(std::string_view var_, const VarChain *link_ = nullptr) noexcept : var(var_), link(link_) {}
 
-	bool contains(std::string_view testVar) const {
+	[[nodiscard]] bool contains(std::string_view testVar) const {
 		return (var == testVar)
-		       || (link && link->contains(testVar));
+			|| (link && link->contains(testVar));
 	}
 
 	const std::string_view var;
-	const VarChain *link=nullptr;
+	const VarChain *link = nullptr;
 };
 
-static int ExpandAllInPlace(const PropSetFile &props, std::string &withVars, int maxExpands, const VarChain &blankVars = VarChain()) {
+int ExpandAllInPlace(const PropSetFile &props, std::string &withVars, int maxExpands, const VarChain &blankVars = VarChain()) {
 	size_t varStart = withVars.find("$(");
 	while ((varStart != std::string::npos) && (maxExpands > 0)) {
-		const size_t varEnd = withVars.find(')', varStart+2);
+		const size_t varEnd = withVars.find(')', varStart + 2);
 		if (varEnd == std::string::npos) {
 			break;
 		}
@@ -262,10 +274,10 @@
 
 		// For consistency, when we see '$(ab$(cde))', expand the inner variable first,
 		// regardless whether there is actually a degenerate variable named 'ab$(cde'.
-		size_t innerVarStart = withVars.find("$(", varStart+2);
+		size_t innerVarStart = withVars.find("$(", varStart + 2);
 		while ((innerVarStart != std::string::npos) && (innerVarStart < varEnd)) {
 			varStart = innerVarStart;
-			innerVarStart = withVars.find("$(", varStart+2);
+			innerVarStart = withVars.find("$(", varStart + 2);
 		}
 
 		std::string var(withVars, varStart + 2, varEnd - (varStart + 2));
@@ -279,7 +291,7 @@
 			maxExpands = ExpandAllInPlace(props, val, maxExpands, VarChain(var, &blankVars));
 		}
 
-		withVars.erase(varStart, varEnd-varStart+1);
+		withVars.erase(varStart, varEnd - varStart + 1);
 		withVars.insert(varStart, val);
 
 		varStart = withVars.find("$(");
@@ -288,9 +300,11 @@
 	return maxExpands;
 }
 
+}
+
 std::string PropSetFile::GetExpandedString(std::string_view key) const {
 	std::string val(Get(key));
-	ExpandAllInPlace(*this, val, 200, VarChain(key));
+	ExpandAllInPlace(*this, val, maxIterations, VarChain(key));
 	return val;
 }
 
@@ -323,15 +337,15 @@
 		const char ch = data[0];
 		data.remove_prefix(1);
 		if ((ch == '\r') || (ch == '\n')) {
-			if ((data.length() > 0) && (ch == '\r') && (data[0] == '\n')) {
+			if ((ch == '\r') && data.starts_with('\n')) {
 				// munch the second half of a crlf
 				data.remove_prefix(1);
 			}
 			return;
-		} else if ((ch == '\\') && (data.length() > 0) && ((data[0] == '\r') || (data[0] == '\n'))) {
+		} else if ((ch == '\\') && !data.empty() && ((data[0] == '\r') || (data[0] == '\n'))) {
 			const char next = data[0];
 			data.remove_prefix(1);
-			if ((data.length() > 0) && (next == '\r') && (data[0] == '\n')) {
+			if ((next == '\r') && data.starts_with('\n')) {
 				data.remove_prefix(1);
 			}
 		} else {
@@ -353,14 +367,16 @@
 	return name.find("SciTE") != std::string::npos;
 }
 
+constexpr int maxDepthImport = 20;
+
 }
 
 void PropSetFile::Import(const FilePath &filename, const FilePath &directoryForImports, const ImportFilter &filter,
 			 FilePathSet *imports, size_t depth) {
-	if (depth > 20)	// Possibly recursive import so give up to avoid crash
+	if (depth > maxDepthImport)	// Possibly recursive import so give up to avoid crash
 		return;
 	if (Read(filename, directoryForImports, filter, imports, depth)) {
-		if (imports && (std::find(imports->begin(), imports->end(), filename) == imports->end())) {
+		if (imports && (std::ranges::find(*imports, filename) == imports->end())) {
 			imports->push_back(filename);
 		}
 	}
@@ -373,7 +389,7 @@
 	}
 	if ((rls == ReadLineState::conditionFalse) && (!IsSpaceOrTab(lineBuffer[0])))    // If clause ends with first non-indented line
 		rls = ReadLineState::active;
-	if (StartsWith(lineBuffer, "module ")) {
+	if (lineBuffer.starts_with("module ")) {
 		std::string moduleName = lineBuffer.substr(strlen("module") + 1);
 		if (moduleName.empty() || filter.IsValid(moduleName)) {
 			rls = ReadLineState::active;
@@ -385,11 +401,11 @@
 	if (rls != ReadLineState::active) {
 		return rls;
 	}
-	if (StartsWith(lineBuffer, "if ")) {
+	if (lineBuffer.starts_with("if ")) {
 		std::string_view expr = lineBuffer;
 		expr.remove_prefix(strlen("if") + 1);
 		std::string value = Expand(expr);
-		if (value == "0" || value == "") {
+		if (value == "0" || value.empty()) {
 			rls = ReadLineState::conditionFalse;
 		} else if (value == "1") {
 			rls = ReadLineState::active;
@@ -396,13 +412,13 @@
 		} else {
 			rls = (GetInt(value) != 0) ? ReadLineState::active : ReadLineState::conditionFalse;
 		}
-	} else if (superPS && StartsWith(lineBuffer, "match ")) {
+	} else if (superPS && lineBuffer.starts_with("match ")) {
 		// Don't match on stand-alone property sets like localiser
 		const std::string pattern = lineBuffer.substr(strlen("match") + 1);
 		const std::string relPath(Get("RelativePath"));
 		const bool matches = PathMatch(pattern, relPath);
 		rls = matches ? ReadLineState::active : ReadLineState::conditionFalse;
-	} else if (StartsWith(lineBuffer, "import ")) {
+	} else if (lineBuffer.starts_with("import ")) {
 		if (directoryForImports.IsSet()) {
 			std::string importName = lineBuffer.substr(strlen("import") + 1);
 			if (importName == "*") {
@@ -453,7 +469,7 @@
 	if (!propsData.empty()) {
 		std::string_view data(propsData);
 		const std::string_view svUtf8BOM(UTF8BOM);
-		if (StartsWith(data, svUtf8BOM)) {
+		if (data.starts_with(svUtf8BOM)) {
 			data.remove_prefix(svUtf8BOM.length());
 		}
 		ReadFromMemory(data, directoryForImports, filter, imports, depth);
@@ -467,10 +483,8 @@
 bool StringEqual(std::string_view a, std::string_view b, bool caseSensitive) noexcept {
 	if (caseSensitive) {
 		return a == b;
-	} else {
-		return EqualCaseInsensitive(a, b);
 	}
-	return true;
+	return EqualCaseInsensitive(a, b);
 }
 
 // Match file names to patterns allowing for '*' and '?'.
@@ -528,7 +542,7 @@
 	const PropSetFile *psf = this;
 	while (psf) {
 		mapss::const_iterator it = psf->props.lower_bound(keybase);
-		while ((it != psf->props.end()) && StartsWith(it->first, keybase)) {
+		while ((it != psf->props.end()) && it->first.starts_with(keybase)) {
 			if (it->first == keybase) {
 				return it->second;
 			}
@@ -537,7 +551,7 @@
 			std::string key;	// keyFile may point into key so key lifetime must cover keyFile
 			std::string_view keyFile = orgkeyfile;
 
-			if (StartsWith(orgkeyfile, "$(")) {
+			if (orgkeyfile.starts_with("$(")) {
 				// $(X) is a variable so extract X and find its value
 				const size_t endVar = orgkeyfile.find_first_of(')');
 				if (endVar != std::string_view::npos) {
@@ -569,7 +583,7 @@
 std::string PropSetFile::GetNewExpandString(std::string_view keybase, std::string_view filename) const {
 	std::string withVars(GetWild(keybase, filename));
 	size_t varStart = withVars.find("$(");
-	int maxExpands = 1000;	// Avoid infinite expansion of recursive definitions
+	int maxExpands = maxIterations;	// Avoid infinite expansion of recursive definitions
 	while ((varStart != std::string::npos) && (maxExpands > 0)) {
 		const size_t varEnd = withVars.find(')', varStart+2);
 		if (varEnd == std::string::npos) {
@@ -596,9 +610,8 @@
 		key = it->first.c_str();
 		val = it->second.c_str();
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
 /**
Index: scite/src/PropSetFile.h
===================================================================
--- scite/src/PropSetFile.h	(版本 44)
+++ scite/src/PropSetFile.h	(版本 45)
@@ -11,7 +11,7 @@
 /**
  */
 
-typedef std::map<std::string, std::string, std::less<>> mapss;
+using mapss = std::map<std::string, std::string, std::less<>>;
 
 class ImportFilter {
 public:
Index: scite/src/SciTE.h
===================================================================
--- scite/src/SciTE.h	(版本 44)
+++ scite/src/SciTE.h	(版本 45)
@@ -9,12 +9,12 @@
 #define SCITE_H
 
 // Version numbers and dates
-#define VERSION_SCITE "5.5.5"
-#define VERSION_WORDS 5, 5, 5, 0
-#define COPYRIGHT_DATES "December 1998-February 2025"
+#define VERSION_SCITE "5.5.6"
+#define VERSION_WORDS 5, 5, 6, 0
+#define COPYRIGHT_DATES "December 1998-April 2025"
 #define COPYRIGHT_YEARS "1998-2025"
-#define VERSION_SCINTILLA "5.5.5"
-#define VERSION_LEXILLA "5.4.3"
+#define VERSION_SCINTILLA "5.5.6"
+#define VERSION_LEXILLA "5.4.4"
 
 // Menu IDs.
 // These are located 100 apart. No one will want more than 100 in each menu ;)
Index: scite/src/SciTEBase.cxx
===================================================================
--- scite/src/SciTEBase.cxx	(版本 44)
+++ scite/src/SciTEBase.cxx	(版本 45)
@@ -16,6 +16,7 @@
 #include <cmath>
 
 #include <system_error>
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -464,7 +465,7 @@
 	// Allocate buffer, including space for NUL
 	std::string text(len, '\0');
 	// And get the line
-	wEditor.GetCurLine(len, &text[0]);
+	wEditor.GetCurLine(len, text.data());
 	return text;
 }
 
@@ -589,10 +590,14 @@
 	return isInside;
 }
 
-static constexpr bool IsBrace(char ch) noexcept {
+namespace {
+
+constexpr bool IsBrace(char ch) noexcept {
 	return ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == '{' || ch == '}';
 }
 
+}
+
 /**
  * Find if there is a brace next to the caret, checking before caret first, then
  * after caret. If brace found also find its matching brace.
@@ -1007,21 +1012,23 @@
 	return s;
 }
 
-static std::string UnSlashAsNeeded(const std::string &s, bool escapes, bool regularExpression) {
+namespace {
+
+std::string UnSlashAsNeeded(const std::string &s, bool escapes, bool regularExpression) {
 	if (escapes) {
 		if (regularExpression) {
 			// For regular expressions, the only escape sequences allowed start with \0
 			// Other sequences, like \t, are handled by the RE engine.
 			return UnSlashLowOctalString(s);
-		} else {
-			// C style escapes allowed
-			return UnSlashString(s);
 		}
-	} else {
-		return s;
+		// C style escapes allowed
+		return UnSlashString(s);
 	}
+	return s;
 }
 
+}
+
 void SciTEBase::RemoveFindMarks() {
 	findMarker.Stop();	// Cancel ongoing background find
 	if (CurrentBuffer()->findMarks != Buffer::FindMarks::none) {
@@ -1477,8 +1484,8 @@
 	dirNameForExecute = FilePath();
 	bool displayParameterDialog = false;
 	parameterisedCommand = "";
-	for (size_t ic = 0; ic < jobQueue.commandMax; ic++) {
-		if (StartsWith(jobQueue.jobQueue[ic].command, "*")) {
+	for (size_t ic = 0; ic < JobQueue::commandMax; ic++) {
+		if (jobQueue.jobQueue[ic].command.starts_with("*")) {
 			displayParameterDialog = true;
 			jobQueue.jobQueue[ic].command.erase(0, 1);
 			parameterisedCommand = jobQueue.jobQueue[ic].command;
@@ -1495,7 +1502,7 @@
 	} else {
 		ParamGrab();
 	}
-	for (size_t ic = 0; ic < jobQueue.commandMax; ic++) {
+	for (size_t ic = 0; ic < JobQueue::commandMax; ic++) {
 		if (jobQueue.jobQueue[ic].jobType != JobSubsystem::grep) {
 			jobQueue.jobQueue[ic].command = props.Expand(jobQueue.jobQueue[ic].command);
 		}
@@ -1640,9 +1647,9 @@
 	wOutput.InvalidateAll();
 }
 
-std::string SciTEBase::GetNearestWords(const char *wordStart, size_t searchLen,
+StringVector SciTEBase::GetNearestWords(const char *wordStart, size_t searchLen,
 				       const char *separators, bool ignoreCase /*=false*/, bool exactLen /*=false*/) {
-	std::string words;
+	StringVector words;
 	while (words.empty() && *separators) {
 		words = apis.GetNearestWords(wordStart, searchLen, ignoreCase, *separators, exactLen);
 		separators++;
@@ -1655,12 +1662,12 @@
 		lastPosCallTip = pos;
 	}
 	if (apis) {
-		std::string words = GetNearestWords(currentCallTipWord.c_str(), currentCallTipWord.length(),
+		StringVector words = GetNearestWords(currentCallTipWord.c_str(), currentCallTipWord.length(),
 						    calltipParametersStart.c_str(), callTipIgnoreCase, true);
 		if (words.empty())
 			return;
 		// Counts how many call tips
-		maxCallTips = std::count(words.begin(), words.end(), ' ') + 1;
+		maxCallTips = words.size();
 
 		// Should get current api definition
 		std::string word = apis.GetNearestWord(currentCallTipWord.c_str(), currentCallTipWord.length(),
@@ -1781,13 +1788,13 @@
 	if (callTipUseEscapes) {
 		std::string sPreHighlight = functionDefinition.substr(0, startHighlight);
 		std::vector<char> vPreHighlight(sPreHighlight.c_str(), sPreHighlight.c_str() + sPreHighlight.length() + 1);
-		const size_t unslashedStartHighlight = UnSlash(&vPreHighlight[0]);
+		const size_t unslashedStartHighlight = UnSlash(vPreHighlight.data());
 
 		size_t unslashedEndHighlight = unslashedStartHighlight;
 		if (startHighlight < endHighlight) {
 			std::string sHighlight = functionDefinition.substr(startHighlight, endHighlight - startHighlight);
 			std::vector<char> vHighlight(sHighlight.c_str(), sHighlight.c_str() + sHighlight.length() + 1);
-			unslashedEndHighlight = unslashedStartHighlight + UnSlash(&vHighlight[0]);
+			unslashedEndHighlight = unslashedStartHighlight + UnSlash(vHighlight.data());
 		}
 
 		startHighlight = unslashedStartHighlight;
@@ -1797,14 +1804,13 @@
 	wEditor.CallTipSetHlt(startHighlight, endHighlight);
 }
 
-std::string SciTEBase::EliminateDuplicateWords(const std::string &words) {
+namespace {
+
+std::string EliminateDuplicateWords(const StringVector &words) {
 	std::set<std::string> wordSet;
 	std::string wordsOut;
 
-	size_t current = 0;
-	while (current < words.length()) {
-		const size_t afterWord = words.find(' ', current);
-		const std::string word(words, current, afterWord - current);
+	for (const std::string &word : words) {
 		std::pair<std::set<std::string>::iterator, bool> result = wordSet.insert(word);
 		if (result.second) {
 			if (!wordsOut.empty())
@@ -1811,13 +1817,12 @@
 				wordsOut += ' ';
 			wordsOut += word;
 		}
-		current = afterWord;
-		if (current < words.length())
-			current++;
 	}
 	return wordsOut;
 }
 
+}
+
 bool SciTEBase::StartAutoComplete() {
 	const std::string line = GetCurrentLine();
 	const SA::Position current = GetCaretInLine();
@@ -1832,7 +1837,7 @@
 
 	const std::string root = line.substr(startword, current - startword);
 	if (apis) {
-		const std::string words = GetNearestWords(root.c_str(), root.length(),
+		const StringVector words = GetNearestWords(root.c_str(), root.length(),
 						    calltipParametersStart.c_str(), autoCompleteIgnoreCase);
 		if (!words.empty()) {
 			std::string wordsUnique = EliminateDuplicateWords(words);
@@ -1892,19 +1897,10 @@
 		posFind = wEditor.SearchInTarget(root);
 	}
 	if ((wordList.Count() != 0) && (!onlyOneWord || (wordList.MinWordLength() > static_cast<size_t>(rootLength)))) {
-		// Protect spaces by temporarily transforming to \001
-		std::string wordsNear = wordList.Get();
-		std::replace(wordsNear.begin(), wordsNear.end(), ' ', '\001');
-		StringList wl(true);
-		wl.Set(wordsNear.c_str());
-		std::string acText = wl.GetNearestWords("", 0, autoCompleteIgnoreCase);
-		// Use \n as word separator
-		std::replace(acText.begin(), acText.end(), ' ', '\n');
-		// Return spaces from \001
-		std::replace(acText.begin(), acText.end(), '\001', ' ');
+		const std::string wordsNear = wordList.Sorted(autoCompleteIgnoreCase);
 		wEditor.AutoCSetSeparator('\n');
 		wEditor.AutoCSetMaxHeight(autoCompleteVisibleItemCount);
-		wEditor.AutoCShow(rootLength, acText.c_str());
+		wEditor.AutoCShow(rootLength, wordsNear.c_str());
 	} else {
 		wEditor.AutoCCancel();
 	}
@@ -2153,9 +2149,9 @@
 		// empty lines are not commented
 		if (linebuf.length() < 1)
 			continue;
-		if (StartsWith(linebuf, comment.c_str())) {
+		if (linebuf.starts_with(comment)) {
 			SA::Position commentLength = comment.length();
-			if (StartsWith(linebuf, longComment.c_str())) {
+			if (linebuf.starts_with(longComment)) {
 				// Removing comment with space after it.
 				commentLength = longCommentLength;
 			}
@@ -2501,7 +2497,9 @@
 	return wEditor.LineIndentPosition(line);
 }
 
-static std::string CreateIndentation(int indent, int tabSize, bool insertSpaces) {
+namespace {
+
+std::string CreateIndentation(int indent, int tabSize, bool insertSpaces) {
 	std::string indentation;
 	if (!insertSpaces) {
 		while (indent >= tabSize) {
@@ -2516,6 +2514,8 @@
 	return indentation;
 }
 
+}
+
 void SciTEBase::ConvertIndentation(int tabSize, int useTabs) {
 	UndoBlock ub(wEditor);
 	const SA::Line maxLine = wEditor.LineCount();
@@ -2807,16 +2807,13 @@
 
 namespace {
 
-void AddProps(std::string &symbols, const PropSetFile &propSet) {
+void AddProps(AutoCompleteWordList &symbols, const PropSetFile &propSet) {
 	const char *key = nullptr;
 	const char *val = nullptr;
-	bool b = propSet.GetFirst(key, val);
-	while (b) {
+	for (bool b = propSet.GetFirst(key, val); b; b = propSet.GetNext(key, val)) {
 		if (IsUpperCase(*key)) {
-			symbols.append(key);
-			symbols.append(") ");
+			symbols.Add(std::string(key) + ")");
 		}
-		b = propSet.GetNext(key, val);
 	}
 }
 
@@ -2833,14 +2830,11 @@
 		// Potential autocompletion of symbols when $( typed
 		const SA::Position selStart = wOutput.SelectionStart();
 		if ((selStart > 1) && (wOutput.CharacterAt(selStart - 2) == '$')) {
-			std::string symbols;
+			AutoCompleteWordList symbols;
 			AddProps(symbols, props);
 			AddProps(symbols, propsDirectory);
-			StringList symList;
-			symList.Set(symbols.c_str());
-			std::string words = symList.GetNearestWords("", 0, true);
-			if (words.length()) {
-				wOutput.AutoCSetSeparator(' ');
+			if (const std::string words = symbols.Sorted(true); !words.empty()) {
+				wOutput.AutoCSetSeparator('\n');
 				wOutput.AutoCSetMaxHeight(autoCompleteVisibleItemCount);
 				wOutput.AutoCShow(0, words.c_str());
 			}
@@ -3935,13 +3929,13 @@
 		line--;
 		while (line >= 0) {
 			cmd = GetLine(wOutput, line);
-			if (StartsWith(cmd, ">") && !StartsWith(cmd, ">Exit")) {
+			if (cmd.starts_with(">") && !cmd.starts_with(">Exit")) {
 				cmd = cmd.substr(1);
 				break;
 			}
 			line--;
 		}
-	} else if (StartsWith(cmd, ">")) {
+	} else if (cmd.starts_with(">")) {
 		cmd = cmd.substr(1);
 	}
 	returnOutputToCommand = false;
@@ -4295,7 +4289,7 @@
 		AddToPopUp("Close", IDM_CLOSE, true);
 	}
 	std::string userContextMenu = props.GetNewExpandString("user.context.menu");
-	std::replace(userContextMenu.begin(), userContextMenu.end(), '|', '\0');
+	std::ranges::replace(userContextMenu, '|', '\0');
 	const char *userContextItem = userContextMenu.c_str();
 	const char *endDefinition = userContextItem + userContextMenu.length();
 	while (userContextItem < endDefinition) {
@@ -4523,7 +4517,9 @@
 	}
 }
 
-static constexpr bool IsSwitchCharacter(GUI::gui_char ch) noexcept {
+namespace {
+
+constexpr bool IsSwitchCharacter(GUI::gui_char ch) noexcept {
 #if defined(__unix__) || defined(__APPLE__)
 	return ch == '-';
 #else
@@ -4531,6 +4527,8 @@
 #endif
 }
 
+}
+
 // Called by SciTEBase::PerformOne when action="enumproperties:"
 void SciTEBase::EnumProperties(const char *propkind) {
 	const PropSetFile *pf = nullptr;
@@ -4674,7 +4672,9 @@
 If command needs answer (SCI_GETTEXTLENGTH ...) : give answer to director
 */
 
-static uintptr_t ReadNum(const char *&t) noexcept {
+namespace {
+
+uintptr_t ReadNum(const char *&t) noexcept {
 	assert(t);
 	const char *argend = strchr(t, ';');	// find ';'
 	uintptr_t v = 0;
@@ -4684,6 +4684,8 @@
 	return v;						// return value
 }
 
+}
+
 void SciTEBase::ExecuteMacroCommand(const char *command) {
 	const char *nextarg = command;
 	uintptr_t wParam = 0;
@@ -4798,7 +4800,7 @@
 				if (phase == 1) {
 					OpenFromStdin(arg[0] == '-');
 				}
-			} else if (StartsWith(arg, GUI_TEXT("@"))) {
+			} else if (arg.starts_with(GUI_TEXT("@"))) {
 				if (phase == 1) {
 					OpenFilesFromStdin();
 				}
@@ -4822,7 +4824,7 @@
 				exit(0);
 			} else {
 				if (AfterName(arg) == ':') {
-					if (StartsWith(arg, GUI_TEXT("open:")) || StartsWith(arg, GUI_TEXT("loadsession:"))) {
+					if (arg.starts_with(GUI_TEXT("open:")) || arg.starts_with(GUI_TEXT("loadsession:"))) {
 						if (phase == 0)
 							return performPrint;
 						else
@@ -4935,7 +4937,7 @@
 
 void SciTEBase::Perform(const char *actionList) {
 	std::vector<char> vActions(actionList, actionList + strlen(actionList) + 1);
-	char *actions = &vActions[0];
+	char *actions = vActions.data();
 	char *nextAct;
 	while ((nextAct = strchr(actions, '\n')) != nullptr) {
 		*nextAct = '\0';
Index: scite/src/SciTEBase.h
===================================================================
--- scite/src/SciTEBase.h	(版本 44)
+++ scite/src/SciTEBase.h	(版本 45)
@@ -274,11 +274,9 @@
 struct SCNotification;
 
 struct SystemAppearance {
-	bool dark;
-	bool highContrast;
-	bool operator==(const SystemAppearance &other) const noexcept {
-		return dark == other.dark && highContrast == other.highContrast;
-	}
+	bool dark = false;
+	bool highContrast = false;
+	constexpr bool operator==(const SystemAppearance &other) const noexcept = default;
 };
 
 // Titles appear different in menus and tabs
@@ -674,7 +672,7 @@
 	static void DropSelectionAt(GUI::ScintillaWindow &win, int selection);
 	virtual std::string GetRangeInUIEncoding(GUI::ScintillaWindow &win, SA::Span span);
 	static std::string GetLine(GUI::ScintillaWindow &win, SA::Line line);
-	void RangeExtend(GUI::ScintillaWindow &wCurrent, SA::Span &range,
+	void RangeExtend(GUI::ScintillaWindow &wCurrent, SA::Span &span,
 			 bool (SciTEBase::*ischarforsel)(char ch));
 	std::string RangeExtendAndGrab(GUI::ScintillaWindow &wCurrent, SA::Span &span,
 				       bool (SciTEBase::*ischarforsel)(char ch), bool stripEol = true);
@@ -694,7 +692,7 @@
 		yes,
 		no
 	};
-	typedef int MessageBoxStyle;
+	using MessageBoxStyle = int;
 	enum {
 		// Same as Win32 MB_*
 		mbsOK = 0,
@@ -751,11 +749,10 @@
 	void ShowMessages(SA::Line line);
 	void GoMessage(int dir);
 	virtual bool StartCallTip();
-	std::string GetNearestWords(const char *wordStart, size_t searchLen,
+	StringVector GetNearestWords(const char *wordStart, size_t searchLen,
 				    const char *separators, bool ignoreCase=false, bool exactLen=false);
 	virtual void FillFunctionDefinition(SA::Position pos = -1);
 	void ContinueCallTip();
-	std::string EliminateDuplicateWords(const std::string &words);
 	virtual bool StartAutoComplete();
 	virtual bool StartAutoCompleteWord(bool onlyOneWord);
 	virtual bool StartExpandAbbreviation();
Index: scite/src/SciTEBuffers.cxx
===================================================================
--- scite/src/SciTEBuffers.cxx	(版本 44)
+++ scite/src/SciTEBuffers.cxx	(版本 45)
@@ -13,6 +13,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -130,6 +131,8 @@
 	}
 }
 
+namespace {
+
 constexpr Buffer::FutureDo operator&(Buffer::FutureDo a, Buffer::FutureDo b) noexcept {
 	return static_cast<Buffer::FutureDo>(static_cast<int>(a) & static_cast<int>(b));
 }
@@ -142,6 +145,8 @@
 	return static_cast<Buffer::FutureDo>(~static_cast<int>(a));
 }
 
+}
+
 void Buffer::ScheduleFinishSave() noexcept {
 	isDirty = false;
 	failedSave = false;
@@ -596,7 +601,9 @@
 	return FilePath(GetSciteUserHome(), nameWithVisibility.c_str());
 }
 
-static std::string IndexPropKey(const char *bufPrefix, BufferIndex bufIndex, const char *bufAppendix) {
+namespace {
+
+std::string IndexPropKey(const char *bufPrefix, BufferIndex bufIndex, const char *bufAppendix) {
 	std::string pKey = bufPrefix;
 	pKey += '.';
 	pKey += StdStringFromInteger(bufIndex + 1);
@@ -607,6 +614,8 @@
 	return pKey;
 }
 
+}
+
 void SciTEBase::LoadSessionFile(const GUI::gui_char *sessionName) {
 	FilePath sessionPathName;
 	if (sessionName[0] == '\0') {
@@ -1197,7 +1206,7 @@
 	FilePath homePath = FilePath::UserHomeDirectory();
 	if (homePath.IsSet()) {
 		const GUI::gui_string_view homeDirectory = homePath.AsInternal();
-		if (StartsWith(path, homeDirectory)) {
+		if (path.starts_with(homeDirectory)) {
 			return GUI::gui_string(GUI_TEXT("~")) + path.substr(homeDirectory.size());
 		}
 	}
@@ -1579,7 +1588,7 @@
 
 namespace {
 
-static SA::Line DecodeMessage(const char *cdoc, std::string &sourcePath, int format, SA::Position &column) {
+SA::Line DecodeMessage(const char *cdoc, std::string &sourcePath, int format, SA::Position &column) {
 	sourcePath.clear();
 	column = -1; // default to not detected
 	switch (format) {
@@ -2114,7 +2123,7 @@
 					const bool isAdd = message.find("+++ ") == 0;
 					const SA::Line atLine = lookLine + (isAdd ? 1 : 2); // lines are in this order: ---, +++, @@
 					std::string atMessage = GetLine(wOutput, atLine);
-					if (StartsWith(atMessage, "@@ -")) {
+					if (atMessage.starts_with("@@ -")) {
 						size_t atPos = 4; // deleted position starts right after "@@ -"
 						if (isAdd) {
 							const size_t linePlace = atMessage.find(" +", 7);
@@ -2150,7 +2159,7 @@
 					//simply move cursor to line, don't do any selection
 					SetSelection(startSourceLine, startSourceLine);
 				}
-				std::replace(message.begin(), message.end(), '\t', ' ');
+				std::ranges::replace(message, '\t', ' ');
 				::Remove(message, std::string("\n"));
 				props.Set("CurrentMessage", message);
 				UpdateStatusBar(false);
Index: scite/src/SciTEIO.cxx
===================================================================
--- scite/src/SciTEIO.cxx	(版本 44)
+++ scite/src/SciTEIO.cxx	(版本 45)
@@ -15,6 +15,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -159,23 +160,23 @@
 	std::string buf = wEditor.StringOfRange(SA::Span(0, length));
 	std::string languageOverride;
 	std::string_view line = ExtractLine(buf);
-	if (StartsWith(line, "<?xml")) {
+	if (line.starts_with("<?xml")) {
 		languageOverride = "xml";
-	} else if (StartsWith(line, "#!")) {
+	} else if (line.starts_with("#!")) {
 		line.remove_prefix(2);
 		std::string l1(line);
-		std::replace(l1.begin(), l1.end(), '\\', ' ');
-		std::replace(l1.begin(), l1.end(), '/', ' ');
-		std::replace(l1.begin(), l1.end(), '\t', ' ');
+		std::ranges::replace(l1, '\\', ' ');
+		std::ranges::replace(l1, '/', ' ');
+		std::ranges::replace(l1, '\t', ' ');
 		Substitute(l1, "  ", " ");
 		Substitute(l1, "  ", " ");
 		Substitute(l1, "  ", " ");
 		::Remove(l1, std::string("\r"));
 		::Remove(l1, std::string("\n"));
-		if (StartsWith(l1, " ")) {
+		if (l1.starts_with(" ")) {
 			l1 = l1.substr(1);
 		}
-		std::replace(l1.begin(), l1.end(), ' ', '\0');
+		std::ranges::replace(l1, ' ', '\0');
 		l1.append(1, '\0');
 		const char *word = l1.c_str();
 		while (*word) {
@@ -679,12 +680,12 @@
 	}
 
 #if !defined(GTK)
-	if (StartsWith(selName, "http:") ||
-			StartsWith(selName, "https:") ||
-			StartsWith(selName, "ftp:") ||
-			StartsWith(selName, "ftps:") ||
-			StartsWith(selName, "news:") ||
-			StartsWith(selName, "mailto:")) {
+	if (selName.starts_with("http:") ||
+			selName.starts_with("https:") ||
+			selName.starts_with("ftp:") ||
+			selName.starts_with("ftps:") ||
+			selName.starts_with("news:") ||
+			selName.starts_with("mailto:")) {
 		std::string cmd = selName;
 		AddCommand(cmd, "", JobSubsystem::shell);
 		return false;	// Job is done
@@ -691,7 +692,7 @@
 	}
 #endif
 
-	if (StartsWith(selName, "file://")) {
+	if (selName.starts_with("file://")) {
 		selName.erase(0, 7);
 		if (selName[0] == '/' && selName[2] == ':') { // file:///C:/filename.ext
 			selName.erase(0, 1);
@@ -698,7 +699,7 @@
 		}
 	}
 
-	if (StartsWith(selName, "~/")) {
+	if (selName.starts_with("~/")) {
 		selName.erase(0, 2);
 		const FilePath selPath(GUI::StringFromUTF8(selName));
 		const FilePath expandedPath(FilePath::UserHomeDirectory(), selPath);
@@ -830,7 +831,7 @@
 			const std::string contents = filePath.Read();
 			// Check for BOM that matches file mode
 			const std::string_view svUtf8BOM(UTF8BOM);
-			if ((uniMode == UniMode::utf8) && !StartsWith(contents, svUtf8BOM)) {
+			if ((uniMode == UniMode::utf8) && !contents.starts_with(svUtf8BOM)) {
 				// Should have BOM but doesn't so use full load
 				OpenCurrentFile(fileLength, false, false);
 			} else {
@@ -1323,7 +1324,7 @@
 			propsSuggestion.Set("TimeStamp", timeBuff);
 			propsSuggestion.SetPath("SciteUserHome", GetSciteUserHome());
 			std::string savePathSuggestion = propsSuggestion.GetExpandedString("save.path.suggestion");
-			std::replace(savePathSuggestion.begin(), savePathSuggestion.end(), '\\', '/');  // To accept "\" on Unix
+			std::ranges::replace(savePathSuggestion, '\\', '/');  // To accept "\" on Unix
 			if (savePathSuggestion.size() > 0) {
 				filePath = FilePath(GUI::StringFromUTF8(savePathSuggestion)).NormalizePath();
 			}
Index: scite/src/SciTEProps.cxx
===================================================================
--- scite/src/SciTEProps.cxx	(版本 44)
+++ scite/src/SciTEProps.cxx	(版本 45)
@@ -14,6 +14,7 @@
 #include <clocale>
 
 #include <stdexcept>
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -325,7 +326,7 @@
 		win.StyleSetFont(style, sd.font.c_str());
 		bool inMonospacedList = !monospacedList.empty() && (monospacedList.back() == "*");
 		if (!inMonospacedList) {
-			inMonospacedList = std::find(monospacedList.begin(), monospacedList.end(), sd.font) != monospacedList.end();
+			inMonospacedList = std::ranges::find(monospacedList, sd.font) != monospacedList.end();
 		}
 		win.StyleSetCheckMonospaced(style, inMonospacedList);
 	}
@@ -465,10 +466,12 @@
 	return ret;
 }
 
+namespace {
+
 /**
  * A list of all the properties that should be forwarded to Scintilla lexers.
  */
-static const char *propertiesToForward[] = {
+const char *propertiesToForward[] = {
 	"fold.scintillua.by.indentation",
 	"fold.scintillua.line.groups",
 	"fold.scintillua.on.zero.sum.lines",
@@ -642,7 +645,7 @@
 };
 
 /* XPM */
-static const char *bookmarkBluegem[] = {
+const char *bookmarkBluegem[] = {
 /* width height num_colors chars_per_pixel */
 "    15    15      64            1",
 /* colors */
@@ -728,6 +731,8 @@
 "    1GdddG1    "
 };
 
+}
+
 std::string SciTEBase::GetFileNameProperty(const char *name) {
 	std::string namePlusDot = name;
 	namePlusDot.append(".");
@@ -821,7 +826,7 @@
 	}
 	const std::string languageCurrent = wEditor.LexerLanguage();
 	if (language != languageCurrent) {
-		if (StartsWith(language, "script_")) {
+		if (language.starts_with("script_")) {
 			wEditor.SetILexer(nullptr);
 		} else {
 			Scintilla::ILexer5 *plexer = Lexilla::MakeLexer(language);
@@ -1714,10 +1719,8 @@
 	const std::string monospaceFonts = props.GetExpandedString("font.monospaced.list");
 	monospacedList = StringSplit(monospaceFonts, ';');
 
-	const char *languageName = language.c_str();
-
-	if (StartsWith(languageName, "scintillua.") && language.length() < 240) {
-		SetScintilluaStyles(wEditor, props, languageName);
+	if (language.starts_with("scintillua.") && language.length() < 240) {
+		SetScintilluaStyles(wEditor, props, language.c_str());
 	}
 
 	// Set styles
@@ -1740,13 +1743,13 @@
 	SetOneStyle(wEditor, StyleDefault, sval);
 	SetOneStyle(wOutput, StyleDefault, sval);
 
-	sval = props.GetExpandedString(StyleName(languageName, StyleDefault));
+	sval = props.GetExpandedString(StyleName(language, StyleDefault));
 	SetOneStyle(wEditor, StyleDefault, sval);
 
 	wEditor.StyleClearAll();
 
 	SetStyleFor(wEditor, "*");
-	SetStyleFor(wEditor, languageName);
+	SetStyleFor(wEditor, language.c_str());
 	if (props.GetInt("error.inline")) {
 		wEditor.ReleaseAllExtendedStyles();
 		diagnosticStyleStart = wEditor.AllocateExtendedStyles(diagnosticStyles);
@@ -1911,7 +1914,7 @@
 	wOutput.SetWrapMode(wrapOutput ? wrapStyle : SA::Wrap::None);
 
 	std::string menuLanguageProp = props.GetExpandedString("menu.language");
-	std::replace(menuLanguageProp.begin(), menuLanguageProp.end(), '|', '\0');
+	std::ranges::replace(menuLanguageProp, '|', '\0');
 	const char *sMenuLanguage = menuLanguageProp.c_str();
 	while (*sMenuLanguage) {
 		LanguageMenuItem lmi;
@@ -1927,9 +1930,9 @@
 
 	// load the user defined short cut props
 	std::string shortCutProp = props.GetNewExpandString("user.shortcuts");
-	if (shortCutProp.length()) {
-		const size_t pipes = std::count(shortCutProp.begin(), shortCutProp.end(), '|');
-		std::replace(shortCutProp.begin(), shortCutProp.end(), '|', '\0');
+	if (!shortCutProp.empty()) {
+		const size_t pipes = std::ranges::count(shortCutProp, '|');
+		std::ranges::replace(shortCutProp, '|', '\0');
 		const char *sShortCutProp = shortCutProp.c_str();
 		for (size_t item = 0; item < pipes/2; item++) {
 			ShortcutItem sci;
Index: scite/src/StringHelpers.cxx
===================================================================
--- scite/src/StringHelpers.cxx	(版本 44)
+++ scite/src/StringHelpers.cxx	(版本 45)
@@ -22,21 +22,6 @@
 #include "GUI.h"
 #include "StringHelpers.h"
 
-bool StartsWith(std::wstring_view s, std::wstring_view start) {
-	return (s.size() >= start.size()) &&
-	       (std::equal(s.begin(), s.begin() + start.size(), start.begin()));
-}
-
-bool StartsWith(std::string_view s, std::string_view start) {
-	return (s.size() >= start.size()) &&
-	       (std::equal(s.begin(), s.begin() + start.size(), start.begin()));
-}
-
-bool EndsWith(std::wstring_view s, std::wstring_view end) {
-	return (s.size() >= end.size()) &&
-	       (std::equal(s.begin() + s.size() - end.size(), s.end(), end.begin()));
-}
-
 bool Contains(std::string const &s, char ch) noexcept {
 	return s.find(ch) != std::string::npos;
 }
@@ -95,9 +80,10 @@
 }
 
 std::string StdStringFromDouble(double d, int precision) {
-	char number[32];
+	constexpr size_t maxDigits = 32;
+	char number[maxDigits]{};
 	snprintf(number, std::size(number), "%.*f", precision, d);
-	return std::string(number);
+	return { number };
 }
 
 int IntegerFromString(const std::string &val, int defaultValue) {
@@ -322,10 +308,12 @@
 	return oRet;
 }
 
+namespace {
+
 /**
  * Is the character an octal digit?
  */
-static constexpr bool IsOctalDigit(char ch) noexcept {
+constexpr bool IsOctalDigit(char ch) noexcept {
 	return ch >= '0' && ch <= '7';
 }
 
@@ -332,7 +320,7 @@
 /**
  * If the character is an hexa digit, get its value.
  */
-static int GetHexaDigit(char ch) noexcept {
+int GetHexaDigit(char ch) noexcept {
 	if (ch >= '0' && ch <= '9') {
 		return ch - '0';
 	}
@@ -346,6 +334,31 @@
 }
 
 /**
+ * Convert C style \0oo into their indicated characters.
+ * This is used to get control characters into the regular expression engine.
+ * Result length is always less than or equal to input length.
+ */
+size_t UnSlashLowOctal(char *s) noexcept {
+	const char *sStart = s;
+	char *o = s;
+	while (*s) {
+		if ((s[0] == '\\') && (s[1] == '0') && IsOctalDigit(s[2]) && IsOctalDigit(s[3])) {
+			*o = static_cast<char>(8 * (s[2] - '0') + (s[3] - '0'));
+			s += 3;
+		} else {
+			*o = *s;
+		}
+		o++;
+		if (*s)
+			s++;
+	}
+	*o = '\0';
+	return o - sStart;
+}
+
+}
+
+/**
  * Convert C style \a, \b, \f, \n, \r, \t, \v, \ooo and \xhh into their indicated characters.
  * Result length is always less than or equal to input length.
  */
@@ -393,7 +406,7 @@
 					ghd = GetHexaDigit(*s);
 					if (ghd >= 0) {
 						s++;
-						val *= 16;
+						val *= GUI::hexBase;
 						val += ghd;
 					}
 				}
@@ -415,36 +428,13 @@
 
 std::string UnSlashString(std::string_view sv) {
 	std::string sCopy(sv);
-	const size_t len = UnSlash(&sCopy[0]);
+	const size_t len = UnSlash(sCopy.data());
 	return sCopy.substr(0, len);
 }
 
-/**
- * Convert C style \0oo into their indicated characters.
- * This is used to get control characters into the regular expression engine.
- * Result length is always less than or equal to input length.
- */
-static size_t UnSlashLowOctal(char *s) noexcept {
-	const char *sStart = s;
-	char *o = s;
-	while (*s) {
-		if ((s[0] == '\\') && (s[1] == '0') && IsOctalDigit(s[2]) && IsOctalDigit(s[3])) {
-			*o = static_cast<char>(8 * (s[2] - '0') + (s[3] - '0'));
-			s += 3;
-		} else {
-			*o = *s;
-		}
-		o++;
-		if (*s)
-			s++;
-	}
-	*o = '\0';
-	return o - sStart;
-}
-
 std::string UnSlashLowOctalString(std::string_view sv) {
 	std::string sCopy(sv);
-	const size_t len = UnSlashLowOctal(&sCopy[0]);
+	const size_t len = UnSlashLowOctal(sCopy.data());
 	return sCopy.substr(0, len);
 }
 
@@ -472,7 +462,7 @@
 unsigned int IntFromHexBytes(std::string_view hexBytes) noexcept {
 	unsigned int val = 0;
 	while (!hexBytes.empty()) {
-		val = val * 16 + IntFromHexDigit(hexBytes[0]);
+		val = val * GUI::hexBase + IntFromHexDigit(hexBytes[0]);
 		hexBytes.remove_prefix(1);
 	}
 	return val;
@@ -513,7 +503,7 @@
 }
 
 void ComboMemory::Insert(std::string_view item) {
-	std::vector<std::string>::iterator match = std::find(entries.begin(), entries.end(), item);
+	std::vector<std::string>::iterator match = std::ranges::find(entries, item);
 	if (match != entries.end()) {
 		entries.erase(match);
 	}
@@ -529,7 +519,7 @@
 void ComboMemory::InsertDeletePrefix(std::string_view item) {
 	if (!entries.empty()) {
 		const std::string_view svFront = entries.front();
-		if (StartsWith(item, svFront) || StartsWith(svFront, item)) {
+		if (item.starts_with(svFront) || svFront.starts_with(item)) {
 			entries.erase(entries.begin());
 		}
 	}
@@ -547,7 +537,7 @@
 
 void ComboMemory::Append(std::string_view item) {
 	if (!Present(item) && entries.size() < sz) {
-		entries.push_back(std::string(item));
+		entries.emplace_back(item);
 	}
 }
 
Index: scite/src/StringHelpers.h
===================================================================
--- scite/src/StringHelpers.h	(版本 44)
+++ scite/src/StringHelpers.h	(版本 45)
@@ -8,9 +8,6 @@
 #ifndef STRINGHELPERS_H
 #define STRINGHELPERS_H
 
-bool StartsWith(std::wstring_view s, std::wstring_view start);
-bool StartsWith(std::string_view s, std::string_view start);
-bool EndsWith(std::wstring_view s, std::wstring_view end);
 bool Contains(std::string const &s, char ch) noexcept;
 
 // Substitute is duplicated instead of templated as it was ambiguous when implemented as a template.
@@ -64,6 +61,10 @@
 	return (ch == ' ') || (ch == '\t');
 }
 
+constexpr bool IsEOLCharacter(int ch) noexcept {
+	return ch == '\r' || ch == '\n';
+}
+
 constexpr bool IsADigit(int ch) noexcept {
 	return (ch >= '0') && (ch <= '9');
 }
@@ -112,7 +113,7 @@
 
 std::set<std::string> SetFromString(std::string_view text, char separator);
 
-typedef std::tuple<std::string_view, std::string_view> ViewPair;
+using ViewPair = std::tuple<std::string_view, std::string_view>;
 
 // Split view around first separator returning the portion before and after the separator.
 // If the separator is not present then return whole view and an empty view.
Index: scite/src/StringList.cxx
===================================================================
--- scite/src/StringList.cxx	(版本 44)
+++ scite/src/StringList.cxx	(版本 45)
@@ -23,7 +23,9 @@
 #include "StringList.h"
 #include "StringHelpers.h"
 
-static int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept {
+namespace {
+
+int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept {
 	while (*a && *b && len) {
 		if (*a != *b) {
 			const char upperA = MakeUpperCase(*a);
@@ -46,7 +48,7 @@
  * Creates an array that points into each word in the string and puts \0 terminators
  * after each word.
  */
-static std::vector<char *> ArrayFromStringList(char *stringList, bool onlyLineEnds = false) {
+std::vector<char *> ArrayFromStringList(char *stringList, bool onlyLineEnds = false) {
 	int prev = '\n';
 	int words = 0;
 	// For rapid determination of whether a character is a separator, build
@@ -82,57 +84,14 @@
 	return keywords;
 }
 
-void StringList::SetFromListText() {
-	sorted = false;
-	sortedNoCase = false;
-	words = ArrayFromStringList(&listText[0], onlyLineEnds);
-	wordsNoCase = words;
-}
-
-static bool CmpString(const char *a, const char *b) noexcept {
+bool CmpString(const char *a, const char *b) noexcept {
 	return strcmp(a, b) < 0;
 }
 
-static bool CmpStringNoCase(const char *a, const char *b) noexcept {
+bool CmpStringNoCase(const char *a, const char *b) noexcept {
 	return CompareNoCase(a, b) < 0;
 }
 
-void StringList::SortIfNeeded(bool ignoreCase) {
-	// In both cases, the final empty sentinel element is not sorted.
-	if (ignoreCase) {
-		if (!sortedNoCase) {
-			sortedNoCase = true;
-			std::sort(wordsNoCase.begin(), wordsNoCase.end(), CmpStringNoCase);
-		}
-	} else {
-		if (!sorted) {
-			sorted = true;
-			std::sort(words.begin(), words.end(), CmpString);
-		}
-	}
-}
-
-void StringList::Clear() noexcept {
-	words.clear();
-	wordsNoCase.clear();
-	listText.clear();
-	sorted = false;
-	sortedNoCase = false;
-}
-
-void StringList::Set(const char *s) {
-	listText.assign(s, s+strlen(s)+1);
-	SetFromListText();
-}
-
-void StringList::Set(const std::vector<char> &data) {
-	listText.assign(data.begin(), data.end());
-	listText.push_back('\0');
-	SetFromListText();
-}
-
-namespace {
-
 // Functors used to find elements given a prefix
 
 struct CompareString {
@@ -153,7 +112,7 @@
 
 template<typename Compare>
 std::string GetMatch(std::vector<char *>::iterator start, std::vector<char *>::iterator end,
-		     const char *wordStart, const std::string &wordCharacters, ptrdiff_t wordIndex, Compare comp) {
+	const char *wordStart, const std::string &wordCharacters, ptrdiff_t wordIndex, Compare comp) {
 	std::vector<char *>::iterator elem = std::lower_bound(start, end, wordStart, comp);
 	if (!comp(wordStart, *elem) && !comp(*elem, wordStart)) {
 		// Found a matching element, now move forward wordIndex matching elements
@@ -170,32 +129,13 @@
 	return std::string();
 }
 
-}
-
 /**
- * Returns an element (complete) of the StringList array which has
- * the same beginning as the passed string.
- * The length of the word to compare is passed too.
- * Letter case can be ignored or preserved.
- */
-std::string StringList::GetNearestWord(const char *wordStart, size_t searchLen, bool ignoreCase, const std::string &wordCharacters, ptrdiff_t wordIndex) {
-	if (words.empty())
-		return std::string();
-	SortIfNeeded(ignoreCase);
-	if (ignoreCase) {
-		return GetMatch(wordsNoCase.begin(), wordsNoCase.end(), wordStart, wordCharacters, wordIndex, CompareStringInsensitive(searchLen));
-	} else { // preserve the letter case
-		return GetMatch(words.begin(), words.end(), wordStart, wordCharacters, wordIndex, CompareString(searchLen));
-	}
-}
-
-/**
  * Find the length of a 'word' which is actually an identifier in a string
  * which looks like "identifier(..." or "identifier" and where
  * there may be extra spaces after the identifier that should not be
  * counted in the length.
  */
-static size_t LengthWord(const char *word, char otherSeparator) noexcept {
+size_t LengthWord(const char *word, char otherSeparator) noexcept {
 	const char *endWord = nullptr;
 	// Find an otherSeparator
 	if (otherSeparator)
@@ -220,8 +160,8 @@
 }
 
 template<typename Compare>
-static std::string GetMatches(std::vector<char *>::iterator start, std::vector<char *>::iterator end, const char *wordStart, char otherSeparator, bool exactLen, Compare comp) {
-	std::string wordList;
+StringVector GetMatches(std::vector<char *>::iterator start, std::vector<char *>::iterator end, const char *wordStart, char otherSeparator, bool exactLen, Compare comp) {
+	StringVector wordList;
 	const size_t wordStartLength = LengthWord(wordStart, otherSeparator);
 	std::vector<char *>::iterator elem = std::lower_bound(start, end, wordStart, comp);
 	// Found a matching element, now accumulate all matches
@@ -231,15 +171,73 @@
 		// length of the word part (before the '(' brace) of the api array element
 		const size_t wordlen = LengthWord(*elem, otherSeparator);
 		if (!exactLen || (wordlen == wordStartLength)) {
-			if (wordList.length() > 0)
-				wordList.append(" ", 1);
-			wordList.append(*elem, wordlen);
+			wordList.emplace_back(*elem, wordlen);
 		}
 	}
 	return wordList;
 }
 
+}
+
+void StringList::SetFromListText() {
+	sorted = false;
+	sortedNoCase = false;
+	words = ArrayFromStringList(listText.data(), onlyLineEnds);
+	wordsNoCase = words;
+}
+
+void StringList::SortIfNeeded(bool ignoreCase) {
+	// In both cases, the final empty sentinel element is not sorted.
+	if (ignoreCase) {
+		if (!sortedNoCase) {
+			sortedNoCase = true;
+			std::sort(wordsNoCase.begin(), wordsNoCase.end(), CmpStringNoCase);
+		}
+	} else {
+		if (!sorted) {
+			sorted = true;
+			std::sort(words.begin(), words.end(), CmpString);
+		}
+	}
+}
+
+void StringList::Clear() noexcept {
+	words.clear();
+	wordsNoCase.clear();
+	listText.clear();
+	sorted = false;
+	sortedNoCase = false;
+}
+
+void StringList::Set(const char *s) {
+	listText.assign(s, s+strlen(s)+1);
+	SetFromListText();
+}
+
+void StringList::Set(const std::vector<char> &data) {
+	listText.assign(data.begin(), data.end());
+	listText.push_back('\0');
+	SetFromListText();
+}
+
 /**
+ * Returns an element (complete) of the StringList array which has
+ * the same beginning as the passed string.
+ * The length of the word to compare is passed too.
+ * Letter case can be ignored or preserved.
+ */
+std::string StringList::GetNearestWord(const char *wordStart, size_t searchLen, bool ignoreCase, const std::string &wordCharacters, ptrdiff_t wordIndex) {
+	if (words.empty())
+		return std::string();
+	SortIfNeeded(ignoreCase);
+	if (ignoreCase) {
+		return GetMatch(wordsNoCase.begin(), wordsNoCase.end(), wordStart, wordCharacters, wordIndex, CompareStringInsensitive(searchLen));
+	} else { // preserve the letter case
+		return GetMatch(words.begin(), words.end(), wordStart, wordCharacters, wordIndex, CompareString(searchLen));
+	}
+}
+
+/**
  * Returns elements (first words of them) of the StringList array which have
  * the same beginning as the passed string.
  * The length of the word to compare is passed too.
@@ -247,7 +245,7 @@
  * If there are more words meeting the condition they are returned all of
  * them in the ascending order separated with spaces.
  */
-std::string StringList::GetNearestWords(
+StringVector StringList::GetNearestWords(
 	const char *wordStart,
 	size_t searchLen,
 	bool ignoreCase,
@@ -255,7 +253,7 @@
 	bool exactLen /*=false*/) {
 
 	if (words.empty())
-		return std::string();
+		return {};
 	SortIfNeeded(ignoreCase);
 	if (ignoreCase) {
 		return GetMatches(wordsNoCase.begin(), wordsNoCase.end(), wordStart, otherSeparator, exactLen, CompareStringInsensitive(searchLen));
@@ -276,14 +274,20 @@
 	return ok;
 }
 
-std::string AutoCompleteWordList::Get() const {
+std::string AutoCompleteWordList::Sorted(bool ignoreCase) const {
+	std::vector<std::string> wv(words.begin(), words.end());
+	if (ignoreCase) {
+		std::ranges::sort(wv,
+			[](const std::string &a, const std::string &b) noexcept -> bool {
+				return CmpStringNoCase(a.c_str(), b.c_str());
+			});
+	}
 	std::string result;
 	if (totalLength) {
-		result.reserve(totalLength + 2);
-		result.push_back('\n');
-		for (const std::string &word : words) {
+		for (const std::string &word : wv) {
+			if (!result.empty())
+				result.push_back('\n');
 			result.append(word);
-			result.push_back('\n');
 		}
 	}
 	return result;
Index: scite/src/StringList.h
===================================================================
--- scite/src/StringList.h	(版本 44)
+++ scite/src/StringList.h	(版本 45)
@@ -8,6 +8,8 @@
 #ifndef STRINGLIST_H
 #define STRINGLIST_H
 
+using StringVector = std::vector<std::string>;
+
 class StringList {
 	// Text pointed into by words and wordsNoCase
 	std::string listText;
@@ -31,7 +33,7 @@
 	void Set(const std::vector<char> &data);
 	std::string GetNearestWord(const char *wordStart, size_t searchLen,
 				   bool ignoreCase, const std::string &wordCharacters, ptrdiff_t wordIndex);
-	std::string GetNearestWords(const char *wordStart, size_t searchLen,
+	StringVector GetNearestWords(const char *wordStart, size_t searchLen,
 				    bool ignoreCase, char otherSeparator='\0', bool exactLen=false);
 };
 
@@ -47,7 +49,7 @@
 		return minWordLength;
 	}
 	bool Add(const std::string& word);
-	std::string Get() const;
+	std::string Sorted(bool ignoreCase) const;
 };
 
 #endif
Index: scite/src/StyleDefinition.cxx
===================================================================
--- scite/src/StyleDefinition.cxx	(版本 44)
+++ scite/src/StyleDefinition.cxx	(版本 45)
@@ -84,7 +84,7 @@
 		if ((optionName == "font") && !optionValue.empty()) {
 			specified = static_cast<flags>(specified | sdFont);
 			font = optionValue;
-			std::replace(font.begin(), font.end(), '|', ',');
+			std::ranges::replace(font, '|', ',');
 		}
 		if ((optionName == "fore") && !optionValue.empty()) {
 			specified = static_cast<flags>(specified | sdFore);
@@ -155,11 +155,11 @@
 	return true;
 }
 
-SA::Colour StyleDefinition::Fore() const {
+SA::Colour StyleDefinition::Fore() const noexcept {
 	return ColourFromString(fore);
 }
 
-SA::Colour StyleDefinition::Back() const {
+SA::Colour StyleDefinition::Back() const noexcept {
 	return ColourFromString(back);
 }
 
@@ -172,21 +172,23 @@
 }
 
 int IntFromHexByte(std::string_view hexByte) noexcept {
-	return IntFromHexDigit(hexByte[0]) * 16 + IntFromHexDigit(hexByte[1]);
+	if (hexByte.length() >= 2) {
+		return (IntFromHexDigit(hexByte[0]) * GUI::hexBase) + IntFromHexDigit(hexByte[1]);
+	}
+	return 0;
 }
 
-SA::Colour ColourFromString(std::string_view s) {
+SA::Colour ColourFromString(std::string_view s) noexcept {
 	if (s.length() >= 7) {
 		const int r = IntFromHexByte(&s[1]);
 		const int g = IntFromHexByte(&s[3]);
 		const int b = IntFromHexByte(&s[5]);
 		return ColourRGB(r, g, b);
-	} else {
-		return 0;
 	}
+	return 0;
 }
 
-SA::ColourAlpha ColourAlphaFromString(std::string_view s) {
+SA::ColourAlpha ColourAlphaFromString(std::string_view s) noexcept {
 	if (s.length() >= 7) {
 		const int r = IntFromHexByte(&s[1]);
 		const int g = IntFromHexByte(&s[3]);
@@ -193,9 +195,8 @@
 		const int b = IntFromHexByte(&s[5]);
 		const int a = (s.length() >= 9)? IntFromHexByte(&s[7]) : 0xff;
 		return ColourRGBA(r, g, b, a);
-	} else {
-		return 0;
 	}
+	return 0;
 }
 
 IndicatorDefinition::IndicatorDefinition(std::string_view definition) :
Index: scite/src/StyleDefinition.h
===================================================================
--- scite/src/StyleDefinition.h	(版本 44)
+++ scite/src/StyleDefinition.h	(版本 45)
@@ -31,8 +31,8 @@
 		   } specified;
 	explicit StyleDefinition(std::string_view definition);
 	bool ParseStyleDefinition(std::string_view definition);
-	Scintilla::Colour Fore() const;
-	Scintilla::Colour Back() const;
+	Scintilla::Colour Fore() const noexcept;
+	Scintilla::Colour Back() const noexcept;
 	int FractionalSize() const noexcept;
 	bool IsBold() const noexcept;
 };
@@ -47,8 +47,8 @@
 
 int IntFromHexByte(std::string_view hexByte) noexcept;
 
-Scintilla::Colour ColourFromString(std::string_view s);
-Scintilla::ColourAlpha ColourAlphaFromString(std::string_view s);
+Scintilla::Colour ColourFromString(std::string_view s) noexcept;
+Scintilla::ColourAlpha ColourAlphaFromString(std::string_view s) noexcept;
 
 struct IndicatorDefinition {
 	Scintilla::IndicatorStyle style;
Index: scite/src/lexillaVersion.txt
===================================================================
--- scite/src/lexillaVersion.txt	(版本 44)
+++ scite/src/lexillaVersion.txt	(版本 45)
@@ -1 +1 @@
-543
\ No newline at end of file
+544
\ No newline at end of file
Index: scite/src/scintillaVersion.txt
===================================================================
--- scite/src/scintillaVersion.txt	(版本 44)
+++ scite/src/scintillaVersion.txt	(版本 45)
@@ -1 +1 @@
-555
\ No newline at end of file
+556
\ No newline at end of file
Index: scite/version.txt
===================================================================
--- scite/version.txt	(版本 44)
+++ scite/version.txt	(版本 45)
@@ -1 +1 @@
-555
\ No newline at end of file
+556
\ No newline at end of file
Index: scite/win32/DirectorExtension.cxx
===================================================================
--- scite/win32/DirectorExtension.cxx	(版本 44)
+++ scite/win32/DirectorExtension.cxx	(版本 45)
@@ -10,6 +10,7 @@
 #include <cstdio>
 #include <ctime>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
@@ -49,18 +50,20 @@
 #include "SciTEBase.h"
 #include "DirectorExtension.h"
 
-static HWND wDirector {};
-static HWND wCorrespondent {};
-static HWND wReceiver {};
-static bool startedByDirector = false;
-static bool shuttingDown = false;
+namespace {
+
+HWND wDirector{};
+HWND wCorrespondent{};
+HWND wReceiver{};
+bool startedByDirector = false;
+bool shuttingDown = false;
 unsigned int SDI = 0;
 
-static bool HasConnection() noexcept {
+bool HasConnection() noexcept {
 	return wDirector || wCorrespondent;
 }
 
-static void SendDirector(const char *verb, const char *arg = nullptr) {
+void SendDirector(const char *verb, const char *arg = nullptr) {
 	if (HasConnection()) {
 		HWND wDestination = wCorrespondent;
 		std::string addressedMessage;
@@ -81,7 +84,7 @@
 		cds.dwData = 0;
 		cds.cbData = static_cast<DWORD>(slashedMessage.length());
 		slashedMessage.append(1, '\0');	// Ensure NUL at end of string
-		cds.lpData = &slashedMessage[0];
+		cds.lpData = slashedMessage.data();
 		::SendMessage(wDestination, WM_COPYDATA,
 			      reinterpret_cast<WPARAM>(wReceiver),
 			      reinterpret_cast<LPARAM>(&cds));
@@ -88,16 +91,16 @@
 	}
 }
 
-static void SendDirectorInteger(const char *verb, intptr_t arg) {
+void SendDirectorInteger(const char *verb, intptr_t arg) {
 	std::string s = std::to_string(arg);
 	::SendDirector(verb, s.c_str());
 }
 
-static HWND HwndFromString(const char *s) noexcept {
+HWND HwndFromString(const char *s) noexcept {
 	return reinterpret_cast<HWND>(static_cast<uintptr_t>(atoll(s)));
 }
 
-static void CheckEnvironment(ExtensionAPI *phost) {
+void CheckEnvironment(ExtensionAPI *phost) {
 	if (phost && !shuttingDown) {
 		if (!wDirector) {
 			std::string director = phost->Property("director.hwnd");
@@ -113,9 +116,9 @@
 	}
 }
 
-static TCHAR DirectorExtension_ClassName[] = TEXT("DirectorExtension");
+TCHAR DirectorExtension_ClassName[] = TEXT("DirectorExtension");
 
-static LRESULT HandleCopyData(LPARAM lParam) {
+LRESULT HandleCopyData(LPARAM lParam) {
 	const COPYDATASTRUCT *pcds = reinterpret_cast<COPYDATASTRUCT *>(lParam);
 	// Copy into an temporary buffer to ensure \0 terminated
 	if (pcds->lpData) {
@@ -135,7 +138,7 @@
 	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 }
 
-static void DirectorExtension_Register(HINSTANCE hInstance) noexcept {
+void DirectorExtension_Register(HINSTANCE hInstance) noexcept {
 	WNDCLASS wndclass;
 	wndclass.style = 0;
 	wndclass.lpfnWndProc = DirectorExtension_WndProc;
@@ -151,6 +154,8 @@
 		::exit(FALSE);
 }
 
+}
+
 DirectorExtension &DirectorExtension::Instance() {
 	static DirectorExtension singleton;
 	return singleton;
@@ -167,8 +172,8 @@
 			    DirectorExtension_ClassName,
 			    0,
 			    0, 0, 0, 0,
-			    0,
-			    0,
+			    {},
+			    {},
 			    hInstance,
 			    nullptr);
 	if (!wReceiver)
Index: scite/win32/GUIWin.cxx
===================================================================
--- scite/win32/GUIWin.cxx	(版本 44)
+++ scite/win32/GUIWin.cxx	(版本 45)
@@ -29,7 +29,9 @@
 enum { SURROGATE_TRAIL_FIRST = 0xDC00 };
 enum { SURROGATE_TRAIL_LAST = 0xDFFF };
 
-static unsigned int UTF8Length(const wchar_t *uptr, size_t tlen) noexcept {
+namespace {
+
+unsigned int UTF8Length(const wchar_t *uptr, size_t tlen) noexcept {
 	unsigned int len = 0;
 	for (size_t i = 0; i < tlen && uptr[i];) {
 		const unsigned int uch = uptr[i];
@@ -38,7 +40,7 @@
 		} else if (uch < 0x800) {
 			len += 2;
 		} else if ((uch >= SURROGATE_LEAD_FIRST) &&
-				(uch <= SURROGATE_TRAIL_LAST)) {
+			(uch <= SURROGATE_TRAIL_LAST)) {
 			len += 4;
 			i++;
 		} else {
@@ -49,7 +51,7 @@
 	return len;
 }
 
-static void UTF8FromUTF16(const wchar_t *uptr, size_t tlen, char *putf) noexcept {
+void UTF8FromUTF16(const wchar_t *uptr, size_t tlen, char *putf) noexcept {
 	int k = 0;
 	for (size_t i = 0; i < tlen && uptr[i];) {
 		const unsigned int uch = uptr[i];
@@ -59,7 +61,7 @@
 			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)) {
+			(uch <= SURROGATE_TRAIL_LAST)) {
 			// Half a surrogate pair
 			i++;
 			const unsigned int xch = 0x10000 + ((uch & 0x3ff) << 10) + (uptr[i] & 0x3ff);
@@ -76,10 +78,10 @@
 	}
 }
 
-static size_t UTF16Length(const char *s, size_t len) noexcept {
+size_t UTF16Length(const char *s, size_t len) noexcept {
 	size_t ulen = 0;
 	size_t charLen;
-	for (size_t i=0; i<len;) {
+	for (size_t i = 0; i < len;) {
 		const unsigned char ch = static_cast<unsigned char>(s[i]);
 		if (ch < 0x80) {
 			charLen = 1;
@@ -97,11 +99,12 @@
 	return ulen;
 }
 
-static size_t UTF16FromUTF8(const char *s, size_t len, gui_char *tbuf, size_t tlen) noexcept {
-	size_t ui=0;
-	const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
-	size_t i=0;
-	while ((i<len) && (ui<tlen)) {
+size_t UTF16FromUTF8(std::string_view s, gui_char *tbuf, size_t tlen) noexcept {
+	size_t ui = 0;
+	const unsigned char *us = reinterpret_cast<const unsigned char *>(s.data());
+	size_t len = s.size();
+	size_t i = 0;
+	while ((i < len) && (ui < tlen)) {
 		unsigned char ch = us[i++];
 		if (ch < 0x80) {
 			tbuf[ui] = ch;
@@ -133,42 +136,41 @@
 	return ui;
 }
 
+}
+
 gui_string StringFromUTF8(const char *s) {
 	if (!s || !*s) {
-		return gui_string();
+		return {};
 	}
-	const size_t sLen = strlen(s);
-	const size_t wideLen = UTF16Length(s, sLen);
+	const size_t wideLen = UTF16Length(s, strlen(s));
 	gui_string us(wideLen, 0);
-	UTF16FromUTF8(s, sLen, us.data(), wideLen);
+	UTF16FromUTF8(s, us.data(), wideLen);
 	return us;
 }
 
 gui_string StringFromUTF8(const std::string &s) {
 	if (s.empty()) {
-		return gui_string();
+		return {};
 	}
-	const size_t sLen = s.length();
-	const size_t wideLen = UTF16Length(s.c_str(), sLen);
+	const size_t wideLen = UTF16Length(s.c_str(), s.length());
 	gui_string us(wideLen, 0);
-	UTF16FromUTF8(s.c_str(), sLen, us.data(), wideLen);
+	UTF16FromUTF8(s, us.data(), wideLen);
 	return us;
 }
 
 gui_string StringFromUTF8(std::string_view sv) {
 	if (sv.empty()) {
-		return gui_string();
+		return {};
 	}
-	const size_t sLen = sv.length();
-	const size_t wideLen = UTF16Length(sv.data(), sLen);
+	const size_t wideLen = UTF16Length(sv.data(), sv.length());
 	gui_string us(wideLen, 0);
-	UTF16FromUTF8(sv.data(), sLen, us.data(), wideLen);
+	UTF16FromUTF8(sv, us.data(), wideLen);
 	return us;
 }
 
 std::string UTF8FromString(gui_string_view sv) {
 	if (sv.empty()) {
-		return std::string();
+		return {};
 	}
 	const size_t sLen = sv.size();
 	const size_t narrowLen = UTF8Length(sv.data(), sLen);
@@ -186,21 +188,15 @@
 }
 
 gui_string HexStringFromInteger(long i) {
-	char number[32];
-	snprintf(number, std::size(number), "%0lx", i);
-	gui_char gnumber[32] {};
-	size_t n = 0;
-	while (number[n]) {
-		gnumber[n] = static_cast<gui_char>(number[n]);
-		n++;
-	}
-	gnumber[n] = 0;
-	return gui_string(gnumber);
+	constexpr size_t maxDigits = 32;
+	char number[maxDigits]{};
+	std::to_chars(number, number + maxDigits, i, hexBase);
+	return StringFromUTF8(number);
 }
 
 std::string LowerCaseUTF8(std::string_view sv) {
 	if (sv.empty()) {
-		return std::string();
+		return {};
 	}
 	const std::string s(sv);
 	const gui_string gs = StringFromUTF8(s);
@@ -228,14 +224,14 @@
 
 void Window::SetPosition(Rectangle rc) {
 	::SetWindowPos(static_cast<HWND>(wid),
-		       0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER|SWP_NOACTIVATE);
+		       {}, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
 Rectangle Window::GetClientPosition() {
-	RECT rc= {0, 0, 0, 0};
+	RECT rc {};
 	if (wid)
 		::GetClientRect(static_cast<HWND>(wid), &rc);
-	return  Rectangle(rc.left, rc.top, rc.right, rc.bottom);
+	return Rectangle(rc.left, rc.top, rc.right, rc.bottom);
 }
 
 void Window::Show(bool show) {
Index: scite/win32/SciTEWin.cxx
===================================================================
--- scite/win32/SciTEWin.cxx	(版本 44)
+++ scite/win32/SciTEWin.cxx	(版本 45)
@@ -27,10 +27,15 @@
 const GUI::gui_char appName[] = GUI_TEXT("Sc1");
 #else
 const GUI::gui_char appName[] = GUI_TEXT("SciTE");
-static const GUI::gui_char scintillaName[] = GUI_TEXT("Scintilla.DLL");
 #endif
 
-static GUI::gui_string GetErrorMessage(DWORD nRet) {
+namespace {
+
+#if !defined(STATIC_BUILD)
+const GUI::gui_char scintillaName[] = GUI_TEXT("Scintilla.DLL");
+#endif
+
+GUI::gui_string GetErrorMessage(DWORD nRet) {
 	LPWSTR lpMsgBuf = nullptr;
 	if (::FormatMessage(
 				FORMAT_MESSAGE_ALLOCATE_BUFFER |
@@ -51,6 +56,8 @@
 	}
 }
 
+}
+
 long SciTEKeys::ParseKeyCode(std::string_view mnemonic) {
 	std::string sKey(mnemonic);
 
@@ -77,7 +84,7 @@
 			const int vkey = IntegerFromString(sKey, 0);
 			if (vkey > 0 && vkey <= 0x7FFF)
 				keyval = vkey;
-		} else if (StartsWith(sKey, "Keypad")) {
+		} else if (sKey.starts_with("Keypad")) {
 			sKey.erase(0, strlen("Keypad"));
 			if ((sKey.length() > 0) && IsADigit(sKey.at(0))) {
 				const int keyNum = IntegerFromString(sKey, -1);
@@ -345,37 +352,34 @@
 }
 
 std::string StringEncode(std::wstring_view wsv, int codePage) {
-	if (wsv.length()) {
-		const int sLength = static_cast<int>(wsv.length());
-		const int cchMulti = ::WideCharToMultiByte(codePage, 0, wsv.data(), sLength, nullptr, 0, nullptr, nullptr);
-		std::string sMulti(cchMulti, 0);
-		::WideCharToMultiByte(codePage, 0, wsv.data(), sLength, sMulti.data(), cchMulti, nullptr, nullptr);
-		return sMulti;
-	} else {
-		return std::string();
+	if (wsv.empty()) {
+		return {};
 	}
+	const int sLength = static_cast<int>(wsv.length());
+	const int cchMulti = ::WideCharToMultiByte(codePage, 0, wsv.data(), sLength, nullptr, 0, nullptr, nullptr);
+	std::string sMulti(cchMulti, 0);
+	::WideCharToMultiByte(codePage, 0, wsv.data(), sLength, sMulti.data(), cchMulti, nullptr, nullptr);
+	return sMulti;
 }
 
 std::wstring StringDecode(std::string_view sv, int codePage) {
-	if (sv.length()) {
-		const int sLength = static_cast<int>(sv.length());
-		const int cchWide = ::MultiByteToWideChar(codePage, 0, sv.data(), sLength, nullptr, 0);
-		std::wstring sWide(cchWide, 0);
-		::MultiByteToWideChar(codePage, 0, sv.data(), sLength, sWide.data(), cchWide);
-		return sWide;
-	} else {
-		return std::wstring();
+	if (sv.empty()) {
+		return {};
 	}
+	const int sLength = static_cast<int>(sv.length());
+	const int cchWide = ::MultiByteToWideChar(codePage, 0, sv.data(), sLength, nullptr, 0);
+	std::wstring sWide(cchWide, 0);
+	::MultiByteToWideChar(codePage, 0, sv.data(), sLength, sWide.data(), cchWide);
+	return sWide;
 }
 
 // Convert to UTF-8
-std::string ConvertEncoding(const char *original, int codePage) {
+std::string ConvertEncoding(std::string_view original, int codePage) {
 	if (codePage == CP_UTF8) {
-		return original;
-	} else {
-		GUI::gui_string sWide = StringDecode(original, codePage);
-		return GUI::UTF8FromString(sWide);
+		return std::string(original);
 	}
+	GUI::gui_string sWide = StringDecode(original, codePage);
+	return GUI::UTF8FromString(sWide);
 }
 
 }
@@ -384,7 +388,7 @@
 	SciTEBase::ReadLocalization();
 	std::string encoding = localiser.GetString("translation.encoding");
 	LowerCaseAZ(encoding);
-	if (encoding.length()) {
+	if (!encoding.empty()) {
 		const int codePageNamed = CodePageFromName(encoding);
 		const char *key = nullptr;
 		const char *val = nullptr;
@@ -392,7 +396,7 @@
 		bool more = localiser.GetFirst(key, val);
 		while (more) {
 			const std::string converted = ConvertEncoding(val, codePageNamed);
-			if (converted != "") {
+			if (!converted.empty()) {
 				localiser.Set(key, converted);
 			}
 			more = localiser.GetNext(key, val);
@@ -544,7 +548,7 @@
 		return home;
 	} else {
 		GUI::gui_char path[MAX_PATH+1]{};
-		if (::GetModuleFileNameW(0, path, MAX_PATH) == 0)
+		if (::GetModuleFileNameW({}, path, MAX_PATH) == 0)
 			return {};
 		// Remove the SciTE.exe
 		const FilePath pathSciTE(path);
@@ -627,7 +631,7 @@
 				ak.pszMsgTitle = nullptr;
 				ak.pszWindow = nullptr;
 				ak.fIndexOnFail = TRUE;
-				fnHHW(NULL,
+				fnHHW({},
 				      path.c_str(),
 				      0x000d,          	// HH_KEYWORD_LOOKUP
 				      reinterpret_cast<DWORD_PTR>(&ak)
@@ -680,7 +684,7 @@
 
 void SciTEWin::FullScreenToggle() {
 	HWND wTaskBar = FindWindow(TEXT("Shell_TrayWnd"), TEXT(""));
-	HWND wStartButton = FindWindow(TEXT("Button"), nullptr);
+	HWND wStartButton = FindWindow(WC_BUTTONW, nullptr);
 	fullScreen = !fullScreen;
 	if (fullScreen) {
 		::SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0);
@@ -740,7 +744,7 @@
 		if (!wEditor.HasFocus() && !wOutput.HasFocus()) {
 			HWND wWithFocus = ::GetFocus();
 			const GUI::gui_string classNameFocus = ClassNameOfWindow(wWithFocus);
-			if (classNameFocus == GUI_TEXT("Edit")) {
+			if (classNameFocus == WC_EDITW) {
 				switch (cmdID) {
 				case IDM_UNDO:
 					::SendMessage(wWithFocus, EM_UNDO, 0, 0);
@@ -789,8 +793,10 @@
 	}
 }
 
+namespace {
+
 // from ScintillaWin.cxx
-static UINT CodePageFromCharSet(SA::CharacterSet characterSet, UINT documentCodePage) noexcept {
+UINT CodePageFromCharSet(SA::CharacterSet characterSet, UINT documentCodePage) noexcept {
 	CHARSETINFO ci {};
 	const BOOL bci = ::TranslateCharsetInfo(reinterpret_cast<DWORD *>(static_cast<uintptr_t>(characterSet)),
 						&ci, TCI_SRCCHARSET);
@@ -804,6 +810,8 @@
 	return cp;
 }
 
+}
+
 void SciTEWin::OutputAppendEncodedStringSynchronised(const GUI::gui_string &s, int codePageDocument) {
 	const std::string sMulti = StringEncode(s, codePageDocument);
 	OutputAppendStringSynchronised(sMulti);
@@ -847,7 +855,7 @@
 
 void SciTEWin::ExecuteNext() {
 	cmdWorker.icmd++;
-	if (cmdWorker.icmd < jobQueue.commandCurrent && cmdWorker.icmd < jobQueue.commandMax && cmdWorker.exitStatus == 0) {
+	if (cmdWorker.icmd < jobQueue.commandCurrent && cmdWorker.icmd < JobQueue::commandMax && cmdWorker.exitStatus == 0) {
 		Execute();
 	} else {
 		ResetExecution();
@@ -1465,8 +1473,8 @@
 			(left != static_cast<int>(CW_USEDEFAULT))) {
 		left += width;
 	}
-	// Pass 'this' pointer in lpParam of CreateWindow().
-	wSciTE = ::CreateWindowEx(
+	// Pass 'this' pointer in lpParam of CreateWindowExW().
+	wSciTE = ::CreateWindowExW(
 			 0,
 			 className,
 			 windowName.c_str(),
@@ -1474,8 +1482,8 @@
 			 WS_MINIMIZEBOX | WS_MAXIMIZEBOX |
 			 WS_CLIPCHILDREN,
 			 left, top, width, height,
-			 NULL,
-			 NULL,
+			 {},
+			 {},
 			 hInstance,
 			 this);
 	if (!wSciTE.Created())
@@ -1667,20 +1675,22 @@
 	// Scintilla, hdrop is null, and an exception is generated!
 	if (hdrop) {
 		const bool tempFilesSyncLoad = props.GetInt("temp.files.sync.load") != 0;
-		GUI::gui_char tempDir[MAX_PATH];
-		const DWORD tempDirLen = ::GetTempPath(MAX_PATH, tempDir);
+		GUI::gui_char tempDirTest[1];
+		const DWORD tempDirLen = ::GetTempPathW(0, tempDirTest);
+		GUI::gui_string tempDir(tempDirLen-1, L'\0');
+		::GetTempPathW(tempDirLen, tempDir.data());
 		bool isTempFile = false;
-		const int filesDropped = ::DragQueryFile(hdrop, 0xffffffff, nullptr, 0);
+		const int filesDropped = ::DragQueryFileW(hdrop, 0xffffffff, nullptr, 0);
 		// Append paths to dropFilesQueue, to finish drag operation soon
 		for (int i = 0; i < filesDropped; ++i) {
-			GUI::gui_char pathDropped[MAX_PATH];
-			::DragQueryFileW(hdrop, i, pathDropped,
-					 static_cast<UINT>(std::size(pathDropped)));
+			const int lenPath = ::DragQueryFileW(hdrop, i, nullptr, 0);
+			GUI::gui_string pathDropped(lenPath, L'\0');
+			::DragQueryFileW(hdrop, i, pathDropped.data(), lenPath+1);
 			// Only do this for the first file in the drop op
 			// as all are coming from the same drag location
 			if (i == 0 && tempFilesSyncLoad) {
 				// check if file's parent dir is temp
-				if (::wcsncmp(tempDir, pathDropped, tempDirLen) == 0) {
+				if (pathDropped.starts_with(tempDir)) {
 					isTempFile = true;
 				}
 			}
@@ -1689,7 +1699,7 @@
 					break;
 				}
 			} else {
-				dropFilesQueue.push_back(pathDropped);
+				dropFilesQueue.emplace_back(pathDropped);
 			}
 		}
 		::DragFinish(hdrop);
@@ -1757,7 +1767,7 @@
 			// if the filename has no extension, try to match a file with list of standard extensions
 			std::string extensions = props.GetExpandedString("source.default.extensions");
 			if (extensions.length()) {
-				std::replace(extensions.begin(), extensions.end(), '|', '\0');
+				std::ranges::replace(extensions, '|', '\0');
 				size_t start = 0;
 				while (start < extensions.length()) {
 					GUI::gui_string filterName = GUI::StringFromUTF8(extensions.c_str() + start);
@@ -1864,7 +1874,7 @@
 		wOutput.Send(WM_DPICHANGED, wParam, lParam);
 		ReloadProperties();
 		const RECT *rect = reinterpret_cast<const RECT *>(lParam);
-		::SetWindowPos(MainHWND(), NULL, rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top,
+		::SetWindowPos(MainHWND(), {}, rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top,
 			SWP_NOZORDER | SWP_NOACTIVATE);
 
 		if (!fnSystemParametersInfoForDpi) {
@@ -2054,7 +2064,7 @@
 		case SCITE_DROP:
 			// Open the files
 			while (!dropFilesQueue.empty()) {
-				FilePath file(dropFilesQueue.front());
+				const FilePath file(dropFilesQueue.front());
 				dropFilesQueue.pop_front();
 				if (file.Exists()) {
 					Open(file);
@@ -2268,7 +2278,7 @@
 				const GUI::Rectangle rcScintilla = pSciTEWin->wEditor.GetPosition();
 				const GUI::Rectangle rcOutput = pSciTEWin->wOutput.GetPosition();
 				if (!rcScintilla.Contains(ptCursor) && !rcOutput.Contains(ptCursor)) {
-					::SetCursor(::LoadCursor(NULL, pSciTEWin->splitVertical ? IDC_SIZEWE : IDC_SIZENS));
+					::SetCursor(::LoadCursor({}, pSciTEWin->splitVertical ? IDC_SIZEWE : IDC_SIZENS));
 					return TRUE;
 				}
 			}
@@ -2315,13 +2325,13 @@
 	BOOL going = TRUE;
 	while (going) {
 		if (needIdle) {
-			const BOOL haveMessage = PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
+			const BOOL haveMessage = PeekMessageW(&msg, {}, 0, 0, PM_NOREMOVE);
 			if (!haveMessage) {
 				OnIdle();
 				continue;
 			}
 		}
-		going = ::GetMessageW(&msg, NULL, 0, 0);
+		going = ::GetMessageW(&msg, {}, 0, 0);
 		if (going > 0) {
 			if (!ModelessHandler(&msg)) {
 				if (!GetID() ||
@@ -2335,7 +2345,9 @@
 	return msg.wParam;
 }
 
-static void RestrictDLLPath() noexcept {
+namespace {
+
+void RestrictDLLPath() noexcept {
 	// Try to limit the locations where DLLs will be loaded from to prevent binary planting.
 	// That is where a bad DLL is placed in the current directory or in the PATH.
 	using SetDefaultDllDirectoriesSig = BOOL(WINAPI *)(DWORD DirectoryFlags);
@@ -2360,6 +2372,8 @@
 	}
 }
 
+}
+
 #ifdef STATIC_BUILD
 extern "C" Scintilla::ILexer5 * __stdcall CreateLexer(const char *name);
 #endif
Index: scite/win32/SciTEWin.h
===================================================================
--- scite/win32/SciTEWin.h	(版本 44)
+++ scite/win32/SciTEWin.h	(版本 45)
@@ -15,6 +15,7 @@
 #include <cstdio>
 #include <cstdarg>
 
+#include <compare>
 #include <tuple>
 #include <string>
 #include <string_view>
Index: scite/win32/SciTEWinBar.cxx
===================================================================
--- scite/win32/SciTEWinBar.cxx	(版本 44)
+++ scite/win32/SciTEWinBar.cxx	(版本 45)
@@ -15,7 +15,7 @@
 
 	constexpr int TEMP_LEN = 100;
 	wchar_t temp[TEMP_LEN] = L"";
-	HANDLE hf = ::CreateFileW(filePath.AsInternal(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	HANDLE hf = ::CreateFileW(filePath.AsInternal(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, {});
 	if (hf != INVALID_HANDLE_VALUE) {
 		FILETIME ft = FILETIME();
 		::GetFileTime(hf, nullptr, nullptr, &ft);
@@ -78,9 +78,9 @@
 	// Synchronize the tab control titles with those passed in.
 
 	// Find the first element that differs between the two vectors.
-	const auto [misNames, misNamesCurrent] = std::mismatch(
-		tabNames.begin(), tabNames.end(),
-		tabNamesCurrent.begin(), tabNamesCurrent.end());
+	const auto [misNames, misNamesCurrent] = std::ranges::mismatch(
+		tabNames,
+		tabNamesCurrent);
 	size_t tabChange = std::distance(tabNames.begin(), misNames);
 
 	if (tabNames.size() == tabNamesCurrent.size() && tabNames.size() == tabChange) {
@@ -499,7 +499,7 @@
 			const GUI::Rectangle rcToSet(rcClient.left, yPos, rcClient.right, yPos + band.height);
 			if (hdwp)
 				hdwp = ::DeferWindowPos(hdwp, HwndOf(band.win),
-							0, rcToSet.left, rcToSet.top, rcToSet.Width(), rcToSet.Height(),
+							{}, rcToSet.left, rcToSet.top, rcToSet.Width(), rcToSet.Height(),
 							SWP_NOZORDER|SWP_NOACTIVATE|SWP_SHOWWINDOW);
 			yPos += band.height;
 		} else {
@@ -506,7 +506,7 @@
 			const GUI::Rectangle rcToSet(rcClient.left, rcClient.top - 41, rcClient.Width(), rcClient.top - 40);
 			if (hdwp)
 				hdwp = ::DeferWindowPos(hdwp, HwndOf(band.win),
-							0, rcToSet.left, rcToSet.top, rcToSet.Width(), rcToSet.Height(),
+							{}, rcToSet.left, rcToSet.top, rcToSet.Width(), rcToSet.Height(),
 							SWP_NOZORDER|SWP_NOACTIVATE|SWP_HIDEWINDOW);
 		}
 	}
@@ -645,7 +645,7 @@
 							text += accel;
 						}
 						text.append(1, 0);
-						mii.dwTypeData = &text[0];
+						mii.dwTypeData = text.data();
 						::SetMenuItemInfoW(hmenu, i, TRUE, &mii);
 					}
 				}
@@ -675,12 +675,14 @@
 	}
 }
 
+namespace {
+
 struct BarButton {
 	int id;
 	int cmd;
 };
 
-static BarButton bbs[] = {
+BarButton bbs[] = {
 	{ -1,           0 },
 	{ STD_FILENEW,  IDM_NEW },
 	{ STD_FILEOPEN, IDM_OPEN },
@@ -701,8 +703,8 @@
 	{ STD_REPLACE,  IDM_REPLACE },
 };
 
-static WNDPROC stDefaultTabProc = nullptr;
-static LRESULT PASCAL TabWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+WNDPROC stDefaultTabProc = nullptr;
+LRESULT PASCAL TabWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
 
 	static bool bDragBegin = false;
 	static int iDraggingTab = -1;
@@ -742,7 +744,7 @@
 			if (bDragBegin) {
 				if (hwndLastFocus) ::SetFocus(hwndLastFocus);
 				::ReleaseCapture();
-				::SetCursor(::LoadCursor(NULL, IDC_ARROW));
+				::SetCursor(::LoadCursor({}, IDC_ARROW));
 				bDragBegin = false;
 				const GUI::Point pt = PointFromLong(lParam);
 				const int tab = TabAtPoint(hWnd, pt);
@@ -762,7 +764,7 @@
 				if (bDragBegin) {
 					if (hwndLastFocus) ::SetFocus(hwndLastFocus);
 					::ReleaseCapture();
-					::SetCursor(::LoadCursor(NULL, IDC_ARROW));
+					::SetCursor(::LoadCursor({}, IDC_ARROW));
 					bDragBegin = false;
 					iDraggingTab = -1;
 					iLastClickTab = -1;
@@ -797,7 +799,7 @@
 									       MAKEINTRESOURCE(IDC_DRAGDROP));
 						if (hcursor) ::SetCursor(hcursor);
 					} else {
-						::SetCursor(::LoadCursor(NULL, IDC_NO));
+						::SetCursor(::LoadCursor({}, IDC_NO));
 					}
 				}
 			}
@@ -863,6 +865,8 @@
 	return retResult;
 }
 
+}
+
 void SciTEWin::CreateStrip(LPCWSTR stripName, LPVOID lpParam) {
 	const HWND hwnd = ::CreateWindowExW(
 		0,
@@ -884,13 +888,15 @@
  */
 void SciTEWin::Creation() {
 
-	wContent = ::CreateWindowEx(
+	constexpr int widthWindow = 100;	// Temporary until stretched to fit
+
+	wContent = ::CreateWindowExW(
 			   flatterUI ? 0 : WS_EX_CLIENTEDGE,
 			   classNameInternal,
 			   TEXT("Source"),
 			   WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
 			   0, 0,
-			   100, 100,
+			   widthWindow, 100,
 			   MainHWND(),
 			   HmenuID(2000),
 			   hInstance,
@@ -897,13 +903,13 @@
 			   &contents);
 	wContent.Show();
 
-	wEditor.SetScintilla(::CreateWindowEx(
+	wEditor.SetScintilla(::CreateWindowExW(
 				     0,
 				     TEXT("Scintilla"),
 				     TEXT("Source"),
 				     WS_CHILD | WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
 				     0, 0,
-				     100, 100,
+				     widthWindow, 100,
 				     HwndOf(wContent),
 				     HmenuID(IDM_SRCWIN),
 				     hInstance,
@@ -915,13 +921,13 @@
 	wEditor.SetCommandEvents(false);
 	WindowSetFocus(wEditor);
 
-	wOutput.SetScintilla(::CreateWindowEx(
+	wOutput.SetScintilla(::CreateWindowExW(
 				     0,
 				     TEXT("Scintilla"),
 				     TEXT("Run"),
 				     WS_CHILD | WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
 				     0, 0,
-				     100, 100,
+				     widthWindow, 100,
 				     HwndOf(wContent),
 				     HmenuID(IDM_RUNWIN),
 				     hInstance,
@@ -936,7 +942,7 @@
 	wOutput.UsePopUp(SA::PopUp::Never);
 	::DragAcceptFiles(MainHWND(), true);
 
-	HWND hwndToolBar = ::CreateWindowEx(
+	HWND hwndToolBar = ::CreateWindowExW(
 				   0,
 				   TOOLBARCLASSNAME,
 				   TEXT(""),
@@ -943,7 +949,7 @@
 				   WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
 				   TBSTYLE_FLAT | TBSTYLE_TOOLTIPS | CCS_NORESIZE,
 				   0, 0,
-				   100, tbLarge ? heightToolsBig : heightTools,
+				   widthWindow, tbLarge ? heightToolsBig : heightTools,
 				   MainHWND(),
 				   HmenuID(IDM_TOOLWIN),
 				   hInstance,
@@ -990,7 +996,7 @@
 	InitCommonControlsEx(&icce);
 
 	WNDCLASS wndClass = {};
-	if (::GetClassInfo(NULL, WC_TABCONTROL, &wndClass) == 0)
+	if (::GetClassInfo({}, WC_TABCONTROL, &wndClass) == 0)
 		exit(FALSE);
 	stDefaultTabProc = wndClass.lpfnWndProc;
 	wndClass.lpfnWndProc = TabWndProc;
@@ -1000,7 +1006,7 @@
 	if (RegisterClass(&wndClass) == 0)
 		exit(FALSE);
 
-	wTabBar = ::CreateWindowEx(
+	wTabBar = ::CreateWindowExW(
 			  0,
 			  TEXT("SciTeTabCtrl"),
 			  TEXT("Tab"),
@@ -1007,7 +1013,7 @@
 			  WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
 			  TCS_FOCUSNEVER | TCS_TOOLTIPS,
 			  0, 0,
-			  100, heightTab,
+			  widthWindow, heightTab,
 			  MainHWND(),
 			  HmenuID(IDM_TABWIN),
 			  hInstance,
@@ -1031,13 +1037,13 @@
 	CreateStrip(L"ReplaceStrip", &replaceStrip);
 	CreateStrip(L"FilterStrip", &filterStrip);
 
-	wStatusBar = ::CreateWindowEx(
+	wStatusBar = ::CreateWindowExW(
 			     0,
 			     STATUSCLASSNAME,
 			     TEXT(""),
 			     WS_CHILD | WS_CLIPSIBLINGS,
 			     0, 0,
-			     100, heightStatus,
+			     widthWindow, heightStatus,
 			     MainHWND(),
 			     HmenuID(IDM_STATUSWIN),
 			     hInstance,
@@ -1050,16 +1056,16 @@
 		      SB_SETPARTS, 1,
 		      reinterpret_cast<LPARAM>(widths));
 
-	bands.push_back(Band(true, tbLarge ? heightToolsBig : heightTools, false, wToolBar));
-	bands.push_back(Band(true, heightTab, false, wTabBar));
-	bands.push_back(Band(true, 100, true, wContent));
-	bands.push_back(Band(true, userStrip.Height(), false, userStrip));
-	bands.push_back(Band(true, backgroundStrip.Height(), false, backgroundStrip));
-	bands.push_back(Band(true, searchStrip.Height(), false, searchStrip));
-	bands.push_back(Band(true, findStrip.Height(), false, findStrip));
-	bands.push_back(Band(true, replaceStrip.Height(), false, replaceStrip));
-	bands.push_back(Band(true, filterStrip.Height(), false, filterStrip));
-	bands.push_back(Band(true, heightStatus, false, wStatusBar));
+	bands.emplace_back(true, tbLarge ? heightToolsBig : heightTools, false, wToolBar);
+	bands.emplace_back(true, heightTab, false, wTabBar);
+	bands.emplace_back(true, 100, true, wContent);
+	bands.emplace_back(true, userStrip.Height(), false, userStrip);
+	bands.emplace_back(true, backgroundStrip.Height(), false, backgroundStrip);
+	bands.emplace_back(true, searchStrip.Height(), false, searchStrip);
+	bands.emplace_back(true, findStrip.Height(), false, findStrip);
+	bands.emplace_back(true, replaceStrip.Height(), false, replaceStrip);
+	bands.emplace_back(true, filterStrip.Height(), false, filterStrip);
+	bands.emplace_back(true, heightStatus, false, wStatusBar);
 
 #ifndef NO_LUA
 	if (props.GetExpandedString("ext.lua.startup.script").length() == 0)
Index: scite/win32/SciTEWinDlg.cxx
===================================================================
--- scite/win32/SciTEWinDlg.cxx	(版本 44)
+++ scite/win32/SciTEWinDlg.cxx	(版本 45)
@@ -52,7 +52,7 @@
 			using MMFn = BOOL(WINAPI *)(LPCSTR, HMODULE, DWORD);
 			MMFn fnMM = DLLFunction<MMFn>(hMM, "PlaySoundA");
 			if (fnMM) {
-				bPlayOK = fnMM(sound, NULL, SND_ASYNC | SND_FILENAME);
+				bPlayOK = fnMM(sound, {}, SND_ASYNC | SND_FILENAME);
 			}
 		}
 	}
@@ -209,7 +209,7 @@
 	if (filterProperty.length()) {
 		const std::vector<GUI::gui_string> filters = StringSplit(filterProperty, GUI_TEXT('|'));
 		for (size_t i = 0; i < filters.size()-1; i+=2) {
-			if (!StartsWith(filters[i], GUI_TEXT("#"))) {
+			if (!filters[i].starts_with(GUI_TEXT("#"))) {
 				const GUI::gui_string localised = localiser.Text(GUI::UTF8FromString(filters[i]), false);
 				if (localised.size()) {
 					transformed.push_back(localised);
@@ -244,7 +244,7 @@
 	DWORD filterDefault = 1;
 	std::vector<GUI::gui_string> filters = StringSplit(GUI::gui_string(filesFilter), L'|');
 	if (!openFilterDefault.empty()) {
-		std::vector<GUI::gui_string>::iterator itFilter = std::find(filters.begin(), filters.end(), openFilterDefault);
+		std::vector<GUI::gui_string>::iterator itFilter = std::ranges::find(filters, openFilterDefault);
 		if (itFilter != filters.end()) {
 			filterDefault = static_cast<DWORD>(std::distance(filters.begin(), itFilter)) / 2 + 1;
 		}
@@ -439,7 +439,9 @@
 	}
 }
 
-static void DeleteFontObject(HFONT &font) noexcept {
+namespace {
+
+void DeleteFontObject(HFONT &font) noexcept {
 	if (font) {
 		::DeleteObject(font);
 		font = {};
@@ -446,6 +448,8 @@
 	}
 }
 
+}
+
 /**
  * Display the Print dialog (if @a showDialog asks it),
  * allowing it to choose what to print on which printer.
@@ -831,7 +835,9 @@
 
 };
 
-static void FillComboFromProps(HWND combo, const PropSetFile &props) {
+namespace {
+
+void FillComboFromProps(HWND combo, const PropSetFile &props) {
 	const char *key = nullptr;
 	const char *val = nullptr;
 	if (props.GetFirst(key, val)) {
@@ -848,6 +854,8 @@
 	}
 }
 
+}
+
 void SciTEWin::UserStripShow(const char *description) {
 	userStrip.visible = *description != 0;
 	if (userStrip.visible) {
@@ -1175,7 +1183,9 @@
 // Set a call back with the handle after init to set the path.
 // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/shell/reference/callbackfunctions/browsecallbackproc.asp
 
-static int __stdcall BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM, LPARAM pData) {
+namespace {
+
+int __stdcall BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM, LPARAM pData) {
 	if (uMsg == BFFM_INITIALIZED) {
 		SendMessage(hwnd, BFFM_SETSELECTION, TRUE, pData);
 	}
@@ -1182,6 +1192,8 @@
 	return 0;
 }
 
+}
+
 void SciTEWin::PerformGrep() {
 	SelectionIntoProperties();
 
@@ -1319,7 +1331,7 @@
 				info.ulFlags = 0;
 				info.lpfn = BrowseCallbackProc;
 				GUI::gui_string directory = dlg.ItemTextG(IDDIRECTORY);
-				if (!EndsWith(directory, pathSepString)) {
+				if (!directory.ends_with(pathSepString)) {
 					directory += pathSepString;
 				}
 				info.lParam = reinterpret_cast<LPARAM>(directory.c_str());
@@ -1665,7 +1677,7 @@
 	modalParameters = modal;
 	if (modal) {
 		success = DoDialog(TEXT("PARAMETERS"), ParametersDlg) == IDOK;
-		wParameters = NULL;
+		wParameters = nullptr;
 	} else {
 		CreateParameterisedDialog(TEXT("PARAMETERSNONMODAL"), ParametersDlg);
 		wParameters.Show();
Index: scite/win32/Strips.cxx
===================================================================
--- scite/win32/Strips.cxx	(版本 44)
+++ scite/win32/Strips.cxx	(版本 45)
@@ -185,7 +185,7 @@
 	int position = rcArea.left;
 	for (const int width : widths) {
 		const int widthElement = width ? width : resizerWidth;
-		positions.push_back(Interval(position, position + widthElement));
+		positions.emplace_back(position, position + widthElement);
 		position += widthElement + gap;
 	}
 	return positions;
@@ -269,7 +269,7 @@
 	GUI::gui_string localised = localiser->Text(text);
 	const int width = WidthText(fontText, localised) + 4;
 	GUI::Window w;
-	w.SetID(::CreateWindowEx(0, TEXT("Static"), localised.c_str(),
+	w.SetID(::CreateWindowExW(0, WC_STATICW, localised.c_str(),
 				 WS_CHILD | WS_CLIPSIBLINGS | SS_RIGHT,
 				 2, 2, width, 21,
 				 Hwnd(), HmenuID(0), ::ApplicationInstance(), nullptr));
@@ -309,7 +309,7 @@
 		width = bmpDimension + 3 * 2;
 	}
 	GUI::Window w;
-	w.SetID(::CreateWindowEx(0, TEXT("Button"), localised.c_str(),
+	w.SetID(::CreateWindowExW(0, WC_BUTTONW, localised.c_str(),
 				 WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS |
 				 (check ? (BS_AUTOCHECKBOX | BS_PUSHLIKE | BS_BITMAP) : BS_PUSHBUTTON),
 				 2, 2, width, height,
@@ -393,12 +393,12 @@
 	SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, FALSE);
 	fontText = ::CreateFontIndirect(&ncm.lfMessageFont);
 
-	wToolTip = ::CreateWindowEx(0,
+	wToolTip = ::CreateWindowExW(0,
 				    TOOLTIPS_CLASSW, nullptr,
 				    WS_POPUP | TTS_ALWAYSTIP,
 				    CW_USEDEFAULT, CW_USEDEFAULT,
 				    CW_USEDEFAULT, CW_USEDEFAULT,
-				    Hwnd(), NULL, ::ApplicationInstance(), nullptr);
+				    Hwnd(), {}, ::ApplicationInstance(), nullptr);
 
 	SetTheme();
 }
@@ -441,10 +441,10 @@
 			HWND wChild = GetFirstChild(Hwnd());
 			while (wChild) {
 				const GUI::gui_string className = ClassNameOfWindow(wChild);
-				if ((className == TEXT("Button")) || (className == TEXT("Static"))) {
+				if ((className == WC_BUTTONW) || (className == WC_STATICW)) {
 					const std::string caption = GUI::UTF8FromString(TextOfWindow(wChild));
 					if (MatchAccessKey(caption, static_cast<int>(key))) {
-						if (className == TEXT("Button")) {
+						if (className == WC_BUTTONW) {
 							::SendMessage(wChild, BM_CLICK, 0, 0);
 						} else {	// Static caption
 							wChild = GetNextSibling(wChild);
@@ -588,7 +588,7 @@
 		scale = ::GetDeviceCaps(hdc, LOGPIXELSX);
 		::ReleaseDC(Hwnd(), hdc);
 		space = scale * 2 / 96;
-		const HRESULT hr = ::GetThemePartSize(hTheme, NULL, WP_SMALLCLOSEBUTTON, CBS_NORMAL,
+		const HRESULT hr = ::GetThemePartSize(hTheme, {}, WP_SMALLCLOSEBUTTON, CBS_NORMAL,
 						      nullptr, TS_TRUE, &closeSize);
 		//HRESULT hr = ::GetThemePartSize(hTheme, NULL, WP_MDICLOSEBUTTON, CBS_NORMAL,
 		//	NULL, TS_TRUE, &closeSize);
@@ -700,10 +700,10 @@
 	case WM_SETCURSOR: {
 			HWND hWnd = reinterpret_cast<HWND>(wParam);
 			const GUI::gui_string className = ClassNameOfWindow(hWnd);
-			if (className == TEXT("Edit") || className == TEXT("ComboBox")) {
+			if (className == WC_EDITW || className == WC_COMBOBOXW) {
 				return ::DefWindowProc(Hwnd(), iMessage, wParam, lParam);
 			} else {
-				::SetCursor(::LoadCursor(NULL, IDC_ARROW));
+				::SetCursor(::LoadCursor({}, IDC_ARROW));
 				return 0;
 			}
 		}
@@ -820,7 +820,7 @@
 	Strip::Creation();
 	lineHeight = SizeText(fontText, GUI_TEXT("\u00C5Ay")).cy + space * 2 + 1;
 
-	wExplanation = ::CreateWindowEx(0, TEXT("Static"), TEXT(""),
+	wExplanation = ::CreateWindowExW(0, WC_STATICW, TEXT(""),
 					WS_CHILD | WS_CLIPSIBLINGS,
 					2, 2, 100, 21,
 					Hwnd(), HmenuID(0), ::ApplicationInstance(), nullptr);
@@ -827,7 +827,7 @@
 	wExplanation.Show();
 	SetFontHandle(wExplanation, fontText);
 
-	wProgress = ::CreateWindowEx(0, PROGRESS_CLASS, TEXT(""),
+	wProgress = ::CreateWindowExW(0, PROGRESS_CLASS, TEXT(""),
 				     WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,
 				     2, 2, 100, 21,
 				     Hwnd(), HmenuID(0), ::ApplicationInstance(), nullptr);
@@ -927,7 +927,7 @@
 
 	wStaticFind = CreateText(textFindPrompt);
 
-	wText = CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("Edit"), TEXT(""),
+	wText = CreateWindowExW(WS_EX_CLIENTEDGE, WC_EDITW, TEXT(""),
 			       WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | ES_AUTOHSCROLL,
 			       50, 2, 300, 21,
 			       Hwnd(), HmenuID(IDC_INCFINDTEXT), ::ApplicationInstance(), nullptr);
@@ -1119,7 +1119,7 @@
 
 	wStaticFind = CreateText(textFindPrompt);
 
-	wText = CreateWindowEx(0, TEXT("ComboBox"), TEXT(""),
+	wText = ::CreateWindowExW(0, WC_COMBOBOXW, TEXT(""),
 			       WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | CBS_DROPDOWN | CBS_AUTOHSCROLL,
 			       50, 2, 300, 80,
 			       Hwnd(), HmenuID(IDFINDWHAT), ::ApplicationInstance(), nullptr);
@@ -1294,7 +1294,7 @@
 
 	wStaticFind = CreateText(textFindPrompt);
 
-	wText = CreateWindowEx(0, TEXT("ComboBox"), TEXT(""),
+	wText = ::CreateWindowExW(0, WC_COMBOBOXW, TEXT(""),
 			       WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | CBS_DROPDOWN | CBS_AUTOHSCROLL,
 			       50, 2, 300, 80,
 			       Hwnd(), HmenuID(IDFINDWHAT), ::ApplicationInstance(), nullptr);
@@ -1306,7 +1306,7 @@
 
 	wStaticReplace = CreateText(textReplacePrompt);
 
-	wReplace = CreateWindowEx(0, TEXT("ComboBox"), TEXT(""),
+	wReplace = ::CreateWindowExW(0, WC_COMBOBOXW, TEXT(""),
 				  WS_CHILD | WS_TABSTOP | CBS_DROPDOWN | CBS_AUTOHSCROLL,
 				  50, 2, 300, 80,
 				  Hwnd(), HmenuID(IDREPLACEWITH), ::ApplicationInstance(), nullptr);
@@ -1557,7 +1557,7 @@
 
 	wStaticFind = CreateText(textFilterPrompt);
 
-	wText = CreateWindowEx(0, TEXT("ComboBox"), TEXT(""),
+	wText = ::CreateWindowExW(0, WC_COMBOBOXW, TEXT(""),
 		WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | CBS_DROPDOWN | CBS_AUTOHSCROLL,
 		50, 2, 300, 80,
 		Hwnd(), HmenuID(IDFINDWHAT), ::ApplicationInstance(), nullptr);
@@ -1705,10 +1705,10 @@
 void UserStrip::Creation() {
 	Strip::Creation();
 	// Combo boxes automatically size to a reasonable height so create a temporary and measure
-	HWND wComboTest = ::CreateWindowEx(0, TEXT("ComboBox"), TEXT("Aby"),
+	HWND wComboTest = ::CreateWindowExW(0, WC_COMBOBOXW, TEXT("Aby"),
 					   WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | CBS_DROPDOWN | CBS_AUTOHSCROLL,
 					   50, 2, 300, 80,
-					   Hwnd(), 0, ::ApplicationInstance(), nullptr);
+					   Hwnd(), {}, ::ApplicationInstance(), nullptr);
 	SetWindowFont(wComboTest, fontText, 0);
 	RECT rc;
 	::GetWindowRect(wComboTest, &rc);
@@ -1896,7 +1896,7 @@
 			case UserControl::ucEdit:
 				ctl.widthDesired = 100;
 				ctl.fixedWidth = false;
-				ctl.w = ::CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("Edit"), ctl.text.c_str(),
+				ctl.w = ::CreateWindowExW(WS_EX_CLIENTEDGE, WC_EDITW, ctl.text.c_str(),
 							 WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | ES_AUTOHSCROLL,
 							 left, top, ctl.widthDesired, lineHeight - 3,
 							 Hwnd(), HmenuID(controlID), ::ApplicationInstance(), nullptr);
@@ -1905,7 +1905,7 @@
 			case UserControl::ucCombo:
 				ctl.widthDesired = 100;
 				ctl.fixedWidth = false;
-				ctl.w = ::CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("ComboBox"), ctl.text.c_str(),
+				ctl.w = ::CreateWindowExW(WS_EX_CLIENTEDGE, WC_COMBOBOXW, ctl.text.c_str(),
 							 WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | CBS_DROPDOWN | CBS_AUTOHSCROLL | WS_VSCROLL,
 							 left, top, ctl.widthDesired, 180,
 							 Hwnd(), HmenuID(controlID), ::ApplicationInstance(), nullptr);
@@ -1916,7 +1916,7 @@
 				ctl.widthDesired = WidthText(fontText, ctl.text) +
 						   2 * ::GetSystemMetrics(SM_CXEDGE) +
 						   2 * WidthText(fontText, GUI_TEXT(" "));
-				ctl.w = ::CreateWindowEx(0, TEXT("Button"), ctl.text.c_str(),
+				ctl.w = ::CreateWindowExW(0, WC_BUTTONW, ctl.text.c_str(),
 							 WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS |
 							 ((ctl.controlType == UserControl::ucDefaultButton) ? BS_DEFPUSHBUTTON : BS_PUSHBUTTON),
 							 left, top, ctl.widthDesired, lineHeight-1,
@@ -1925,7 +1925,7 @@
 
 			default:
 				ctl.widthDesired = WidthText(fontText, ctl.text);
-				ctl.w = ::CreateWindowEx(0, TEXT("Static"), ctl.text.c_str(),
+				ctl.w = ::CreateWindowExW(0, WC_STATICW, ctl.text.c_str(),
 							 WS_CHILD | WS_CLIPSIBLINGS | ES_RIGHT,
 							 left, top, ctl.widthDesired, lineHeight - 5,
 							 Hwnd(), HmenuID(controlID), ::ApplicationInstance(), nullptr);
Index: scite/win32/UniqueInstance.cxx
===================================================================
--- scite/win32/UniqueInstance.cxx	(版本 44)
+++ scite/win32/UniqueInstance.cxx	(版本 45)
@@ -143,7 +143,7 @@
 	if (result == 0 && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 		// WinNT / Win2000
 		std::wstring info(len, 0);	// len is actually bytes so this is twice length needed
-		::GetUserObjectInformation(desktop, UOI_NAME, &info[0], len, nullptr);
+		::GetUserObjectInformation(desktop, UOI_NAME, info.data(), len, nullptr);
 		mutexName += info;
 	}
 	// Try to set the mutex. If return false, it failed, there is already another instance.
@@ -204,7 +204,7 @@
 	cwdCmd.append(cwd.AsUTF8());
 	cwdCmd.append("\"");
 	// Defeat the "\" mangling - convert "\" to "/"
-	std::replace(cwdCmd.begin(), cwdCmd.end(), '\\', '/');
+	std::ranges::replace(cwdCmd, '\\', '/');
 	WindowCopyData(cwdCmd);
 	// Now the command line itself.
 	WindowCopyData(cmdLine);