Source.cpp

#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#define NOMINMAX
#include <windows.h>
#include <shellapi.h>
#include <shlobj.h>
#include <shobjidl.h>
#include <propkey.h>
#include <propvarutil.h>
#pragma comment(lib, "propsys.lib")
#include <shlwapi.h>
#pragma comment(lib, "shlwapi.lib")
#include <d3d11.h>
#include <dxgi1_2.h>
#include <d2d1_1.h>
#include <d2d1.h>
#include <dwrite.h>
#include <dcomp.h>
#include <initguid.h>
#include <d2d1effects.h>
#include <imm.h>
#include <commdlg.h>
#include <commctrl.h>
#include <dwmapi.h>
#include <uxtheme.h>
#include <string>
#include <vector>
#include <memory>
#include <cassert>
#include <algorithm>
#include <fstream>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <regex> 
#include <cstring>
#include "compact_enc_det/compact_enc_det.h"
#include "resource.h"
#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "dcomp.lib")
#pragma comment(lib, "dwrite.lib")
#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "imm32.lib")
#pragma comment(lib, "comdlg32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "dwmapi.lib")
#pragma comment(lib, "uxtheme.lib")
#pragma comment(lib, "ced.lib")
const std::wstring APP_VERSION = L"miu v1.0.30";
enum MiuEncoding { ENC_UTF8_NOBOM = 0, ENC_UTF8_BOM, ENC_UTF16LE, ENC_UTF16BE, ENC_LOCAL };
struct DetectResult { MiuEncoding type; UINT codePage; };
static void SwapBytes(wchar_t* buf, size_t count) {
    for (size_t i = 0; i < count; ++i) { unsigned short x = (unsigned short)buf[i]; buf[i] = (wchar_t)((x >> 8) | (x << 8)); }
}
static bool IsValidUtf8(const char* buf, size_t len) {
    if (len == 0) return true;
    size_t check_len = (len > 4096) ? 4096 : len; size_t i = 0;
    while (i < check_len) {
        unsigned char c = buf[i];
        if (c <= 0x7F) i++;
        else if (c >= 0xC2 && c <= 0xDF) { if (i + 1 >= check_len) break; if ((buf[i + 1] & 0xC0) != 0x80) return false; i += 2; }
        else if (c >= 0xE0 && c <= 0xEF) { if (i + 2 >= check_len) break; if ((buf[i + 1] & 0xC0) != 0x80 || (buf[i + 2] & 0xC0) != 0x80) return false; i += 3; }
        else if (c >= 0xF0 && c <= 0xF4) { if (i + 3 >= check_len) break; if ((buf[i + 1] & 0xC0) != 0x80 || (buf[i + 2] & 0xC0) != 0x80 || (buf[i + 3] & 0xC0) != 0x80) return false; i += 4; }
        else return false;
    }
    return true;
}
static UINT MapCedEncodingToCodePage(Encoding enc) {
    switch (enc) {
    case JAPANESE_SHIFT_JIS: return 932;
    case JAPANESE_EUC_JP:    return 51932;
    case CHINESE_GB:         return 936;
    case CHINESE_BIG5:       return 950;
    case KOREAN_EUC_KR:      return 949;
    case RUSSIAN_CP1251:     return 1251;
    case LATIN1:             return 1252;
    case ASCII_7BIT:         return CP_UTF8;
    default:                 return CP_ACP;
    }
}
static DetectResult DetectEncodingEx(const char* buf, size_t len) {
    DetectResult res = { ENC_UTF8_NOBOM, CP_UTF8 };
    if (len >= 3 && (unsigned char)buf[0] == 0xEF && (unsigned char)buf[1] == 0xBB && (unsigned char)buf[2] == 0xBF) { res.type = ENC_UTF8_BOM; return res; }
    if (len >= 2) {
        if ((unsigned char)buf[0] == 0xFF && (unsigned char)buf[1] == 0xFE) { res.type = ENC_UTF16LE; return res; }
        if ((unsigned char)buf[0] == 0xFE && (unsigned char)buf[1] == 0xFF) { res.type = ENC_UTF16BE; return res; }
    }
    if (IsValidUtf8(buf, len)) { res.type = ENC_UTF8_NOBOM; return res; }
    int bytes_consumed = 0; bool is_reliable = false; size_t ced_len = (len > 65536) ? 65536 : len;
    Encoding ced_enc = CompactEncDet::DetectEncoding(buf, static_cast<int>(ced_len), nullptr, nullptr, nullptr, UNKNOWN_ENCODING, UNKNOWN_LANGUAGE, CompactEncDet::WEB_CORPUS, false, &bytes_consumed, &is_reliable);
    res.type = ENC_LOCAL; res.codePage = MapCedEncodingToCodePage(ced_enc);
    return res;
}
static std::wstring UTF8ToW(const std::string& s) {
    if (s.empty()) return {};
    int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), NULL, 0);
    if (n <= 0) return {};
    std::wstring w; w.resize(n);
    MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), &w[0], n);
    return w;
}
static void UTF8ToW(const std::string& s, std::wstring& out) {
    out.clear();
    if (s.empty()) return;
    int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), NULL, 0);
    if (n <= 0) return;
    out.resize(n);
    MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), &out[0], n);
}
static std::string LocalToUtf8(const char* data, size_t len, UINT cp) {
    if (len == 0) return "";
    int wLen = MultiByteToWideChar(cp, 0, data, (int)len, NULL, 0);
    if (wLen <= 0) return "";
    std::vector<wchar_t> wBuf(wLen);
    MultiByteToWideChar(cp, 0, data, (int)len, wBuf.data(), wLen);
    int uLen = WideCharToMultiByte(CP_UTF8, 0, wBuf.data(), wLen, NULL, 0, NULL, NULL);
    if (uLen <= 0) return "";
    std::string ret; ret.resize(uLen);
    WideCharToMultiByte(CP_UTF8, 0, wBuf.data(), wLen, &ret[0], uLen, NULL, NULL);
    return ret;
}
static std::string Utf8ToLocal(const std::string& utf8, UINT cp) {
    if (utf8.empty()) return "";
    std::wstring w = UTF8ToW(utf8);
    int len = WideCharToMultiByte(cp, 0, w.c_str(), (int)w.size(), NULL, 0, NULL, NULL);
    if (len <= 0) return "";
    std::string ret; ret.resize(len);
    WideCharToMultiByte(cp, 0, w.c_str(), (int)w.size(), &ret[0], len, NULL, NULL);
    return ret;
}
static std::string Utf16ToUtf8(const char* data, size_t len, bool isBigEndian) {
    if (len < 2) return "";
    const wchar_t* wData = (const wchar_t*)(data + 2);
    size_t wLen = (len - 2) / sizeof(wchar_t);
    if (wLen == 0) return "";
    std::vector<wchar_t> wBuf(wData, wData + wLen);
    if (isBigEndian) SwapBytes(wBuf.data(), wBuf.size());
    int uLen = WideCharToMultiByte(CP_UTF8, 0, wBuf.data(), (int)wBuf.size(), NULL, 0, NULL, NULL);
    if (uLen <= 0) return "";
    std::string ret; ret.resize(uLen);
    WideCharToMultiByte(CP_UTF8, 0, wBuf.data(), (int)wBuf.size(), &ret[0], uLen, NULL, NULL);
    return ret;
}
static std::wstring Utf8ToUtf16(const std::string& utf8) {
    if (utf8.empty()) return L"";
    int wLen = MultiByteToWideChar(CP_UTF8, 0, utf8.data(), (int)utf8.size(), NULL, 0);
    if (wLen <= 0) return L"";
    std::wstring ret; ret.resize(wLen);
    MultiByteToWideChar(CP_UTF8, 0, utf8.data(), (int)utf8.size(), &ret[0], wLen);
    return ret;
}
static std::wstring GetResString(UINT id) {
    const wchar_t* pBuf = nullptr;
    int len = LoadStringW(GetModuleHandle(NULL), id, (LPWSTR)&pBuf, 0);
    if (len > 0 && pBuf) return std::wstring(pBuf, len);
    return L"";
}

const int MAX_RECENT_FILES = 60;
const UINT IDM_RECENT_SEP  = 0x7FF0;
const UINT IDM_RECENT_BASE = 0x8000;
const size_t MAX_RECENT_MENU_ITEMS = 20;
static std::vector<std::wstring> s_sysMenuRecentFiles;

static std::vector<std::wstring> loadRecentFiles() {
    std::vector<std::wstring> list;
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\miu\\RecentFiles", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
        for (int i = 0; i < MAX_RECENT_FILES; ++i) {
            std::wstring valName = std::to_wstring(i);
            wchar_t path[MAX_PATH];
            DWORD size = sizeof(path);
            DWORD type = 0;
            if (RegQueryValueExW(hKey, valName.c_str(), NULL, &type, (LPBYTE)path, &size) == ERROR_SUCCESS && type == REG_SZ && path[0] != L'\0') {
                list.push_back(path);
            }
        }
        RegCloseKey(hKey);
    }
    return list;
}

static void saveRecentFiles(const std::vector<std::wstring>& list) {
    HKEY hKey;
    if (RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\miu\\RecentFiles", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
        for (int i = 0; i < MAX_RECENT_FILES; ++i) {
            std::wstring valName = std::to_wstring(i);
            RegDeleteValueW(hKey, valName.c_str());
        }
        int count = std::min((int)list.size(), MAX_RECENT_FILES);
        for (int i = 0; i < count; ++i) {
            std::wstring valName = std::to_wstring(i);
            const std::wstring& path = list[i];
            RegSetValueExW(hKey, valName.c_str(), 0, REG_SZ, (const BYTE*)path.c_str(), (DWORD)((path.size() + 1) * sizeof(wchar_t)));
        }
        RegCloseKey(hKey);
    }
}

static std::wstring normalizePath(const std::wstring& p) {
    std::wstring s = p;
    while (!s.empty() && (s.front() == L' ' || s.front() == L'\"' || s.front() == L'\'')) s.erase(s.begin());
    while (!s.empty() && (s.back() == L' ' || s.back() == L'\"' || s.back() == L'\'')) s.pop_back();
    if (s.empty()) return L"";
    wchar_t fullPath[MAX_PATH];
    if (GetFullPathNameW(s.c_str(), MAX_PATH, fullPath, NULL)) {
        wchar_t longPath[MAX_PATH];
        if (GetLongPathNameW(fullPath, longPath, MAX_PATH)) {
            return longPath;
        }
        return fullPath;
    }
    return s;
}

static std::vector<std::wstring> extractRemovedPaths(IObjectArray* pRemoved) {
    std::vector<std::wstring> toRemove;
    if (!pRemoved) return toRemove;

    UINT count = 0;
    if (FAILED(pRemoved->GetCount(&count)) || count == 0) return toRemove;

    wchar_t exePath[MAX_PATH] = {};
    GetModuleFileNameW(NULL, exePath, MAX_PATH);
    std::wstring normExe = normalizePath(exePath);

    for (UINT i = 0; i < count; ++i) {
        IUnknown* pUnk = nullptr;
        if (SUCCEEDED(pRemoved->GetAt(i, IID_PPV_ARGS(&pUnk)))) {
            IShellItem* pItem = nullptr;
            if (SUCCEEDED(pUnk->QueryInterface(IID_PPV_ARGS(&pItem)))) {
                LPWSTR pszPath = nullptr;
                if (SUCCEEDED(pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszPath)) && pszPath) {
                    std::wstring norm = normalizePath(pszPath);
                    if (!norm.empty()) toRemove.push_back(norm);
                    CoTaskMemFree(pszPath);
                } else if (SUCCEEDED(pItem->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath)) && pszPath) {
                    std::wstring norm = normalizePath(pszPath);
                    if (!norm.empty()) toRemove.push_back(norm);
                    CoTaskMemFree(pszPath);
                }
                pItem->Release();
            }

            IShellLinkW* pLink = nullptr;
            if (SUCCEEDED(pUnk->QueryInterface(IID_PPV_ARGS(&pLink)))) {
                wchar_t args[MAX_PATH] = {};
                if (SUCCEEDED(pLink->GetArguments(args, MAX_PATH)) && args[0] != L'\0') {
                    std::wstring norm = normalizePath(args);
                    if (!norm.empty()) toRemove.push_back(norm);
                }
                wchar_t path[MAX_PATH] = {};
                if (SUCCEEDED(pLink->GetPath(path, MAX_PATH, NULL, 0)) && path[0] != L'\0') {
                    std::wstring norm = normalizePath(path);
                    if (!norm.empty() && _wcsicmp(norm.c_str(), normExe.c_str()) != 0) {
                        toRemove.push_back(norm);
                    }
                }
                pLink->Release();
            }
            pUnk->Release();
        }
    }
    return toRemove;
}

static void removeFromRecentFiles(const std::vector<std::wstring>& toRemove) {
    if (toRemove.empty()) return;
    std::vector<std::wstring> normRemove;
    for (const auto& r : toRemove) {
        std::wstring n = normalizePath(r);
        if (!n.empty()) normRemove.push_back(n);
    }
    if (normRemove.empty()) return;

    std::vector<std::wstring> current = loadRecentFiles();
    std::vector<std::wstring> updated;
    for (const auto& item : current) {
        std::wstring normItem = normalizePath(item);
        bool match = false;
        for (const auto& rem : normRemove) {
            if (_wcsicmp(normItem.c_str(), rem.c_str()) == 0) {
                match = true;
                break;
            }
        }
        if (!match) updated.push_back(item);
    }
    if (updated.size() != current.size()) {
        saveRecentFiles(updated);
    }
}

static void updateJumpList() {
    CoInitialize(NULL);
    ICustomDestinationList* pDestList = nullptr;
    if (FAILED(CoCreateInstance(CLSID_DestinationList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDestList)))) {
        return;
    }
    pDestList->SetAppID(L"miu");

    UINT cMinSlots = 0;
    IObjectArray* pRemoved = nullptr;
    if (FAILED(pDestList->BeginList(&cMinSlots, IID_PPV_ARGS(&pRemoved)))) {
        pDestList->Release();
        return;
    }

    if (pRemoved) {
        std::vector<std::wstring> toRemove = extractRemovedPaths(pRemoved);
        if (!toRemove.empty()) {
            removeFromRecentFiles(toRemove);
        }
        pRemoved->Release();
    }

    std::vector<std::wstring> recentList = loadRecentFiles();
    std::vector<std::wstring> validList;
    for (const auto& p : recentList) {
        DWORD attrs = GetFileAttributesW(p.c_str());
        if (attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
            validList.push_back(p);
        }
    }
    if (validList.size() != recentList.size()) {
        saveRecentFiles(validList);
    }

    UINT maxSlots = (cMinSlots > 0) ? std::min((UINT)validList.size(), cMinSlots) : (UINT)validList.size();
    if (maxSlots > 0) {
        IObjectCollection* pCollection = nullptr;
        if (SUCCEEDED(CoCreateInstance(CLSID_EnumerableObjectCollection, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pCollection)))) {
            wchar_t exePath[MAX_PATH];
            GetModuleFileNameW(NULL, exePath, MAX_PATH);

            for (UINT i = 0; i < maxSlots; ++i) {
                const std::wstring& filePath = validList[i];
                IShellLinkW* pLink = nullptr;
                if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pLink)))) {
                    pLink->SetPath(exePath);
                    std::wstring arg = L"\"" + filePath + L"\"";
                    pLink->SetArguments(arg.c_str());

                    std::wstring title = filePath;
                    size_t lastSlash = filePath.find_last_of(L"\\/");
                    if (lastSlash != std::wstring::npos) title = filePath.substr(lastSlash + 1);

                    IPropertyStore* pPropStore = nullptr;
                    if (SUCCEEDED(pLink->QueryInterface(IID_PPV_ARGS(&pPropStore)))) {
                        PROPVARIANT pv;
                        InitPropVariantFromString(title.c_str(), &pv);
                        pPropStore->SetValue(PKEY_Title, pv);
                        PropVariantClear(&pv);
                        pPropStore->Commit();
                        pPropStore->Release();
                    }
                    pLink->SetDescription(filePath.c_str());
                    pLink->SetIconLocation(exePath, 0);

                    pCollection->AddObject(pLink);
                    pLink->Release();
                }
            }

            std::wstring catName = GetResString(IDS_RECENT_FILES);
            if (catName.empty()) catName = L"Recent Files";
            pDestList->AppendCategory(catName.c_str(), pCollection);
            pCollection->Release();
        }
    }

    pDestList->CommitList();
    pDestList->Release();
}

static void syncRemovedJumpListItems() {
    CoInitialize(NULL);
    ICustomDestinationList* pDestList = nullptr;
    if (FAILED(CoCreateInstance(CLSID_DestinationList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDestList)))) {
        return;
    }
    pDestList->SetAppID(L"miu");

    IObjectArray* pRemoved = nullptr;
    if (SUCCEEDED(pDestList->GetRemovedDestinations(IID_PPV_ARGS(&pRemoved)))) {
        if (pRemoved) {
            UINT count = 0;
            if (SUCCEEDED(pRemoved->GetCount(&count)) && count > 0) {
                std::vector<std::wstring> toRemove = extractRemovedPaths(pRemoved);
                pRemoved->Release();
                pDestList->Release();

                if (!toRemove.empty()) {
                    removeFromRecentFiles(toRemove);
                }
                updateJumpList();
                return;
            }
            pRemoved->Release();
        }
    }
    pDestList->Release();
}

static void addToRecentFiles(const std::wstring& path) {
    if (path.empty()) return;
    std::wstring normalizedPath = normalizePath(path);
    if (normalizedPath.empty()) return;

    DWORD attrs = GetFileAttributesW(normalizedPath.c_str());
    if (attrs == INVALID_FILE_ATTRIBUTES || (attrs & FILE_ATTRIBUTE_DIRECTORY)) return;

    std::vector<std::wstring> list = loadRecentFiles();
    std::vector<std::wstring> updated;
    updated.push_back(normalizedPath);
    for (const auto& item : list) {
        if (_wcsicmp(item.c_str(), normalizedPath.c_str()) != 0) {
            updated.push_back(item);
        }
        if (updated.size() >= MAX_RECENT_FILES) break;
    }
    saveRecentFiles(updated);

    updateJumpList();
    SHAddToRecentDocs(SHARD_PATHW, normalizedPath.c_str());
}

enum PreferredAppMode {
    PAM_DEFAULT = 0,
    PAM_ALLOW_DARK = 1,
    PAM_FORCE_DARK = 2,
    PAM_FORCE_LIGHT = 3,
    PAM_MAX = 4
};

using fnSetPreferredAppMode = PreferredAppMode (WINAPI *)(PreferredAppMode appMode);
using fnAllowDarkModeForWindow = BOOL (WINAPI *)(HWND hWnd, BOOL allow);
using fnFlushMenuThemes = void (WINAPI *)();

static void InitDarkMode() {
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (!hUxtheme) hUxtheme = LoadLibraryExW(L"uxtheme.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
    if (hUxtheme) {
        auto pSetPreferredAppMode = (fnSetPreferredAppMode)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(135));
        if (pSetPreferredAppMode) {
            pSetPreferredAppMode(PAM_ALLOW_DARK);
        }
        auto pFlushMenuThemes = (fnFlushMenuThemes)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(136));
        if (pFlushMenuThemes) {
            pFlushMenuThemes();
        }
    }
}

static void EnableDarkModeForWindow(HWND hwnd, BOOL enable) {
    if (!hwnd) return;
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (hUxtheme) {
        auto pAllowDarkModeForWindow = (fnAllowDarkModeForWindow)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(133));
        if (pAllowDarkModeForWindow) {
            pAllowDarkModeForWindow(hwnd, enable);
        }
    }
}

static void FlushMenuThemesInternal() {
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (hUxtheme) {
        auto pFlushMenuThemes = (fnFlushMenuThemes)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(136));
        if (pFlushMenuThemes) {
            pFlushMenuThemes();
        }
    }
}

static void updateSystemMenu(HWND hwnd) {
    if (!hwnd) return;
    syncRemovedJumpListItems();
    HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
    if (!hSysMenu) return;

    DeleteMenu(hSysMenu, IDM_RECENT_SEP, MF_BYCOMMAND);
    for (UINT id = IDM_RECENT_BASE; id < IDM_RECENT_BASE + (UINT)(MAX_RECENT_MENU_ITEMS * 16); id += 16) {
        DeleteMenu(hSysMenu, id, MF_BYCOMMAND);
    }
    s_sysMenuRecentFiles.clear();

    std::vector<std::wstring> recentList = loadRecentFiles();
    size_t count = std::min(recentList.size(), MAX_RECENT_MENU_ITEMS);
    if (count > 0) {
        AppendMenuW(hSysMenu, MF_SEPARATOR, IDM_RECENT_SEP, NULL);
        for (size_t i = 0; i < count; ++i) {
            const std::wstring& path = recentList[i];
            s_sysMenuRecentFiles.push_back(path);

            wchar_t dispPath[MAX_PATH];
            if (path.length() > 60) {
                PathCompactPathExW(dispPath, path.c_str(), 60, 0);
            } else {
                wcscpy_s(dispPath, path.c_str());
            }

            std::wstring escaped;
            for (const wchar_t* p = dispPath; *p; ++p) {
                if (*p == L'&') escaped += L"&&";
                else escaped += *p;
            }

            std::wstring itemText;
            if (i < 9) {
                itemText = L"&" + std::to_wstring(i + 1) + L"  " + escaped;
            } else if (i == 9) {
                itemText = L"1&0  " + escaped;
            } else {
                itemText = std::to_wstring(i + 1) + L"  " + escaped;
            }

            UINT itemID = IDM_RECENT_BASE + (UINT)(i * 16);
            AppendMenuW(hSysMenu, MF_STRING, itemID, itemText.c_str());
        }
    }
}

static std::string WToUTF8(const std::wstring& w) {
    if (w.empty()) return {};
    int n = WideCharToMultiByte(CP_UTF8, 0, w.data(), (int)w.size(), NULL, 0, NULL, NULL);
    if (n <= 0) return {};
    std::string s; s.resize(n);
    WideCharToMultiByte(CP_UTF8, 0, w.data(), (int)w.size(), &s[0], n, NULL, NULL);
    return s;
}
static std::string UnescapeString(const std::string& s, const std::string& newline) {
    std::string out; out.reserve(s.size());
    for (size_t i = 0; i < s.size(); ++i) {
        if (s[i] == '\\' && i + 1 < s.size()) {
            switch (s[i + 1]) {
            case 'n': out += newline; break;
            case 'r': out += '\r'; break;
            case 't': out += '\t'; break;
            case '\\': out += '\\'; break;
            default: out += s[i]; out += s[i + 1]; break;
            }
            i++;
        }
        else out += s[i];
    }
    return out;
}
struct Piece { bool isOriginal; size_t start; size_t len; };
struct PieceTable {
    const char* origPtr = nullptr; size_t origSize = 0; std::string addBuf; std::vector<Piece> pieces;
    void initFromFile(const char* data, size_t size) { origPtr = data; origSize = size; pieces.clear(); addBuf.clear(); if (size > 0) pieces.push_back({ true, 0, size }); }
    void initEmpty() { origPtr = nullptr; origSize = 0; pieces.clear(); addBuf.clear(); }
    size_t length() const { size_t s = 0; for (auto& p : pieces) s += p.len; return s; }
    std::string getRange(size_t pos, size_t count) const {
        std::string out; getRange(pos, count, out); return out;
    }
    void getRange(size_t pos, size_t count, std::string& out) const {
        out.clear(); if (count == 0) return;
        out.reserve(count); size_t cur = 0;
        for (const auto& p : pieces) {
            if (cur + p.len <= pos) { cur += p.len; continue; }
            size_t localStart = (pos > cur) ? (pos - cur) : 0; size_t take = std::min(p.len - localStart, count - out.size());
            if (take == 0) break;
            if (p.isOriginal) out.append(origPtr + p.start + localStart, take); else out.append(addBuf.data() + p.start + localStart, take);
            if (out.size() >= count) break; cur += p.len;
        }
    }
    void insert(size_t pos, const std::string& s) {
        if (s.empty()) return; size_t cur = 0; size_t idx = 0;
        while (idx < pieces.size() && cur + pieces[idx].len < pos) { cur += pieces[idx].len; ++idx; }
        if (idx < pieces.size()) {
            Piece p = pieces[idx]; size_t offsetInPiece = pos - cur;
            if (offsetInPiece > 0 && offsetInPiece < p.len) { pieces[idx] = { p.isOriginal, p.start, offsetInPiece }; pieces.insert(pieces.begin() + idx + 1, { p.isOriginal, p.start + offsetInPiece, p.len - offsetInPiece }); idx++; }
            else if (offsetInPiece == p.len) idx++;
        }
        else idx = pieces.size();
        size_t addStart = addBuf.size(); addBuf.append(s); pieces.insert(pieces.begin() + idx, { false, addStart, s.size() }); coalesceAround(idx);
    }
    void erase(size_t pos, size_t count) {
        if (count == 0) return; size_t cur = 0; size_t idx = 0;
        while (idx < pieces.size() && cur + pieces[idx].len <= pos) { cur += pieces[idx].len; ++idx; }
        size_t remaining = count; if (idx >= pieces.size()) return;
        if (pos > cur) { Piece p = pieces[idx]; size_t leftLen = pos - cur; pieces[idx] = { p.isOriginal, p.start, leftLen }; pieces.insert(pieces.begin() + idx + 1, { p.isOriginal, p.start + leftLen, p.len - leftLen }); idx++; }
        while (idx < pieces.size() && remaining > 0) { if (pieces[idx].len <= remaining) { remaining -= pieces[idx].len; pieces.erase(pieces.begin() + idx); } else { pieces[idx].start += remaining; pieces[idx].len -= remaining; remaining = 0; } }
        coalesceAround(idx > 0 ? idx - 1 : 0);
    }
    void coalesceAround(size_t idx) {
        if (pieces.empty()) return; if (idx >= pieces.size()) idx = pieces.size() - 1;
        if (idx > 0) { Piece& a = pieces[idx - 1]; Piece& b = pieces[idx]; if (!a.isOriginal && !b.isOriginal && (a.start + a.len == b.start)) { a.len += b.len; pieces.erase(pieces.begin() + idx); idx--; } }
        if (idx + 1 < pieces.size()) { Piece& a = pieces[idx]; Piece& b = pieces[idx + 1]; if (!a.isOriginal && !b.isOriginal && (a.start + a.len == b.start)) { a.len += b.len; pieces.erase(pieces.begin() + idx + 1); } }
    }
    char charAt(size_t pos) const {
        size_t cur = 0;
        for (const auto& p : pieces) { if (cur + p.len <= pos) { cur += p.len; continue; } size_t local = pos - cur; if (p.isOriginal) return origPtr[p.start + local]; else return addBuf[p.start + local]; }
        return ' ';
    }
};
struct Cursor { size_t head; size_t anchor; float desiredX; bool affinity = false; size_t start() const { return std::min(head, anchor); } size_t end() const { return std::max(head, anchor); } bool hasSelection() const { return head != anchor; } void clearSelection() { anchor = head; } };
struct EditOp { enum Type { Insert, Erase } type; size_t pos; std::string text; };
struct EditBatch { std::vector<EditOp> ops; std::vector<Cursor> beforeCursors; std::vector<Cursor> afterCursors; };
struct UndoManager {
    std::vector<EditBatch> undoStack; std::vector<EditBatch> redoStack; int savePoint = 0;
    void clear() { undoStack.clear(); redoStack.clear(); savePoint = 0; }
    void markSaved() { savePoint = (int)undoStack.size(); }
    bool isModified() const { return (int)undoStack.size() != savePoint; }
    void push(const EditBatch& batch) { if (savePoint > (int)undoStack.size()) savePoint = -1; undoStack.push_back(batch); redoStack.clear(); }
    bool canUndo() const { return !undoStack.empty(); }
    bool canRedo() const { return !redoStack.empty(); }
    EditBatch popUndo() { EditBatch e = undoStack.back(); undoStack.pop_back(); redoStack.push_back(e); return e; }
    EditBatch popRedo() { EditBatch e = redoStack.back(); redoStack.pop_back(); undoStack.push_back(e); return e; }
};
struct MappedFile {
    HANDLE hFile = INVALID_HANDLE_VALUE; HANDLE hMap = NULL; const char* ptr = nullptr; size_t size = 0;
    std::vector<char> heapBuffer; bool isMapped = false;
    static const size_t THRESHOLD = 50 * 1024 * 1024; // 50MB
    bool open(const wchar_t* path) {
        hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hFile == INVALID_HANDLE_VALUE) return false;
        LARGE_INTEGER li; if (!GetFileSizeEx(hFile, &li)) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return false; }
        size = (size_t)li.QuadPart;
        if (size == 0) { ptr = nullptr; CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return true; }
        if (size >= THRESHOLD) {
            hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
            if (!hMap) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return false; }
            ptr = (const char*)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0); isMapped = true; return !!ptr;
        }
        else {
            heapBuffer.resize(size); DWORD bytesRead = 0;
            if (ReadFile(hFile, heapBuffer.data(), (DWORD)size, &bytesRead, NULL) && bytesRead == size) {
                ptr = heapBuffer.data(); isMapped = false; CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return true;
            }
            CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return false;
        }
    }
    void close() {
        if (isMapped && ptr) { UnmapViewOfFile(ptr); ptr = nullptr; }
        if (hMap) { CloseHandle(hMap); hMap = NULL; }
        if (hFile != INVALID_HANDLE_VALUE) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; }
        heapBuffer.clear(); ptr = nullptr; size = 0; isMapped = false;
    }
    ~MappedFile() { close(); }
};
#include <unordered_set>
#include <unordered_map>
#include <cwctype>
struct SyntaxDef {
    std::unordered_set<std::string> keywords;
    std::unordered_set<std::string> literals;
    std::string commentLine;
    std::string commentBlockStart;
    std::string commentBlockEnd;
    std::vector<std::pair<std::regex, D2D1::ColorF>> regexes;
};
class CustomTextRenderer : public IDWriteTextRenderer {
public:
    ID2D1DeviceContext* rend;
    ID2D1SolidColorBrush* defaultBrush;
    CustomTextRenderer(ID2D1DeviceContext* r, ID2D1SolidColorBrush* b) : rend(r), defaultBrush(b) {}
    IFACEMETHOD(DrawGlyphRun)(void*, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_MEASURING_MODE measuringMode, DWRITE_GLYPH_RUN const* glyphRun, DWRITE_GLYPH_RUN_DESCRIPTION const*, IUnknown* clientDrawingEffect) override {
        ID2D1SolidColorBrush* brush = defaultBrush;
        if (clientDrawingEffect) clientDrawingEffect->QueryInterface(__uuidof(ID2D1SolidColorBrush), (void**)&brush);
        rend->DrawGlyphRun(D2D1::Point2F(baselineOriginX, baselineOriginY), glyphRun, brush, measuringMode);
        if (clientDrawingEffect && brush != defaultBrush) brush->Release();
        return S_OK;
    }
    IFACEMETHOD(DrawUnderline)(void*, FLOAT, FLOAT, DWRITE_UNDERLINE const*, IUnknown*) override { return E_NOTIMPL; }
    IFACEMETHOD(DrawStrikethrough)(void*, FLOAT, FLOAT, DWRITE_STRIKETHROUGH const*, IUnknown*) override { return E_NOTIMPL; }
    IFACEMETHOD(DrawInlineObject)(void*, FLOAT, FLOAT, IDWriteInlineObject*, BOOL, BOOL, IUnknown*) override { return E_NOTIMPL; }
    IFACEMETHOD(IsPixelSnappingDisabled)(void*, BOOL* disabled) override { *disabled = FALSE; return S_OK; }
    IFACEMETHOD(GetCurrentTransform)(void*, DWRITE_MATRIX* m) override { rend->GetTransform((D2D1_MATRIX_3X2_F*)m); return S_OK; }
    IFACEMETHOD(GetPixelsPerDip)(void*, FLOAT* pixelsPerDip) override { *pixelsPerDip = 1.0f; return S_OK; }
    IFACEMETHODIMP_(ULONG) AddRef() { return 1; }
    IFACEMETHODIMP_(ULONG) Release() { return 1; }
    IFACEMETHODIMP QueryInterface(REFIID riid, void** ppv) {
        if (riid == __uuidof(IDWriteTextRenderer) || riid == __uuidof(IDWritePixelSnapping) || riid == __uuidof(IUnknown)) { *ppv = this; return S_OK; }
        *ppv = NULL; return E_NOINTERFACE;
    }
};
struct CustomDialogButton {
    int id = 0;
    std::wstring text;
    int width = 0;
    int height = 0;
    int x = 0;
    int y = 0;
    HWND hwnd = NULL;
    bool isDefault = false;
    bool isCancel = false;
};

struct CustomTaskDialogData {
    HWND hDlg = NULL;
    HWND hwndParent = NULL;
    bool isDarkMode = false;
    UINT dpi = 96;

    std::wstring title;
    std::wstring instruction;
    std::wstring content;
    bool hasContent = false;

    HICON hIcon = NULL;
    int iconSize = 32;

    HFONT hFontInstruction = NULL;
    HFONT hFontContent = NULL;
    HFONT hFontButton = NULL;

    int padX = 0;
    int padY = 0;
    int textLeft = 0;
    int iconTextGap = 0;
    int textGap = 0;

    int instW = 0;
    int instH = 0;
    int contentW = 0;
    int contentH = 0;

    int upperHeight = 0;
    int lowerHeight = 0;
    int clientWidth = 0;
    int clientHeight = 0;

    std::vector<CustomDialogButton> buttons;
    int resultId = 0;
    int cancelId = IDCANCEL;
    HWND hDefaultBtn = NULL;
};

static std::wstring GetStandardButtonText(int id) {
    UINT resId = 0;
    switch (id) {
    case IDOK: resId = IDS_BTN_OK; break;
    case IDYES: resId = IDS_BTN_YES; break;
    case IDNO: resId = IDS_BTN_NO; break;
    case IDCANCEL: resId = IDS_BTN_CANCEL; break;
    }
    if (resId != 0) {
        std::wstring s = GetResString(resId);
        if (!s.empty()) return s;
    }
    switch (id) {
    case IDOK: return L"OK";
    case IDYES: return L"縺ｯ縺・&Y)";
    case IDNO: return L"縺・＞縺・&N)";
    case IDCANCEL: return L"繧ｭ繝｣繝ｳ繧ｻ繝ｫ";
    case IDRETRY: return L"蜀崎ｩｦ陦・&R)";
    case IDCLOSE: return L"髢峨§繧・&C)";
    default: return L"";
    }
}

static LRESULT CALLBACK DarkButtonSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
    CustomTaskDialogData* pData = (CustomTaskDialogData*)dwRefData;
    switch (uMsg) {
    case WM_MOUSEMOVE: {
        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        if (!isHovered) {
            SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)1);
            TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT), TME_LEAVE, hWnd, 0 };
            TrackMouseEvent(&tme);
            InvalidateRect(hWnd, NULL, FALSE);
        }
        break;
    }
    case WM_MOUSELEAVE: {
        SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)0);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_LBUTTONDOWN: {
        SetPropW(hWnd, L"MiuPressed", (HANDLE)(INT_PTR)1);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_LBUTTONUP: {
        SetPropW(hWnd, L"MiuPressed", (HANDLE)(INT_PTR)0);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_SETFOCUS:
    case WM_KILLFOCUS: {
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_ERASEBKGND:
        return 1;
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RECT rc;
        GetClientRect(hWnd, &rc);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBmp = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
        HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, memBmp);

        COLORREF parentBg = (COLORREF)(INT_PTR)GetPropW(hWnd, L"MiuParentBg");
        if (parentBg == 0) parentBg = RGB(32, 32, 32);
        HBRUSH hbrBg = CreateSolidBrush(parentBg);
        FillRect(memDC, &rc, hbrBg);
        DeleteObject(hbrBg);

        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        BOOL isPressed = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuPressed");
        if (SendMessageW(hWnd, BM_GETSTATE, 0, 0) & BST_PUSHED) {
            isPressed = TRUE;
        }
        bool isFocused = (GetFocus() == hWnd);
        bool isDefault = (GetWindowLongPtrW(hWnd, GWL_STYLE) & BS_DEFPUSHBUTTON) != 0;

        COLORREF bgCol;
        COLORREF borderCol;
        if (isPressed) {
            bgCol = RGB(40, 40, 40);
            borderCol = RGB(80, 80, 80);
        } else if (isHovered) {
            bgCol = RGB(65, 65, 65);
            borderCol = RGB(120, 120, 120);
        } else {
            bgCol = RGB(50, 50, 50);
            borderCol = isDefault ? RGB(0, 120, 215) : RGB(85, 85, 85);
        }

        if (isFocused && !isPressed) {
            borderCol = RGB(76, 194, 255);
        }

        HBRUSH hbrBtn = CreateSolidBrush(bgCol);
        HPEN hPen = CreatePen(PS_SOLID, 1, borderCol);
        HBRUSH oldBrush = (HBRUSH)SelectObject(memDC, hbrBtn);
        HPEN oldPen = (HPEN)SelectObject(memDC, hPen);

        UINT dpi = pData ? pData->dpi : GetDpiForWindow(hWnd);
        if (dpi == 0) dpi = 96;
        int radius = MulDiv(4, dpi, 96);
        RoundRect(memDC, rc.left, rc.top, rc.right, rc.bottom, radius * 2, radius * 2);

        SelectObject(memDC, oldBrush);
        SelectObject(memDC, oldPen);
        DeleteObject(hbrBtn);
        DeleteObject(hPen);

        WCHAR text[128];
        GetWindowTextW(hWnd, text, ARRAYSIZE(text));
        HFONT hFont = pData ? pData->hFontButton : (HFONT)SendMessageW(hWnd, WM_GETFONT, 0, 0);
        if (hFont) SelectObject(memDC, hFont);
        SetBkMode(memDC, TRANSPARENT);
        SetTextColor(memDC, isPressed ? RGB(200, 200, 200) : RGB(255, 255, 255));
        DrawTextW(memDC, text, -1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        BitBlt(hdc, 0, 0, rc.right, rc.bottom, memDC, 0, 0, SRCCOPY);
        SelectObject(memDC, oldBmp);
        DeleteObject(memBmp);
        DeleteDC(memDC);

        EndPaint(hWnd, &ps);
        return 0;
    }
    case WM_NCDESTROY:
        RemovePropW(hWnd, L"MiuHover");
        RemovePropW(hWnd, L"MiuPressed");
        RemovePropW(hWnd, L"MiuParentBg");
        RemoveWindowSubclass(hWnd, DarkButtonSubclassProc, uIdSubclass);
        break;
    }
    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

static LRESULT CALLBACK DarkCheckboxSubclass(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
    switch (uMsg) {
    case WM_MOUSEMOVE: {
        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        if (!isHovered) {
            SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)1);
            TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT), TME_LEAVE, hWnd, 0 };
            TrackMouseEvent(&tme);
            InvalidateRect(hWnd, NULL, FALSE);
        }
        break;
    }
    case WM_MOUSELEAVE: {
        SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)0);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_LBUTTONUP:
    case WM_KEYUP: {
        LRESULT res = DefSubclassProc(hWnd, uMsg, wParam, lParam);
        InvalidateRect(hWnd, NULL, FALSE);
        return res;
    }
    case BM_SETCHECK: {
        LRESULT res = DefSubclassProc(hWnd, uMsg, wParam, lParam);
        InvalidateRect(hWnd, NULL, FALSE);
        return res;
    }
    case WM_SETFOCUS:
    case WM_KILLFOCUS: {
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_ERASEBKGND:
        return 1;
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RECT rc;
        GetClientRect(hWnd, &rc);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBmp = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
        HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, memBmp);

        COLORREF parentBg = (COLORREF)(INT_PTR)GetPropW(hWnd, L"MiuParentBg");
        if (parentBg == 0) parentBg = RGB(32, 32, 32);
        HBRUSH hbrBg = CreateSolidBrush(parentBg);
        FillRect(memDC, &rc, hbrBg);
        DeleteObject(hbrBg);

        BOOL isChecked = (SendMessageW(hWnd, BM_GETCHECK, 0, 0) == BST_CHECKED);
        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        bool isFocused = (GetFocus() == hWnd);

        UINT dpi = GetDpiForWindow(hWnd);
        if (dpi == 0) dpi = 96;

        int boxSize = MulDiv(14, dpi, 96);
        int boxY = (rc.bottom - boxSize) / 2;
        int boxX = 0;

        RECT rcBox = { boxX, boxY, boxX + boxSize, boxY + boxSize };

        COLORREF boxBg = isChecked ? (isHovered ? RGB(0, 140, 240) : RGB(0, 120, 215)) : (isHovered ? RGB(45, 45, 45) : RGB(35, 35, 35));
        COLORREF boxBorder = isFocused ? RGB(76, 194, 255) : (isHovered ? RGB(140, 140, 140) : RGB(100, 100, 100));

        HBRUSH hbrBox = CreateSolidBrush(boxBg);
        HPEN hPenBox = CreatePen(PS_SOLID, 1, boxBorder);
        HBRUSH oldBr = (HBRUSH)SelectObject(memDC, hbrBox);
        HPEN oldP = (HPEN)SelectObject(memDC, hPenBox);

        int r = MulDiv(2, dpi, 96);
        RoundRect(memDC, rcBox.left, rcBox.top, rcBox.right, rcBox.bottom, r * 2, r * 2);

        SelectObject(memDC, oldBr);
        SelectObject(memDC, oldP);
        DeleteObject(hbrBox);
        DeleteObject(hPenBox);

        if (isChecked) {
            HPEN hCheckPen = CreatePen(PS_SOLID, MulDiv(2, dpi, 96), RGB(255, 255, 255));
            HPEN oldCp = (HPEN)SelectObject(memDC, hCheckPen);

            int x1 = rcBox.left + MulDiv(3, dpi, 96);
            int y1 = rcBox.top + MulDiv(7, dpi, 96);
            int x2 = rcBox.left + MulDiv(6, dpi, 96);
            int y2 = rcBox.top + MulDiv(10, dpi, 96);
            int x3 = rcBox.left + MulDiv(11, dpi, 96);
            int y3 = rcBox.top + MulDiv(4, dpi, 96);

            MoveToEx(memDC, x1, y1, NULL);
            LineTo(memDC, x2, y2);
            LineTo(memDC, x3, y3);

            SelectObject(memDC, oldCp);
            DeleteObject(hCheckPen);
        }

        WCHAR text[128];
        GetWindowTextW(hWnd, text, ARRAYSIZE(text));
        HFONT hFont = (HFONT)SendMessageW(hWnd, WM_GETFONT, 0, 0);
        if (hFont) SelectObject(memDC, hFont);
        SetBkMode(memDC, TRANSPARENT);
        SetTextColor(memDC, RGB(230, 230, 230));

        RECT rcText = { rcBox.right + MulDiv(6, dpi, 96), 0, rc.right, rc.bottom };
        DrawTextW(memDC, text, -1, &rcText, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

        if (isFocused) {
            RECT rcFocus = rcText;
            DrawTextW(memDC, text, -1, &rcFocus, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE);
            InflateRect(&rcFocus, 1, 1);
            DrawFocusRect(memDC, &rcFocus);
        }

        BitBlt(hdc, 0, 0, rc.right, rc.bottom, memDC, 0, 0, SRCCOPY);
        SelectObject(memDC, oldBmp);
        DeleteObject(memBmp);
        DeleteDC(memDC);

        EndPaint(hWnd, &ps);
        return 0;
    }
    case WM_NCDESTROY:
        RemovePropW(hWnd, L"MiuHover");
        RemovePropW(hWnd, L"MiuParentBg");
        RemoveWindowSubclass(hWnd, DarkCheckboxSubclass, uIdSubclass);
        break;
    }
    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

static void ApplyDialogTheme(HWND hDlg, bool isDarkMode) {
    if (!hDlg) return;
    BOOL dark = isDarkMode;
    DwmSetWindowAttribute(hDlg, 20 /* DWMWA_USE_IMMERSIVE_DARK_MODE */, &dark, sizeof(dark));
    EnableDarkModeForWindow(hDlg, isDarkMode);

    HWND hChild = GetWindow(hDlg, GW_CHILD);
    while (hChild) {
        WCHAR className[64];
        GetClassNameW(hChild, className, ARRAYSIZE(className));
        LONG_PTR style = GetWindowLongPtrW(hChild, GWL_STYLE);

        if (_wcsicmp(className, L"Button") == 0) {
            DWORD btnType = (style & BS_TYPEMASK);
            if (btnType == BS_CHECKBOX || btnType == BS_AUTOCHECKBOX) {
                if (isDarkMode) {
                    SetWindowSubclass(hChild, DarkCheckboxSubclass, (UINT_PTR)GetDlgCtrlID(hChild), 0);
                } else {
                    RemoveWindowSubclass(hChild, DarkCheckboxSubclass, (UINT_PTR)GetDlgCtrlID(hChild));
                    SetWindowTheme(hChild, NULL, NULL);
                }
            } else if (btnType == BS_PUSHBUTTON || btnType == BS_DEFPUSHBUTTON) {
                if (isDarkMode) {
                    SetWindowSubclass(hChild, DarkButtonSubclassProc, (UINT_PTR)GetDlgCtrlID(hChild), 0);
                } else {
                    RemoveWindowSubclass(hChild, DarkButtonSubclassProc, (UINT_PTR)GetDlgCtrlID(hChild));
                    SetWindowTheme(hChild, NULL, NULL);
                }
            }
        } else if (_wcsicmp(className, L"Edit") == 0) {
            if (isDarkMode) {
                SetWindowTheme(hChild, L"DarkMode_CFD", NULL);
            } else {
                SetWindowTheme(hChild, NULL, NULL);
            }
        }
        hChild = GetWindow(hChild, GW_HWNDNEXT);
    }
}

static LRESULT CALLBACK CustomTaskDialogWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
    CustomTaskDialogData* pData = (CustomTaskDialogData*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);

    switch (message) {
    case WM_NCCREATE: {
        CREATESTRUCTW* cs = (CREATESTRUCTW*)lParam;
        pData = (CustomTaskDialogData*)cs->lpCreateParams;
        pData->hDlg = hWnd;
        SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pData);
        return DefWindowProcW(hWnd, message, wParam, lParam);
    }
    case WM_CREATE: {
        if (!pData) return -1;
        if (pData->isDarkMode) {
            BOOL dark = TRUE;
            DwmSetWindowAttribute(hWnd, 20 /* DWMWA_USE_IMMERSIVE_DARK_MODE */, &dark, sizeof(dark));
            EnableDarkModeForWindow(hWnd, TRUE);
        }
        for (auto& btn : pData->buttons) {
            DWORD btnStyle = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
            if (btn.isDefault) btnStyle |= BS_DEFPUSHBUTTON;
            else btnStyle |= BS_PUSHBUTTON;

            btn.hwnd = CreateWindowExW(
                0, L"BUTTON", btn.text.c_str(),
                btnStyle,
                btn.x, btn.y, btn.width, btn.height,
                hWnd, (HMENU)(INT_PTR)btn.id,
                GetModuleHandle(NULL), NULL
            );
            SendMessageW(btn.hwnd, WM_SETFONT, (WPARAM)pData->hFontButton, TRUE);

            if (btn.isDefault) {
                pData->hDefaultBtn = btn.hwnd;
            }

            if (pData->isDarkMode) {
                SetPropW(btn.hwnd, L"MiuParentBg", (HANDLE)(INT_PTR)RGB(43, 43, 43));
                SetWindowSubclass(btn.hwnd, DarkButtonSubclassProc, (UINT_PTR)btn.id, (DWORD_PTR)pData);
            }
        }
        return 0;
    }
    case WM_ERASEBKGND:
        return 1;
    case WM_PRINTCLIENT:
    case WM_PAINT: {
        if (!pData) break;
        PAINTSTRUCT ps;
        HDC hdc = (message == WM_PRINTCLIENT) ? (HDC)wParam : BeginPaint(hWnd, &ps);
        RECT rcClient;
        GetClientRect(hWnd, &rcClient);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBmp = CreateCompatibleBitmap(hdc, rcClient.right, rcClient.bottom);
        HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, memBmp);

        COLORREF upperBgCol  = pData->isDarkMode ? RGB(32, 32, 32) : RGB(255, 255, 255);
        COLORREF lowerBgCol  = pData->isDarkMode ? RGB(43, 43, 43) : RGB(240, 240, 240);
        COLORREF sepCol      = pData->isDarkMode ? RGB(56, 56, 56) : RGB(223, 223, 223);
        COLORREF instTextCol = pData->isDarkMode ? RGB(76, 194, 255) : RGB(0, 51, 153);
        COLORREF contTextCol = pData->isDarkMode ? RGB(224, 224, 224) : RGB(0, 0, 0);

        RECT rcUpper = { 0, 0, rcClient.right, pData->upperHeight };
        HBRUSH hbrUpper = CreateSolidBrush(upperBgCol);
        FillRect(memDC, &rcUpper, hbrUpper);
        DeleteObject(hbrUpper);

        RECT rcSep = { 0, pData->upperHeight, rcClient.right, pData->upperHeight + 1 };
        HBRUSH hbrSep = CreateSolidBrush(sepCol);
        FillRect(memDC, &rcSep, hbrSep);
        DeleteObject(hbrSep);

        RECT rcLower = { 0, pData->upperHeight + 1, rcClient.right, rcClient.bottom };
        HBRUSH hbrLower = CreateSolidBrush(lowerBgCol);
        FillRect(memDC, &rcLower, hbrLower);
        DeleteObject(hbrLower);

        if (pData->hIcon) {
            DrawIconEx(memDC, pData->padX, pData->padY, pData->hIcon, pData->iconSize, pData->iconSize, 0, NULL, DI_NORMAL);
        }

        SetBkMode(memDC, TRANSPARENT);
        SelectObject(memDC, pData->hFontInstruction);
        SetTextColor(memDC, instTextCol);
        RECT rcInst = { pData->textLeft, pData->padY, rcClient.right - pData->padX, pData->padY + pData->instH };
        DrawTextW(memDC, pData->instruction.c_str(), -1, &rcInst, DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX | DT_LEFT);

        if (pData->hasContent) {
            SelectObject(memDC, pData->hFontContent);
            SetTextColor(memDC, contTextCol);
            int contY = pData->padY + pData->instH + pData->textGap;
            RECT rcCont = { pData->textLeft, contY, rcClient.right - pData->padX, contY + pData->contentH };
            DrawTextW(memDC, pData->content.c_str(), -1, &rcCont, DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX | DT_LEFT);
        }

        BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom, memDC, 0, 0, SRCCOPY);
        SelectObject(memDC, oldBmp);
        DeleteObject(memBmp);
        DeleteDC(memDC);

        if (message == WM_PAINT) EndPaint(hWnd, &ps);
        return 0;
    }
    case WM_CTLCOLORBTN:
    case WM_CTLCOLORDLG:
    case WM_CTLCOLORSTATIC: {
        if (!pData) break;
        if (pData->isDarkMode) {
            static HBRUSH hbrDarkLower = CreateSolidBrush(RGB(43, 43, 43));
            SetBkColor((HDC)wParam, RGB(43, 43, 43));
            SetTextColor((HDC)wParam, RGB(255, 255, 255));
            return (LRESULT)hbrDarkLower;
        } else {
            return (LRESULT)GetSysColorBrush(COLOR_BTNFACE);
        }
    }
    case WM_COMMAND: {
        if (!pData) break;
        int id = LOWORD(wParam);
        if (HIWORD(wParam) == BN_CLICKED || lParam != 0) {
            pData->resultId = id;
            DestroyWindow(hWnd);
            return 0;
        }
        break;
    }
    case WM_CLOSE: {
        if (!pData) break;
        pData->resultId = pData->cancelId;
        DestroyWindow(hWnd);
        return 0;
    }
    }
    return DefWindowProcW(hWnd, message, wParam, lParam);
}

static int ShowCustomTaskDialog(HWND hwndParent, const wchar_t* title, const wchar_t* instruction, const wchar_t* content, TASKDIALOG_COMMON_BUTTON_FLAGS buttons, PCWSTR icon, bool isDarkMode) {
    CustomTaskDialogData data;
    data.hwndParent = hwndParent;
    data.isDarkMode = isDarkMode;
    data.title = title ? title : L"";
    data.instruction = instruction ? instruction : L"";
    data.content = content ? content : L"";
    data.hasContent = !data.content.empty();

    static const wchar_t* s_className = L"MiuCustomTaskDialog";
    static bool s_registered = false;
    if (!s_registered) {
        WNDCLASSEXW wc = { sizeof(WNDCLASSEXW) };
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = CustomTaskDialogWndProc;
        wc.hInstance = GetModuleHandle(NULL);
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = NULL;
        wc.lpszClassName = s_className;
        RegisterClassExW(&wc);
        s_registered = true;
    }

    UINT dpi = 96;
    if (hwndParent) dpi = GetDpiForWindow(hwndParent);
    if (dpi == 0) {
        HDC hdcScreen = GetDC(NULL);
        dpi = GetDeviceCaps(hdcScreen, LOGPIXELSX);
        ReleaseDC(NULL, hdcScreen);
    }
    if (dpi == 0) dpi = 96;

    data.dpi = dpi;
    data.padX = MulDiv(18, dpi, 96);
    data.padY = MulDiv(18, dpi, 96);
    data.iconTextGap = MulDiv(16, dpi, 96);
    data.textGap = MulDiv(10, dpi, 96);
    data.iconSize = MulDiv(32, dpi, 96);

    LPCWSTR sysIconId = NULL;
    if (icon == TD_WARNING_ICON || icon == (PCWSTR)MAKEINTRESOURCEW(32515)) {
        sysIconId = IDI_WARNING;
    } else if (icon == TD_ERROR_ICON || icon == (PCWSTR)MAKEINTRESOURCEW(32513)) {
        sysIconId = IDI_ERROR;
    } else if (icon == TD_INFORMATION_ICON || icon == (PCWSTR)MAKEINTRESOURCEW(32516)) {
        sysIconId = IDI_INFORMATION;
    } else if (icon == TD_SHIELD_ICON) {
        sysIconId = IDI_SHIELD;
    } else if (IS_INTRESOURCE(icon)) {
        sysIconId = (LPCWSTR)icon;
    }

    if (sysIconId) {
        data.hIcon = (HICON)LoadImageW(NULL, sysIconId, IMAGE_ICON, data.iconSize, data.iconSize, LR_SHARED);
        if (!data.hIcon) {
            data.hIcon = LoadIconW(NULL, sysIconId);
        }
    }

    LOGFONTW lfInst = {};
    LOGFONTW lfContent = {};
    LOGFONTW lfBtn = {};

    using fnOpenThemeDataForDpi = HTHEME(WINAPI*)(HWND, LPCWSTR, UINT);
    HMODULE hUx = GetModuleHandleW(L"uxtheme.dll");
    if (!hUx) hUx = LoadLibraryExW(L"uxtheme.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
    fnOpenThemeDataForDpi pfnOpenThemeDataForDpi = hUx ? (fnOpenThemeDataForDpi)GetProcAddress(hUx, "OpenThemeDataForDpi") : nullptr;

    HTHEME hTheme = pfnOpenThemeDataForDpi ? pfnOpenThemeDataForDpi(NULL, L"TaskDialog", dpi) : (hUx ? OpenThemeData(NULL, L"TaskDialog") : NULL);
    if (hTheme) {
        GetThemeFont(hTheme, NULL, 2 /* TDLG_MAININSTRUCTIONPANE */, 0, 210 /* TMT_FONT */, &lfInst);
        GetThemeFont(hTheme, NULL, 4 /* TDLG_CONTENTPANE */, 0, 210 /* TMT_FONT */, &lfContent);
        GetThemeFont(hTheme, NULL, 10 /* TDLG_BUTTONSECTION */, 0, 210 /* TMT_FONT */, &lfBtn);
        CloseThemeData(hTheme);
    }

    if (lfInst.lfFaceName[0] == L'\0') {
        NONCLIENTMETRICSW ncm = { sizeof(ncm) };
        SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
        lfInst = ncm.lfMessageFont;
        lfInst.lfHeight = MulDiv(lfInst.lfHeight, 4, 3);
        lfContent = ncm.lfMessageFont;
        lfBtn = ncm.lfMessageFont;
    }

    if (!pfnOpenThemeDataForDpi && dpi != 96) {
        lfInst.lfHeight = MulDiv(lfInst.lfHeight, dpi, 96);
        lfContent.lfHeight = MulDiv(lfContent.lfHeight, dpi, 96);
        lfBtn.lfHeight = MulDiv(lfBtn.lfHeight, dpi, 96);
    }

    data.hFontInstruction = CreateFontIndirectW(&lfInst);
    data.hFontContent = CreateFontIndirectW(&lfContent);
    data.hFontButton = CreateFontIndirectW(&lfBtn);

    if (buttons & TDCBF_YES_BUTTON) {
        data.buttons.push_back({ IDYES, GetStandardButtonText(IDYES) });
    }
    if (buttons & TDCBF_NO_BUTTON) {
        data.buttons.push_back({ IDNO, GetStandardButtonText(IDNO) });
    }
    if (buttons & TDCBF_OK_BUTTON) {
        data.buttons.push_back({ IDOK, GetStandardButtonText(IDOK) });
    }
    if (buttons & TDCBF_RETRY_BUTTON) {
        data.buttons.push_back({ IDRETRY, GetStandardButtonText(IDRETRY) });
    }
    if (buttons & TDCBF_CANCEL_BUTTON) {
        data.buttons.push_back({ IDCANCEL, GetStandardButtonText(IDCANCEL), 0, 0, 0, 0, NULL, false, true });
    }
    if (buttons & TDCBF_CLOSE_BUTTON) {
        data.buttons.push_back({ IDCLOSE, GetStandardButtonText(IDCLOSE) });
    }

    if (data.buttons.empty()) {
        data.buttons.push_back({ IDOK, GetStandardButtonText(IDOK) });
    }

    data.buttons[0].isDefault = true;

    data.cancelId = IDCANCEL;
    bool hasCancel = false;
    for (auto& btn : data.buttons) {
        if (btn.id == IDCANCEL) {
            btn.isCancel = true;
            data.cancelId = IDCANCEL;
            hasCancel = true;
            break;
        }
    }
    if (!hasCancel) {
        for (auto& btn : data.buttons) {
            if (btn.id == IDNO) {
                btn.isCancel = true;
                data.cancelId = IDNO;
                hasCancel = true;
                break;
            }
        }
    }
    if (!hasCancel) {
        data.cancelId = data.buttons.back().id;
        data.buttons.back().isCancel = true;
    }

    HDC hdcScreen = GetDC(NULL);
    HFONT hOldFont = (HFONT)SelectObject(hdcScreen, data.hFontButton);

    int minBtnWidth = MulDiv(75, dpi, 96);
    int btnHeight = MulDiv(24, dpi, 96);
    int btnGap = MulDiv(8, dpi, 96);

    int totalButtonsWidth = 0;
    for (auto& btn : data.buttons) {
        RECT rcText = { 0, 0, 0, 0 };
        DrawTextW(hdcScreen, btn.text.c_str(), -1, &rcText, DT_CALCRECT | DT_SINGLELINE);
        int textW = rcText.right - rcText.left;
        btn.width = (std::max)(minBtnWidth, textW + MulDiv(24, dpi, 96));
        btn.height = btnHeight;
        totalButtonsWidth += btn.width;
    }
    totalButtonsWidth += (int)(data.buttons.size() - 1) * btnGap;

    data.textLeft = data.padX;
    if (data.hIcon) {
        data.textLeft = data.padX + data.iconSize + data.iconTextGap;
    }

    int minDlgClientWidth = (std::max)(MulDiv(380, dpi, 96), totalButtonsWidth + data.padX * 2);
    int textAvailWidth = minDlgClientWidth - data.textLeft - data.padX;
    if (textAvailWidth < MulDiv(240, dpi, 96)) textAvailWidth = MulDiv(240, dpi, 96);

    SelectObject(hdcScreen, data.hFontInstruction);
    RECT rcInst = { 0, 0, textAvailWidth, 0 };
    DrawTextW(hdcScreen, data.instruction.c_str(), -1, &rcInst, DT_CALCRECT | DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX);
    data.instW = rcInst.right - rcInst.left;
    data.instH = rcInst.bottom - rcInst.top;

    if (data.hasContent) {
        SelectObject(hdcScreen, data.hFontContent);
        RECT rcCont = { 0, 0, textAvailWidth, 0 };
        DrawTextW(hdcScreen, data.content.c_str(), -1, &rcCont, DT_CALCRECT | DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX);
        data.contentW = rcCont.right - rcCont.left;
        data.contentH = rcCont.bottom - rcCont.top;
    }

    int textRequiredW = (std::max)(data.instW, data.contentW);
    data.clientWidth = (std::max)(minDlgClientWidth, data.textLeft + textRequiredW + data.padX);

    int textTotalH = data.instH + (data.hasContent ? (data.textGap + data.contentH) : 0);
    int contentMinH = (std::max)(data.iconSize, textTotalH);
    data.upperHeight = data.padY + contentMinH + data.padY;

    data.lowerHeight = MulDiv(44, dpi, 96);
    data.clientHeight = data.upperHeight + 1 + data.lowerHeight;

    int btnY = data.upperHeight + 1 + (data.lowerHeight - btnHeight) / 2;
    int currBtnX = data.clientWidth - data.padX - totalButtonsWidth;
    for (auto& btn : data.buttons) {
        btn.x = currBtnX;
        btn.y = btnY;
        currBtnX += btn.width + btnGap;
    }

    SelectObject(hdcScreen, hOldFont);
    ReleaseDC(NULL, hdcScreen);

    DWORD dwStyle = WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_CLIPCHILDREN;
    DWORD dwExStyle = WS_EX_DLGMODALFRAME;
    RECT rcWin = { 0, 0, data.clientWidth, data.clientHeight };
    AdjustWindowRectEx(&rcWin, dwStyle, FALSE, dwExStyle);
    int winW = rcWin.right - rcWin.left;
    int winH = rcWin.bottom - rcWin.top;

    int x = 0, y = 0;
    RECT rcParent;
    if (hwndParent && GetWindowRect(hwndParent, &rcParent)) {
        x = rcParent.left + ((rcParent.right - rcParent.left) - winW) / 2;
        y = rcParent.top + ((rcParent.bottom - rcParent.top) - winH) / 2;
    } else {
        RECT rcWork;
        SystemParametersInfoW(SPI_GETWORKAREA, 0, &rcWork, 0);
        x = rcWork.left + ((rcWork.right - rcWork.left) - winW) / 2;
        y = rcWork.top + ((rcWork.bottom - rcWork.top) - winH) / 2;
    }

    BOOL wasParentEnabled = hwndParent ? IsWindowEnabled(hwndParent) : FALSE;
    if (hwndParent && wasParentEnabled) EnableWindow(hwndParent, FALSE);

    HWND hDlg = CreateWindowExW(
        dwExStyle, s_className, data.title.c_str(),
        dwStyle,
        x, y, winW, winH,
        hwndParent, NULL, GetModuleHandle(NULL), &data
    );

    if (!hDlg) {
        if (hwndParent && wasParentEnabled) EnableWindow(hwndParent, TRUE);
        if (data.hFontInstruction) DeleteObject(data.hFontInstruction);
        if (data.hFontContent) DeleteObject(data.hFontContent);
        if (data.hFontButton) DeleteObject(data.hFontButton);
        return 0;
    }

    ShowWindow(hDlg, SW_SHOW);
    UpdateWindow(hDlg);

    if (data.hDefaultBtn) {
        SetFocus(data.hDefaultBtn);
    }

    MSG msg;
    while (IsWindow(hDlg)) {
        BOOL bRet = GetMessageW(&msg, NULL, 0, 0);
        if (bRet == 0 || bRet == -1) {
            if (bRet == 0) PostQuitMessage((int)msg.wParam);
            break;
        }

        if (msg.message == WM_KEYDOWN) {
            if (msg.wParam == VK_ESCAPE) {
                SendMessageW(hDlg, WM_CLOSE, 0, 0);
                continue;
            }
        }

        if (IsDialogMessageW(hDlg, &msg)) {
            continue;
        }
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }

    if (hwndParent && wasParentEnabled) {
        EnableWindow(hwndParent, TRUE);
        SetActiveWindow(hwndParent);
    }

    if (data.hFontInstruction) DeleteObject(data.hFontInstruction);
    if (data.hFontContent) DeleteObject(data.hFontContent);
    if (data.hFontButton) DeleteObject(data.hFontButton);

    return data.resultId;
}
struct Editor {
    HWND hwnd = NULL; HICON hFileIcon = NULL; HICON hAppIcon = NULL; HWND hFindDlg = NULL; PieceTable pt; UndoManager undo;
    std::unique_ptr<MappedFile> fileMap; std::wstring currentFilePath; bool isDirty = false; UINT cfMsDevCol = 0; UINT cfMsDevLine = 0;
    std::regex cachedRegex; bool isRegexDirty = true; bool isRegexValid = false; std::string searchQuery; std::string replaceQuery;
    bool searchMatchCase = false; bool searchWholeWord = false; bool searchRegex = false; bool isReplaceMode = false; bool showHelpPopup = false;
    std::vector<Cursor> cursors; EditBatch pendingPadding; bool isDragging = false; bool isRectSelecting = false; bool isAutoScrolling = false;
    float rectAnchorX = 0; int rectAnchorLine = 0; float rectHeadX = 0; int rectHeadLine = 0;
    bool isDragMovePending = false; bool isDragMoving = false; size_t dragMoveSourceStart = 0; size_t dragMoveSourceEnd = 0; size_t dragMoveDestPos = 0;
    wchar_t highSurrogate = 0; std::string imeComp; int vScrollPos = 0; int vScrollSubLine = 0; int hScrollPos = 0; std::vector<size_t> lineStarts;
    float maxLineWidth = 100.0f; float gutterWidth = 50.0f; DWORD lastClickTime = 0; int clickCount = 0; int lastClickX = 0, lastClickY = 0;
    float currentFontSize = 21.0f; DWORD64 zoomPopupEndTime = 0; std::wstring zoomPopupText; bool suppressUI = false;
    ID2D1Factory1* d2dFactory = nullptr; ID2D1DeviceContext* rend = nullptr; IDXGISwapChain1* swapChain = nullptr; ID2D1Bitmap1* targetBitmap = nullptr;
    IDCompositionDevice* dcompDevice = nullptr; IDCompositionTarget* dcompTarget = nullptr; IDWriteFactory* dwFactory = nullptr;
    IDWriteTextFormat* textFormat = nullptr; IDWriteTextFormat* popupTextFormat = nullptr; IDWriteTextFormat* helpTextFormat = nullptr;
    ID2D1StrokeStyle* dotStyle = nullptr; ID2D1StrokeStyle* roundJoinStyle = nullptr;
    D2D1::ColorF background = D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f); D2D1::ColorF textColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f);
    D2D1::ColorF gutterBg = D2D1::ColorF(0.95f, 0.95f, 0.95f, 1.0f); D2D1::ColorF gutterText = D2D1::ColorF(0.6f, 0.6f, 0.6f, 1.0f);
    D2D1::ColorF selColor = D2D1::ColorF(0.7f, 0.8f, 1.0f, 1.0f); D2D1::ColorF highlightColor = D2D1::ColorF(1.0f, 1.0f, 0.0f, 0.4f);
    float dpiScaleX = 1.0f, dpiScaleY = 1.0f; float lineHeight = 17.5f; float charWidth = 8.0f; bool isFullScreen = false;
    WINDOWPLACEMENT prevPlacement = { sizeof(WINDOWPLACEMENT) }; std::wstring helpTextStr;
    D2D1::ColorF autoHlColor = D2D1::ColorF(0.8f, 0.8f, 0.8f, 0.35f); D2D1::ColorF caretColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f);
    int forceTheme = 0; // 0=auto, 1=light, 2=dark
    bool isDarkMode = false; bool isOverwriteMode = false; bool isVScrollDragging = false; bool isHScrollDragging = false;
    float scrollDragOffset = 0.0f; bool isVScrollHover = false; bool isHScrollHover = false; bool isTrackingMouse = false;
    bool wordWrapEnabled = false;
    MiuEncoding currentEncoding = ENC_UTF8_NOBOM; UINT currentCodePage = CP_UTF8; std::string convertedBuffer; std::string newlineStr = "\r\n";
    SyntaxDef currentSyntax;
    ID2D1SolidColorBrush* keywordBrush = nullptr;
    ID2D1SolidColorBrush* literalBrush = nullptr;
    ID2D1SolidColorBrush* commentBrush = nullptr;
    ID2D1SolidColorBrush* stringBrush = nullptr;
    std::vector<ID2D1SolidColorBrush*> regexBrushes;
    FILETIME lastWriteTime = { 0, 0 }; bool isCheckingModification = false;
    void updateFileTime() {
        if (currentFilePath.empty()) { lastWriteTime = { 0, 0 }; return; }
        WIN32_FILE_ATTRIBUTE_DATA fad;
        if (GetFileAttributesExW(currentFilePath.c_str(), GetFileExInfoStandard, &fad)) { lastWriteTime = fad.ftLastWriteTime; }
        else { lastWriteTime = { 0, 0 }; }
    }
    void checkFileModification() {
        if (currentFilePath.empty() || isCheckingModification) return;
        WIN32_FILE_ATTRIBUTE_DATA fad;
        if (GetFileAttributesExW(currentFilePath.c_str(), GetFileExInfoStandard, &fad)) {
            if (CompareFileTime(&lastWriteTime, &fad.ftLastWriteTime) < 0) {
                isCheckingModification = true;
                std::wstring msg = GetResString(IDS_FILE_CHANGED_EXT);
                if (isDirty) msg += GetResString(IDS_FILE_CHANGED_WARN);
                int r = ShowTaskDialog(GetResString(IDS_FILE_CHANGED_TITLE).c_str(), msg.c_str(), currentFilePath.c_str(), TDCBF_YES_BUTTON | TDCBF_NO_BUTTON, TD_INFORMATION_ICON);
                if (r == IDYES) openFileFromPath(currentFilePath);
                else lastWriteTime = fad.ftLastWriteTime;
                isCheckingModification = false;
            }
        }
    }
    void loadSyntaxForExtension(const std::wstring& ext) {
        static bool initialized = false;
        static std::unordered_map<std::wstring, std::string> syntaxStrMap;
        if (!initialized) {
            initialized = true;
            syntaxStrMap[L"cpp"] = syntaxStrMap[L"c"] = syntaxStrMap[L"h"] = syntaxStrMap[L"hpp"] = R"([cpp]
keyword: int float double return if else for while break class struct static virtual void bool const auto namespace using template typename public private protected new delete goto unsigned char short long typedef sizeof switch case default constexpr noexcept inline explicit friend mutable catch try throw operator decltype alignas alignof static_cast dynamic_cast reinterpret_cast const_cast typeid union enum final override thread_local DWORD HWND HRESULT HANDLE HINSTANCE HICON HCURSOR HBRUSH HKEY HDC HGLRC LRESULT WPARAM LPARAM WNDCLASS WNDCLASSEX MSG PAINTSTRUCT RECT FILETIME SYSTEMTIME WORD BYTE UINT ULONG LONG INT BOOL BOOLEAN TCHAR WCHAR LPSTR LPCSTR LPWSTR LPCWSTR LPTSTR LPCTSTR LPVOID PVOID std vector string wstring map set unordered_map unordered_set list deque stringstream wstringstream regex sregex_iterator
literal: true false nullptr TRUE FALSE NULL INFINITE INVALID_HANDLE_VALUE
comment_line: //
comment_block: /* */
regex: #[ \t]*include[ \t]*[<"][^>"]+[>"]
regex_color: 0.6 0.4 0.6 1.0
regex: #[ \t]*[a-zA-Z0-9_]+
regex_color: 0.6 0.4 0.6 1.0
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?([fFlLuU]*))\b
regex_color: 0.4 0.7 0.6 1.0
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
regex: \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b
regex_color: 0.8 0.4 0.2 1.0
)";
            syntaxStrMap[L"cs"] = R"([cs]
keyword: abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while async await var yield nameof record init get set
literal: true false null
comment_line: //
comment_block: /* */
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?([fFlLmUdD]*))\b
regex_color: 0.4 0.7 0.6 1.0
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
regex: \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b
regex_color: 0.8 0.4 0.2 1.0
)";
            syntaxStrMap[L"py"] = R"([python]
keyword: and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass print raise return try while with yield async await match case type
literal: True False None
comment_line: #
comment_block: """ """
regex: \b(0x[0-9a-fA-F]+|0b[01]+|0o[0-7]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?(j)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
regex: \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b
regex_color: 0.8 0.4 0.2 1.0
)";
            syntaxStrMap[L"js"] = syntaxStrMap[L"ts"] = syntaxStrMap[L"jsx"] = syntaxStrMap[L"tsx"] = R"([js]
keyword: break case catch class const continue debugger default delete do else export extends finally for function if import in instanceof new return super switch this throw try typeof var void while with yield let static enum implements package protected interface private public async await type namespace declare module as any unknown never boolean number string symbol get set require exports
literal: true false null undefined NaN Infinity
comment_line: //
comment_block: /* */
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
regex: \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b
regex_color: 0.8 0.4 0.2 1.0
)";
            syntaxStrMap[L"json"] = R"([json]
literal: true false null
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
regex: \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b
regex_color: 0.8 0.4 0.2 1.0
)";
            syntaxStrMap[L"html"] = syntaxStrMap[L"htm"] = syntaxStrMap[L"xml"] = R"([html]
comment_block: <!-- -->
regex: </?[a-zA-Z0-9\-:]+>?
regex_color: 0.3 0.6 0.8 1.0
regex: \b[a-zA-Z0-9\-:]+(?=\s*=)
regex_color: 0.8 0.5 0.3 1.0
regex: &[#a-zA-Z0-9]+;
regex_color: 0.6 0.4 0.7 1.0
)";
            syntaxStrMap[L"css"] = R"([css]
comment_block: /* */
regex: \b[a-zA-Z\-]+(?=\s*:)
regex_color: 0.3 0.6 0.8 1.0
regex: \B#[0-9a-fA-F]{3,6}\b
regex_color: 0.6 0.4 0.7 1.0
regex: \b(px|em|rem|vh|vw|%)\b
regex_color: 0.8 0.5 0.3 1.0
regex: (\.|#|:)[a-zA-Z_\-]+
regex_color: 0.4 0.7 0.6 1.0
)";
            syntaxStrMap[L"md"] = syntaxStrMap[L"markdown"] = R"([markdown]
regex: ^[ \t]*#{1,6}[ \t]+.*
regex_color: 0.3 0.7 0.9 1.0
regex: (\*\*|__)[^\*\_]+(\*\*|__)
regex_color: 0.9 0.5 0.3 1.0
regex: `[^`]+`
regex_color: 0.5 0.7 0.5 1.0
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
)";
            syntaxStrMap[L"rs"] = R"([rust]
keyword: as break const continue crate else enum extern fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait type unsafe use where while async await dyn abstract become box do final macro override priv typeof unsized virtual yield
literal: true false Option Result Some None Ok Err
comment_line: //
comment_block: /* */
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?([a-zA-Z0-9_]*))\b
regex_color: 0.4 0.7 0.6 1.0
regex: #[ \t]*\[.*?\]
regex_color: 0.6 0.4 0.7 1.0
regex: \b[a-zA-Z_][a-zA-Z0-9_]*!
regex_color: 0.3 0.6 0.8 1.0
)";
            syntaxStrMap[L"go"] = R"([go]
keyword: break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var
literal: true false iota nil make new len cap append close delete panic recover
comment_line: //
comment_block: /* */
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
)";
            syntaxStrMap[L"java"] = R"([java]
keyword: abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while var yield record sealed permits non-sealed
literal: true false null
comment_line: //
comment_block: /* */
regex: \b(0x[0-9a-fA-F]+|[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?([fFlLdD]*))\b
regex_color: 0.4 0.7 0.6 1.0
regex: @[a-zA-Z_][a-zA-Z0-9_]*
regex_color: 0.6 0.4 0.7 1.0
)";
            syntaxStrMap[L"ps1"] = R"([powershell]
keyword: begin break catch continue data do dynamicparam else elseif end exit filter finally for foreach from function if in inlineScript parallel param process return sequence switch throw trap try until while workflow
literal: $true $false $null
comment_line: #
comment_block: <# #>
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: \$[a-zA-Z_][a-zA-Z0-9_]*
regex_color: 0.8 0.5 0.3 1.0
regex: -[a-zA-Z_][a-zA-Z0-9_]*
regex_color: 0.4 0.7 0.9 1.0
)";
            syntaxStrMap[L"bat"] = syntaxStrMap[L"cmd"] = R"([batch]
keyword: call cd chdir choice cls color copy date del dir echo endlocal erase exit find findstr for goto if md mkdir move path pause popd prompt pushd rd rem ren rename rmdir set setlocal shift start time title type ver verify vol CALL CD CHDIR CHOICE CLS COLOR COPY DATE DEL DIR ECHO ENDLOCAL ERASE EXIT FIND FINDSTR FOR GOTO IF MD MKDIR MOVE PATH PAUSE POPD PROMPT PUSHD RD REM REN RENAME RMDIR SET SETLOCAL SHIFT START TIME TITLE TYPE VER VERIFY VOL
regex: ^[ \t]*([rR][eE][mM]|::).*
regex_color: 0.38 0.62 0.38 1.0
regex: %[a-zA-Z0-9_]+%
regex_color: 0.8 0.5 0.3 1.0
regex: ^[ \t]*:[a-zA-Z0-9_]+
regex_color: 0.6 0.4 0.7 1.0
)";
            syntaxStrMap[L"sh"] = syntaxStrMap[L"bash"] = R"([bash]
keyword: if then else elif fi case esac for select while until do done in function time coproc source alias export read local
literal: true false
comment_line: #
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: \$[a-zA-Z_][a-zA-Z0-9_]*
regex_color: 0.8 0.5 0.3 1.0
regex: \$\{[^\}]+\}
regex_color: 0.8 0.5 0.3 1.0
)";
            syntaxStrMap[L"sql"] = R"([sql]
comment_line: --
comment_block: /* */
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: \b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|LEFT|RIGHT|INNER|OUTER|ON|GROUP|BY|ORDER|HAVING|LIMIT|OFFSET|AS|IN|AND|OR|NOT|IS|NULL|CREATE|ALTER|DROP|TABLE|INDEX|VIEW|PRIMARY|KEY|FOREIGN|REFERENCES|DEFAULT|UNIQUE)\b
regex_color: 0.3 0.6 0.8 1.0
regex: \b(select|insert|update|delete|from|where|join|left|right|inner|outer|on|group|by|order|having|limit|offset|as|in|and|or|not|is|null|create|alter|drop|table|index|view|primary|key|foreign|references|default|unique)\b
regex_color: 0.3 0.6 0.8 1.0
)";
            syntaxStrMap[L"php"] = R"([php]
keyword: echo print if else elseif for foreach while do switch case break continue return include require function class public private protected static try catch throw new extends implements trait namespace use yield global
literal: true false null TRUE FALSE NULL
comment_line: //
comment_block: /* */
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
regex: \$[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
regex_color: 0.8 0.5 0.3 1.0
)";
            syntaxStrMap[L"rb"] = syntaxStrMap[L"ruby"] = R"([ruby]
keyword: def end class module if unless else elsif case when while until for do yield return break next redo retry rescue ensure super alias undef in include require
literal: true false nil self
comment_line: #
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
)";
            syntaxStrMap[L"swift"] = R"([swift]
keyword: func var let class struct enum protocol extension init deinit return if else switch case for in while do catch throw try await async guard defer fileprivate private open public internal
literal: true false nil
comment_line: //
comment_block: /* */
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
)";
            syntaxStrMap[L"kt"] = syntaxStrMap[L"kotlin"] = R"([kotlin]
keyword: fun val var class interface object package import return if else when for while do break continue try catch finally throw in is as typealias
literal: true false null
comment_line: //
comment_block: /* */
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?([fFlL]*))\b
regex_color: 0.4 0.7 0.6 1.0
)";
            syntaxStrMap[L"lua"] = R"([lua]
keyword: and break do else elseif end false for function if in local nil not or repeat return then true until while
literal: true false nil
comment_line: --
comment_block: --[[ ]]
regex: \b([0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b
regex_color: 0.4 0.7 0.6 1.0
)";
            syntaxStrMap[L"yml"] = syntaxStrMap[L"yaml"] = R"([yaml]
comment_line: #
regex: ^[ \t]*[a-zA-Z0-9_\-]+:
regex_color: 0.3 0.6 0.8 1.0
regex: \b(true|false|null)\b
regex_color: 0.8 0.4 0.2 1.0
)";
            syntaxStrMap[L"tex"] = syntaxStrMap[L"latex"] = R"([latex]
comment_line: %
regex: \\[a-zA-Z]+
regex_color: 0.3 0.6 0.8 1.0
regex: \{.*?\}
regex_color: 0.8 0.5 0.3 1.0
regex: \$.*?\$
regex_color: 0.6 0.4 0.7 1.0
)";
            syntaxStrMap[L""] = R"([default]
regex: (https?|ftp)://[^\s/$.?#].[^\s]*
regex_color: 0.2 0.6 0.8 1.0
regex: \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b
regex_color: 0.8 0.4 0.2 1.0
)";
        }
        std::wstring lowerExt = ext;
        for (auto& c : lowerExt) c = std::towlower(c);
        std::string targetSyntax = syntaxStrMap[L""];
        if (syntaxStrMap.count(lowerExt)) {
            targetSyntax = syntaxStrMap[lowerExt];
        }
        currentSyntax = SyntaxDef();
        std::stringstream ss(targetSyntax);
        std::string line;
        std::string lastRegex;
        while (std::getline(ss, line)) {
            if (!line.empty() && line.back() == '\r') line.pop_back();
            if (line.find("keyword: ") == 0) {
                std::stringstream ws(line.substr(9)); std::string w;
                while (ws >> w) currentSyntax.keywords.insert(w);
            }
            if (line.find("literal: ") == 0) {
                std::stringstream ws(line.substr(9)); std::string w;
                while (ws >> w) currentSyntax.literals.insert(w);
            }
            if (line.find("comment_line: ") == 0) currentSyntax.commentLine = line.substr(14);
            if (line.find("comment_block: ") == 0) {
                std::stringstream ws(line.substr(15));
                ws >> currentSyntax.commentBlockStart >> currentSyntax.commentBlockEnd;
            }
            if (line.find("regex: ") == 0) lastRegex = line.substr(7);
            if (line.find("regex_color: ") == 0 && !lastRegex.empty()) {
                float r, g, b, a;
                if (sscanf_s(line.substr(13).c_str(), "%f %f %f %f", &r, &g, &b, &a) == 4) {
                    currentSyntax.regexes.push_back({ std::regex(lastRegex, std::regex_constants::optimize), D2D1::ColorF(r, g, b, a) });
                }
                lastRegex = "";
            }
        }
    }
    bool checkInBlockComment(size_t visibleStart) {
        if (currentSyntax.commentBlockStart.empty() || currentSyntax.commentBlockEnd.empty()) return false;
        if (visibleStart == 0) return false;
        size_t maxSearch = std::min((size_t)50000, visibleStart);
        std::string preText = pt.getRange(visibleStart - maxSearch, maxSearch);
        size_t lastOpen = preText.rfind(currentSyntax.commentBlockStart);
        size_t lastClose = preText.rfind(currentSyntax.commentBlockEnd);
        if (lastOpen != std::string::npos) {
            if (lastClose == std::string::npos || lastOpen > lastClose) {
                size_t lastNewline = preText.rfind('\n', lastOpen);
                size_t startSearchLine = (lastNewline == std::string::npos) ? 0 : lastNewline + 1;
                if (!currentSyntax.commentLine.empty()) {
                    size_t lineCommentPos = preText.find(currentSyntax.commentLine, startSearchLine);
                    if (lineCommentPos != std::string::npos && lineCommentPos < lastOpen) {
                        return false;
                    }
                }
                bool insideString = false;
                for (size_t k = startSearchLine; k < lastOpen; ++k) {
                    if (preText[k] == '"' || preText[k] == '\'') {
                        if (k > 0 && preText[k - 1] == '\\') continue;
                        insideString = !insideString;
                    }
                }
                if (insideString) return false;
                return true;
            }
        }
        return false;
    }
    void applySyntaxHighlighting(IDWriteTextLayout* layout, const std::string& visibleText, size_t visibleStartOffset) {
        if (visibleText.empty()) return;
        bool inBlockComment = checkInBlockComment(visibleStartOffset);
        auto setEffect = [&](size_t utf8Start, size_t utf8Len, ID2D1SolidColorBrush* brush) {
            if (utf8Len == 0 || !brush) return;
            size_t wStart = utf8OffsetToUtf16Count(visibleText, utf8Start);
            size_t wLen = utf8OffsetToUtf16Count(visibleText, utf8Start + utf8Len) - wStart;
            DWRITE_TEXT_RANGE range = { (UINT32)wStart, (UINT32)wLen };
            layout->SetDrawingEffect(brush, range);
            };
        for (size_t i = 0; i < currentSyntax.regexes.size(); ++i) {
            if (i >= regexBrushes.size()) break;
            std::sregex_iterator words_begin(visibleText.begin(), visibleText.end(), currentSyntax.regexes[i].first);
            std::sregex_iterator words_end;
            for (auto it = words_begin; it != words_end; ++it) {
                setEffect(it->position(), it->length(), regexBrushes[i]);
            }
        }
        size_t i = 0;
        size_t len = visibleText.length();
        while (i < len) {
            if (inBlockComment) {
                size_t startStr = i;
                size_t endComment = visibleText.find(currentSyntax.commentBlockEnd, i);
                if (endComment != std::string::npos) {
                    i = endComment + currentSyntax.commentBlockEnd.length();
                    inBlockComment = false;
                }
                else {
                    i = len;
                }
                setEffect(startStr, i - startStr, commentBrush);
            }
            else {
                if (!currentSyntax.commentBlockStart.empty() && visibleText.compare(i, currentSyntax.commentBlockStart.length(), currentSyntax.commentBlockStart) == 0) {
                    inBlockComment = true;
                    continue;
                }
                if (!currentSyntax.commentLine.empty() && visibleText.compare(i, currentSyntax.commentLine.length(), currentSyntax.commentLine) == 0) {
                    size_t startStr = i;
                    size_t eol = visibleText.find('\n', i);
                    if (eol == std::string::npos) eol = len;
                    i = eol;
                    setEffect(startStr, i - startStr, commentBrush);
                    continue;
                }
                if (visibleText[i] == '"' || visibleText[i] == '\'') {
                    char quote = visibleText[i];
                    size_t startStr = i;
                    i++;
                    while (i < len) {
                        if (visibleText[i] == '\\' && i + 1 < len) {
                            i += 2;
                        }
                        else if (visibleText[i] == quote) {
                            i++;
                            break;
                        }
                        else if (visibleText[i] == '\n') {
                            break;
                        }
                        else {
                            i++;
                        }
                    }
                    setEffect(startStr, i - startStr, stringBrush);
                    continue;
                }
                if (isWordChar(visibleText[i])) {
                    size_t startStr = i;
                    while (i < len && isWordChar(visibleText[i])) i++;
                    std::string word = visibleText.substr(startStr, i - startStr);
                    if (currentSyntax.keywords.count(word)) setEffect(startStr, i - startStr, keywordBrush);
                    else if (currentSyntax.literals.count(word)) setEffect(startStr, i - startStr, literalBrush);
                    continue;
                }
                i++;
            }
        }
    }
    void updateSearchQuery(const std::string& newQuery) { if (searchQuery != newQuery) { searchQuery = newQuery; isRegexDirty = true; } }
    void updateSearchFlags(bool matchCase, bool wholeWord, bool regexMode) { if (searchMatchCase != matchCase || searchWholeWord != wholeWord || searchRegex != regexMode) { searchMatchCase = matchCase; searchWholeWord = wholeWord; searchRegex = regexMode; isRegexDirty = true; } }
    void ensureRegexReady() {
        if (searchRegex && isRegexDirty) {
            isRegexValid = false;
            if (!searchQuery.empty()) {
                try { std::string actualQuery = preprocessRegexQuery(searchQuery); std::regex_constants::syntax_option_type flags = std::regex_constants::ECMAScript; if (!searchMatchCase) flags |= std::regex_constants::icase; cachedRegex = std::regex(actualQuery, flags); isRegexValid = true; }
                catch (...) { isRegexValid = false; }
            }
            isRegexDirty = false;
        }
    }
    std::string preprocessRegexQuery(const std::string& query) {
        std::string processed; processed.reserve(query.size() * 4);
        for (size_t i = 0; i < query.size(); ++i) {
            char c = query[i];
            if (c == '\\') { if (i + 1 < query.size()) { char next = query[i + 1]; if (next == 'n') { bool isPrecededByCR = (i >= 2 && query[i - 2] == '\\' && query[i - 1] == 'r'); if (!isPrecededByCR) { processed += "(?:\\r\\n|[\\r\\n])"; i++; continue; } } processed += c; processed += next; i++; continue; } }
            else if (c == '^') { bool inClass = false; if (i > 0 && query[i - 1] == '[') inClass = true; if (!inClass) { processed += "((?:^|(?:\\r\\n|\\r(?!\\n)|[\\n])))"; continue; } }
            else if (c == '$') { bool inClass = false; if (i > 0 && query[i - 1] == '[') inClass = true; if (!inClass) { processed += "(?=(?:\\r\\n|[\\r\\n]|$))"; continue; } }
            processed += c;
        }
        return processed;
    }
    void detectNewlineStyle(const char* buf, size_t len) {
        size_t checkLen = (len > 4096) ? 4096 : len;
        for (size_t i = 0; i < checkLen; ++i) {
            if (buf[i] == '\r') { if (i + 1 < checkLen && buf[i + 1] == '\n') { newlineStr = "\r\n"; return; } newlineStr = "\r"; return; }
            else if (buf[i] == '\n') { newlineStr = "\n"; return; }
        }
        newlineStr = "\r\n";
    }
    bool checkSystemDarkMode() {
        HKEY hKey; DWORD val = 1; DWORD size = sizeof(DWORD);
        if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { RegQueryValueExW(hKey, L"AppsUseLightTheme", NULL, NULL, (LPBYTE)&val, &size); RegCloseKey(hKey); }
        return (val == 0);
    }
    D2D1::ColorF getWindowsAccentColor(float alpha) {
        DWORD color = 0; bool success = false; HKEY hKey;
        if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\DWM", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { DWORD type, size = sizeof(DWORD); if (RegQueryValueExW(hKey, L"AccentColor", NULL, &type, (LPBYTE)&color, &size) == ERROR_SUCCESS) { success = true; } RegCloseKey(hKey); }
        if (success) { float r = (float)(color & 0xFF) / 255.0f; float g = (float)((color >> 8) & 0xFF) / 255.0f; float b = (float)((color >> 16) & 0xFF) / 255.0f; return D2D1::ColorF(r, g, b, alpha); }
        return D2D1::ColorF(0.0f, 0.47f, 0.84f, alpha);
    }
    void updateThemeColors() {
        if (forceTheme == 1) isDarkMode = false;
        else if (forceTheme == 2) isDarkMode = true;
        else isDarkMode = checkSystemDarkMode();
        D2D1::ColorF accent = getWindowsAccentColor(0.5f); bool isTransparencyEnabled = true; HKEY hKey; DWORD val = 1; DWORD size = sizeof(DWORD);
        if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { if (RegQueryValueExW(hKey, L"EnableTransparency", NULL, NULL, (LPBYTE)&val, &size) == ERROR_SUCCESS) { isTransparencyEnabled = (val != 0); } RegCloseKey(hKey); }
        int backdropValue = DWMSBT_TRANSIENTWINDOW; bool isMicaEnabled = false;
        if (isTransparencyEnabled) { HRESULT hrMica = DwmSetWindowAttribute(hwnd, DWMWA_SYSTEMBACKDROP_TYPE, &backdropValue, sizeof(backdropValue)); isMicaEnabled = SUCCEEDED(hrMica); }
        float bgAlpha = isMicaEnabled ? 0.0f : 1.0f;
        if (keywordBrush) { keywordBrush->Release(); keywordBrush = nullptr; }
        if (literalBrush) { literalBrush->Release(); literalBrush = nullptr; }
        if (commentBrush) { commentBrush->Release(); commentBrush = nullptr; }
        if (stringBrush) { stringBrush->Release(); stringBrush = nullptr; }
        for (auto b : regexBrushes) b->Release();
        regexBrushes.clear();

        if (isDarkMode) {
            background = D2D1::ColorF(0.0f, 0.0f, 0.0f, bgAlpha); textColor = D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f); gutterBg = D2D1::ColorF(0.0f, 0.0f, 0.0f, bgAlpha); gutterText = D2D1::ColorF(0.33f, 0.33f, 0.33f, 1.0f); selColor = accent; caretColor = D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f); autoHlColor = D2D1::ColorF(0.35f, 0.35f, 0.35f, 0.5f); highlightColor = D2D1::ColorF(0.4f, 0.4f, 0.0f, 0.6f);
            if (rend) {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.33f, 0.61f, 0.83f), &keywordBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.85f, 0.43f, 0.43f), &literalBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.38f, 0.62f, 0.38f), &commentBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.80f, 0.56f, 0.35f), &stringBrush);
                for (auto& r : currentSyntax.regexes) {
                    ID2D1SolidColorBrush* b = nullptr;
                    rend->CreateSolidColorBrush(r.second, &b);
                    regexBrushes.push_back(b);
                }
            }
        }
        else {
            background = D2D1::ColorF(1.0f, 1.0f, 1.0f, bgAlpha); textColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f); gutterBg = D2D1::ColorF(1.0f, 1.0f, 1.0f, bgAlpha); gutterText = D2D1::ColorF(0.66f, 0.66f, 0.66f, 1.0f); selColor = accent; caretColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f); autoHlColor = D2D1::ColorF(0.85f, 0.85f, 0.85f, 0.5f); highlightColor = D2D1::ColorF(1.0f, 1.0f, 0.0f, 0.4f);
            if (rend) {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 1.0f), &keywordBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.6f, 0.0f, 0.0f), &literalBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.5f, 0.0f), &commentBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.6f, 0.2f, 0.0f), &stringBrush);
                for (auto& r : currentSyntax.regexes) {
                    ID2D1SolidColorBrush* b = nullptr;
                    rend->CreateSolidColorBrush(r.second, &b);
                    regexBrushes.push_back(b);
                }
            }
        }
        BOOL dark = isDarkMode; DwmSetWindowAttribute(hwnd, 20, &dark, sizeof(dark));
        if (isDarkMode) SetWindowTheme(hwnd, L"DarkMode_Explorer", NULL); else SetWindowTheme(hwnd, L"Explorer", NULL);
        EnableDarkModeForWindow(hwnd, isDarkMode);
        FlushMenuThemesInternal();
        if (hFindDlg && IsWindow(hFindDlg)) {
            ApplyDialogTheme(hFindDlg, isDarkMode);
            InvalidateRect(hFindDlg, NULL, TRUE);
        }
        if (hwnd) { SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE); InvalidateRect(hwnd, NULL, TRUE); }
    }
    void handleDpiChange(float newDpiX, float newDpiY) { dpiScaleX = newDpiX / 96.0f; dpiScaleY = newDpiY / 96.0f; if (rend) rend->SetDpi(newDpiX, newDpiY); updateFont(currentFontSize); rebuildLineStarts(); if (hwnd) InvalidateRect(hwnd, NULL, FALSE); }
    std::pair<std::string, bool> getHighlightTarget() {
        if (cursors.size() > 1 || cursors.empty()) return { "", false };
        const Cursor& c = cursors.back();
        if (c.hasSelection()) { size_t len = c.end() - c.start(); if (len == 0 || len > 200) return { "", false }; std::string s = pt.getRange(c.start(), len); if (s.empty() || s.find('\n') != std::string::npos) return { "", false }; return { s, false }; }
        size_t pos = c.head; size_t len = pt.length(); if (pos > len) pos = len;
        bool charRight = (pos < len && isWordChar(pt.charAt(pos))); bool charLeft = (pos > 0 && isWordChar(pt.charAt(pos - 1)));
        if (!charRight && !charLeft) return { "", true };
        size_t start = pos; size_t end = pos; if (!charRight && charLeft) start--;
        while (start > 0 && isWordChar(pt.charAt(start - 1))) start--;
        while (end < len && isWordChar(pt.charAt(end))) end++;
        if (end > start) return { pt.getRange(start, end - start), true };
        return { "", true };
    }
    void initGraphics(HWND h) {
        hwnd = h; RECT rc; GetClientRect(hwnd, &rc); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top;
        ID3D11Device* d3dDevice = nullptr; ID3D11DeviceContext* d3dContext = nullptr; UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
        D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0 };
        D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &d3dDevice, nullptr, &d3dContext);
        IDXGIDevice* dxgiDevice = nullptr; d3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);
        D2D1_FACTORY_OPTIONS options = {}; D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory1), &options, (void**)&d2dFactory);
        ID2D1Device* d2dDevice = nullptr; d2dFactory->CreateDevice(dxgiDevice, &d2dDevice); d2dDevice->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE, &rend);
        IDXGIFactory2* dxgiFactory = nullptr; CreateDXGIFactory2(0, __uuidof(IDXGIFactory2), (void**)&dxgiFactory);
        DXGI_SWAP_CHAIN_DESC1 description = {}; description.Format = DXGI_FORMAT_B8G8R8A8_UNORM; description.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; description.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; description.BufferCount = 2; description.SampleDesc.Count = 1; description.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED; description.Scaling = DXGI_SCALING_STRETCH; description.Width = width; description.Height = height;
        dxgiFactory->CreateSwapChainForComposition(dxgiDevice, &description, nullptr, &swapChain);
        DCompositionCreateDevice(dxgiDevice, __uuidof(IDCompositionDevice), (void**)&dcompDevice); dcompDevice->CreateTargetForHwnd(hwnd, TRUE, &dcompTarget);
        IDCompositionVisual* dcompVisual = nullptr; dcompDevice->CreateVisual(&dcompVisual); dcompVisual->SetContent(swapChain); dcompTarget->SetRoot(dcompVisual); dcompDevice->Commit();
        if (dcompVisual) dcompVisual->Release(); if (dxgiFactory) dxgiFactory->Release(); if (d2dDevice) d2dDevice->Release(); if (dxgiDevice) dxgiDevice->Release(); if (d3dContext) d3dContext->Release(); if (d3dDevice) d3dDevice->Release();
        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&dwFactory));
        UINT dpi = GetDpiForWindow(hwnd); if (dpi == 0) dpi = 96; FLOAT dpix = (FLOAT)dpi; FLOAT dpiy = (FLOAT)dpi; dpiScaleX = dpix / 96.0f; dpiScaleY = dpiy / 96.0f; rend->SetDpi(dpix, dpiy);
        dwFactory->CreateTextFormat(L"Segoe UI", NULL, DWRITE_FONT_WEIGHT_BOLD, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 24.0f, L"en-us", &popupTextFormat);
        if (popupTextFormat) { popupTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER); popupTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER); }
        helpTextStr = APP_VERSION + GetResString(IDS_HELP_TEXT);
        dwFactory->CreateTextFormat(L"Consolas", NULL, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 16.0f, L"en-us", &helpTextFormat);
        if (helpTextFormat) { helpTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING); helpTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR); }
        float dashes[] = { 2.0f, 2.0f }; D2D1_STROKE_STYLE_PROPERTIES props = D2D1::StrokeStyleProperties(D2D1_CAP_STYLE_FLAT, D2D1_CAP_STYLE_FLAT, D2D1_CAP_STYLE_FLAT, D2D1_LINE_JOIN_MITER, 10.0f, D2D1_DASH_STYLE_CUSTOM, 0.0f); d2dFactory->CreateStrokeStyle(&props, dashes, 2, &dotStyle);
        D2D1_STROKE_STYLE_PROPERTIES roundProps = D2D1::StrokeStyleProperties(D2D1_CAP_STYLE_ROUND, D2D1_CAP_STYLE_ROUND, D2D1_CAP_STYLE_ROUND, D2D1_LINE_JOIN_ROUND, 10.0f, D2D1_DASH_STYLE_SOLID, 0.0f); d2dFactory->CreateStrokeStyle(&roundProps, nullptr, 0, &roundJoinStyle);
        cfMsDevCol = RegisterClipboardFormatW(L"MSDEVColumnSelect"); cfMsDevLine = RegisterClipboardFormatW(L"MSDEVLineSelect");
        hAppIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
        loadSyntaxForExtension(L"");
        updateThemeColors(); updateFont(currentFontSize); rebuildLineStarts(); cursors.push_back({ 0, 0, 0.0f }); updateTitleBar(); updateWindowIcon();
    }
    void updateFont(float size) {
        size = std::round(size); if (size < 6.0f) size = 6.0f; if (size > 200.0f) size = 200.0f;
        if (textFormat && size == currentFontSize) return; currentFontSize = size;
        if (textFormat) { textFormat->Release(); textFormat = nullptr; }
        dwFactory->CreateTextFormat(L"Consolas", NULL, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, currentFontSize, L"en-us", &textFormat);
        lineHeight = currentFontSize * 1.25f;
        if (textFormat) { textFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineHeight, lineHeight * 0.8f); textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING); textFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR); }
        IDWriteTextLayout* layout = nullptr;
        if (SUCCEEDED(dwFactory->CreateTextLayout(L"0", 1, textFormat, 100.0f, 100.0f, &layout))) { DWRITE_TEXT_METRICS m; layout->GetMetrics(&m); charWidth = m.width; layout->Release(); }
        if (textFormat) textFormat->SetIncrementalTabStop(charWidth * 4.0f);
        updateGutterWidth(); updateScrollBars();
    }
    void destroyGraphics() {
        if (keywordBrush) { keywordBrush->Release(); keywordBrush = nullptr; }
        if (literalBrush) { literalBrush->Release(); literalBrush = nullptr; }
        if (commentBrush) { commentBrush->Release(); commentBrush = nullptr; }
        if (stringBrush) { stringBrush->Release(); stringBrush = nullptr; }
        for (auto b : regexBrushes) b->Release();
        regexBrushes.clear();
        if (hFileIcon) { DestroyIcon(hFileIcon); hFileIcon = NULL; } if (dcompTarget) dcompTarget->Release(); if (dcompDevice) dcompDevice->Release(); if (targetBitmap) targetBitmap->Release(); if (swapChain) swapChain->Release(); if (rend) rend->Release(); if (popupTextFormat) popupTextFormat->Release(); if (helpTextFormat) helpTextFormat->Release(); if (dotStyle) dotStyle->Release(); if (roundJoinStyle) roundJoinStyle->Release(); if (textFormat) textFormat->Release(); if (dwFactory) dwFactory->Release(); if (d2dFactory) d2dFactory->Release();
    }
    void updateTitleBar() {
        if (!hwnd) return;
        std::wstring title;
        if (isDirty) title = L"*";
        if (currentFilePath.empty()) {
            title += GetResString(IDS_UNTITLED);
        }
        else {
            std::wstring fileName = currentFilePath;
            size_t lastSlash = currentFilePath.find_last_of(L"\\/");
            if (lastSlash != std::wstring::npos) {
                fileName = currentFilePath.substr(lastSlash + 1);
            }
            title += fileName;
        }
        SetWindowTextW(hwnd, title.c_str());
    }
    void updateWindowIcon() {
        if (!hwnd) return;
        if (hFileIcon) { DestroyIcon(hFileIcon); hFileIcon = NULL; }
        HICON iconForTitleBar = hAppIcon;
        if (!currentFilePath.empty()) { SHFILEINFOW sfi = { 0 }; if (SHGetFileInfoW(currentFilePath.c_str(), 0, &sfi, sizeof(sfi), SHGFI_ICON | SHGFI_SMALLICON)) { hFileIcon = sfi.hIcon; iconForTitleBar = hFileIcon; } }
        SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)iconForTitleBar); SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hAppIcon);
    }
    void updateDirtyFlag() { bool newDirty = undo.isModified(); if (isDirty != newDirty) { isDirty = newDirty; updateTitleBar(); } }
    void updateGutterWidth() {
        if (suppressUI) return; int totalLines = (int)lineStarts.size(); int digits = 1; int tempLines = totalLines;
        while (tempLines >= 10) { tempLines /= 10; digits++; }
        gutterWidth = (float)(digits * charWidth) + (charWidth * 1.0f);
    }
    void rebuildLineStarts() {
        lineStarts.clear(); size_t totalLen = pt.length(); if (totalLen > 0) lineStarts.reserve(totalLen / 40 + 1); lineStarts.push_back(0);
        size_t globalOffset = 0; size_t maxBytes = 0; int maxBytesLineIdx = -1; int currentLineIdx = 0;
        for (const auto& p : pt.pieces) {
            const char* buf = p.isOriginal ? (pt.origPtr + p.start) : (pt.addBuf.data() + p.start); const char* ptr = buf; const char* end = buf + p.len;
            while (ptr < end) {
                char c = *ptr;
                if (c == '\n') { size_t offsetInPiece = ptr - buf; size_t nextLineStart = globalOffset + offsetInPiece + 1; size_t currentLineLen = nextLineStart - lineStarts.back(); if (currentLineLen > maxBytes) { maxBytes = currentLineLen; maxBytesLineIdx = currentLineIdx; } lineStarts.push_back(nextLineStart); ptr++; currentLineIdx++; }
                else if (c == '\r') { size_t offsetInPiece = ptr - buf; size_t step = 1; if (ptr + 1 < end && *(ptr + 1) == '\n') step = 2; size_t nextLineStart = globalOffset + offsetInPiece + step; size_t currentLineLen = nextLineStart - lineStarts.back(); if (currentLineLen > maxBytes) { maxBytes = currentLineLen; maxBytesLineIdx = currentLineIdx; } lineStarts.push_back(nextLineStart); ptr += step; currentLineIdx++; }
                else ptr++;
            }
            globalOffset += p.len;
        }
        size_t lastStart = lineStarts.back();
        if (lastStart < totalLen) { size_t lastLineLen = totalLen - lastStart; if (lastLineLen > maxBytes) { maxBytes = lastLineLen; maxBytesLineIdx = currentLineIdx; } }
        maxLineWidth = 100.0f;
        if (maxBytesLineIdx >= 0 && dwFactory && textFormat) {
            size_t start = lineStarts[maxBytesLineIdx]; size_t end = (maxBytesLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[maxBytesLineIdx + 1] : pt.length(); size_t len = (end > start) ? (end - start) : 0;
            if (len > 0) {
                std::string lineStr = pt.getRange(start, len); if (!lineStr.empty() && lineStr.back() == '\n') lineStr.pop_back(); if (!lineStr.empty() && lineStr.back() == '\r') lineStr.pop_back();
                std::wstring wLine = UTF8ToW(lineStr); IDWriteTextLayout* layout = nullptr;
                HRESULT hr = dwFactory->CreateTextLayout(wLine.c_str(), (UINT32)wLine.size(), textFormat, 100000.0f, (FLOAT)lineHeight, &layout);
                if (SUCCEEDED(hr) && layout) { DWRITE_TEXT_METRICS metrics; if (SUCCEEDED(layout->GetMetrics(&metrics))) { maxLineWidth = metrics.widthIncludingTrailingWhitespace + charWidth * 2.0f + 50.0f; } layout->Release(); }
            }
        }
        else maxLineWidth = maxBytes * charWidth + 100.0f;
        updateGutterWidth(); updateScrollBars();
    }
    int getLineIdx(size_t pos) { if (lineStarts.empty()) return 0; auto it = std::upper_bound(lineStarts.begin(), lineStarts.end(), pos); int idx = (int)std::distance(lineStarts.begin(), it) - 1; if (idx < 0) idx = 0; if (idx >= (int)lineStarts.size()) idx = (int)lineStarts.size() - 1; return idx; }
    float getXFromPos(size_t pos, bool affinity = false) {
        int lineIdx = getLineIdx(pos); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); size_t len = (end > start) ? (end - start) : 0;
        std::string lineStr = pt.getRange(start, len); std::wstring wLine = UTF8ToW(lineStr); IDWriteTextLayout* layout = nullptr;
        RECT rc; GetClientRect(hwnd, &rc); float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth; if (clientW < 0) clientW = 0;
        float layoutWidth = wordWrapEnabled ? clientW : 10000000.0f;
        HRESULT hr = dwFactory->CreateTextLayout(wLine.c_str(), (UINT32)wLine.size(), textFormat, layoutWidth, (FLOAT)lineHeight * 100.0f, &layout); float x = 0;
        if (SUCCEEDED(hr) && layout) {
            if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
            size_t utf8Len = (pos >= start) ? (pos - start) : 0; if (utf8Len > lineStr.size()) utf8Len = lineStr.size(); std::string subUtf8 = lineStr.substr(0, utf8Len); std::wstring subUtf16 = UTF8ToW(subUtf8); UINT32 u16Idx = (UINT32)subUtf16.size(); if (u16Idx > wLine.size()) u16Idx = (UINT32)wLine.size();
            DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
            if (affinity && u16Idx > 0) {
                layout->HitTestTextPosition(u16Idx - 1, TRUE, &px, &py, &m);
            } else {
                layout->HitTestTextPosition(u16Idx, FALSE, &px, &py, &m);
            }
            x = px; layout->Release();
        }
        return x;
    }
    size_t getPosFromLineAndX(int lineIdx, float targetX) {
        if (lineIdx < 0 || lineIdx >= (int)lineStarts.size()) return cursors.empty() ? 0 : cursors.back().head;
        size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); size_t len = (end > start) ? (end - start) : 0;
        std::string lineStr = pt.getRange(start, len); std::wstring wLine = UTF8ToW(lineStr); IDWriteTextLayout* layout = nullptr;
        RECT rc; GetClientRect(hwnd, &rc); float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth; if (clientW < 0) clientW = 0;
        float layoutWidth = wordWrapEnabled ? clientW : 10000000.0f;
        HRESULT hr = dwFactory->CreateTextLayout(wLine.c_str(), (UINT32)wLine.size(), textFormat, layoutWidth, (FLOAT)lineHeight * 100.0f, &layout); size_t resultPos = start;
        if (SUCCEEDED(hr) && layout) {
            if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
            BOOL isTrailing, isInside; DWRITE_HIT_TEST_METRICS m; layout->HitTestPoint(targetX, 1.0f, &isTrailing, &isInside, &m); size_t local = m.textPosition; if (isTrailing) local += m.length; size_t limit = wLine.size(); if (limit > 0 && wLine.back() == L'\n') { limit--; if (limit > 0 && wLine[limit - 1] == L'\r') limit--; } if (local > limit) local = limit; std::wstring wSub = wLine.substr(0, local); std::string sub = WToUTF8(wSub); resultPos = start + sub.size(); layout->Release();
        }
        return resultPos;
    }
    size_t moveVisualUpDown(size_t pos, float desiredX, bool up, bool currentAffinity, bool& outAffinity) {
        outAffinity = false;
        if (!wordWrapEnabled) {
            int l = getLineIdx(pos);
            if (up) {
                if (l > 0) return getPosFromLineAndX(l - 1, desiredX);
                return pos;
            } else {
                if (l + 1 < (int)lineStarts.size()) return getPosFromLineAndX(l + 1, desiredX);
                return pos;
            }
        }
        RECT rc; GetClientRect(hwnd, &rc);
        float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if (pos > pt.length()) pos = pt.length();
        int curLineIdx = getLineIdx(pos);
        size_t curStart = lineStarts[curLineIdx];
        size_t curEnd = (curLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[curLineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') {
            curLineStr.pop_back();
            if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        }
        std::wstring curWLine = UTF8ToW(curLineStr);

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) {
            outAffinity = currentAffinity;
            return pos;
        }
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount == 0) curLineCount = 1;
        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        if (curActual == 0) curActual = 1;

        std::vector<UINT32> curVisualStarts(curActual);
        std::vector<UINT32> curVisualEnds(curActual);
        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            curVisualStarts[i] = cum;
            cum += curLineMetrics[i].length;
            curVisualEnds[i] = cum;
        }

        size_t utf8Off = (pos >= curStart) ? (pos - curStart) : 0;
        if (utf8Off > curLineStr.size()) utf8Off = curLineStr.size();
        UINT32 u16Idx = (UINT32)utf8OffsetToUtf16Count(curLineStr, utf8Off);
        if (u16Idx > curWLine.size()) u16Idx = (UINT32)curWLine.size();

        int curVisualLine = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (currentAffinity && i > 0 && u16Idx == curVisualStarts[i]) {
                curVisualLine = (int)i - 1;
                break;
            }
            if (i == curActual - 1 || u16Idx < curVisualEnds[i]) {
                curVisualLine = (int)i;
                break;
            }
        }

        int targetLineIdx = curLineIdx;
        int targetVisualLine = -1;

        if (up) {
            if (curVisualLine > 0) {
                targetVisualLine = curVisualLine - 1;
            } else {
                if (curLineIdx == 0) {
                    curLayout->Release();
                    outAffinity = currentAffinity;
                    return pos;
                }
                targetLineIdx = curLineIdx - 1;
            }
        } else {
            if (curVisualLine + 1 < (int)curActual) {
                targetVisualLine = curVisualLine + 1;
            } else {
                if (curLineIdx + 1 >= (int)lineStarts.size()) {
                    curLayout->Release();
                    outAffinity = currentAffinity;
                    return pos;
                }
                targetLineIdx = curLineIdx + 1;
                targetVisualLine = 0;
            }
        }

        IDWriteTextLayout* targetLayout = nullptr;
        std::wstring targetWLine;
        size_t targetStart = 0;
        UINT32 targetLineCount = 0;
        std::vector<DWRITE_LINE_METRICS> targetLineMetrics;
        std::vector<UINT32> targetVisualStarts;
        std::vector<UINT32> targetVisualEnds;

        if (targetLineIdx == curLineIdx) {
            targetLayout = curLayout;
            targetWLine = curWLine;
            targetStart = curStart;
            targetLineCount = curActual;
            targetLineMetrics = curLineMetrics;
            targetVisualStarts = curVisualStarts;
            targetVisualEnds = curVisualEnds;
        } else {
            curLayout->Release();
            curLayout = nullptr;

            targetStart = lineStarts[targetLineIdx];
            size_t targetEnd = (targetLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[targetLineIdx + 1] : pt.length();
            size_t targetLen = (targetEnd > targetStart) ? (targetEnd - targetStart) : 0;
            std::string targetLineStr = pt.getRange(targetStart, targetLen);
            if (!targetLineStr.empty() && targetLineStr.back() == '\n') {
                targetLineStr.pop_back();
                if (!targetLineStr.empty() && targetLineStr.back() == '\r') targetLineStr.pop_back();
            }
            targetWLine = UTF8ToW(targetLineStr);

            hr = dwFactory->CreateTextLayout(targetWLine.c_str(), (UINT32)targetWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &targetLayout);
            if (FAILED(hr) || !targetLayout) {
                outAffinity = currentAffinity;
                return pos;
            }
            targetLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

            DWRITE_TEXT_METRICS tTm;
            targetLayout->GetMetrics(&tTm);
            targetLineCount = tTm.lineCount;
            if (targetLineCount == 0) targetLineCount = 1;

            targetLineMetrics.resize(targetLineCount);
            UINT32 tActual = 0;
            targetLayout->GetLineMetrics(targetLineMetrics.data(), targetLineCount, &tActual);
            targetLineCount = tActual;
            if (targetLineCount == 0) targetLineCount = 1;

            targetVisualStarts.resize(targetLineCount);
            targetVisualEnds.resize(targetLineCount);
            UINT32 tCum = 0;
            for (UINT32 i = 0; i < targetLineCount; ++i) {
                targetVisualStarts[i] = tCum;
                tCum += targetLineMetrics[i].length;
                targetVisualEnds[i] = tCum;
            }

            if (up) {
                targetVisualLine = (int)targetLineCount - 1;
            } else {
                targetVisualLine = 0;
            }
        }

        if (targetVisualLine < 0) targetVisualLine = 0;
        if (targetVisualLine >= (int)targetLineCount) targetVisualLine = (int)targetLineCount - 1;

        float targetY = targetVisualLine * lineHeight + lineHeight * 0.5f;
        BOOL isTrailing = FALSE, isInside = FALSE;
        DWRITE_HIT_TEST_METRICS hitM = {};
        targetLayout->HitTestPoint(desiredX, targetY, &isTrailing, &isInside, &hitM);

        UINT32 localU16 = hitM.textPosition;
        if (isTrailing) localU16 += hitM.length;

        UINT32 minU16 = targetVisualStarts[targetVisualLine];
        UINT32 maxU16 = targetVisualEnds[targetVisualLine];

        if (localU16 < minU16) localU16 = minU16;
        if (localU16 > maxU16) localU16 = maxU16;

        if (localU16 == targetVisualEnds[targetVisualLine] && targetVisualLine < (int)targetLineCount - 1 && targetVisualEnds[targetVisualLine] > minU16) {
            outAffinity = true;
        } else {
            outAffinity = false;
        }

        std::wstring wSub = targetWLine.substr(0, localU16);
        std::string sub = WToUTF8(wSub);
        size_t resultPos = targetStart + sub.size();

        targetLayout->Release();
        return resultPos;
    }
    size_t getLogicalLineStart(size_t pos) {
        if (lineStarts.empty()) return 0;
        int l = getLineIdx(pos);
        return lineStarts[l];
    }
    size_t getLogicalLineEnd(size_t pos) {
        if (lineStarts.empty()) return 0;
        int l = getLineIdx(pos);
        size_t start = lineStarts[l];
        size_t nextStart = (l + 1 < (int)lineStarts.size()) ? lineStarts[l + 1] : pt.length();
        size_t end = nextStart;
        if (end > start && pt.charAt(end - 1) == '\n') {
            end--;
            if (end > start && pt.charAt(end - 1) == '\r') end--;
        }
        return end;
    }
    size_t moveVisualHome(size_t pos, bool currentAffinity, bool& outAffinity) {
        outAffinity = false;
        size_t logicalStart = getLogicalLineStart(pos);
        if (!wordWrapEnabled) return logicalStart;

        RECT rc; GetClientRect(hwnd, &rc);
        float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if (pos > pt.length()) pos = pt.length();

        int curLineIdx = getLineIdx(pos);
        size_t curStart = lineStarts[curLineIdx];
        size_t curEnd = (curLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[curLineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') {
            curLineStr.pop_back();
            if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        }
        std::wstring curWLine = UTF8ToW(curLineStr);
        if (curWLine.empty()) return logicalStart;

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return logicalStart;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount == 0) curLineCount = 1;
        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        if (curActual == 0) curActual = 1;

        std::vector<UINT32> curVisualStarts(curActual);
        std::vector<UINT32> curVisualEnds(curActual);
        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            curVisualStarts[i] = cum;
            cum += curLineMetrics[i].length;
            curVisualEnds[i] = cum;
        }

        size_t utf8Off = (pos >= curStart) ? (pos - curStart) : 0;
        if (utf8Off > curLineStr.size()) utf8Off = curLineStr.size();
        UINT32 u16Idx = (UINT32)utf8OffsetToUtf16Count(curLineStr, utf8Off);
        if (u16Idx > curWLine.size()) u16Idx = (UINT32)curWLine.size();

        int curVisualLine = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (currentAffinity && i > 0 && u16Idx == curVisualStarts[i]) {
                curVisualLine = (int)i - 1;
                break;
            }
            if (i == curActual - 1 || u16Idx < curVisualEnds[i]) {
                curVisualLine = (int)i;
                break;
            }
        }

        UINT32 startU16 = curVisualStarts[curVisualLine];
        std::wstring wSub = curWLine.substr(0, startU16);
        size_t visualStart = curStart + WToUTF8(wSub).size();

        curLayout->Release();

        if (pos <= visualStart && !currentAffinity) {
            return logicalStart;
        }
        return visualStart;
    }
    size_t moveVisualEnd(size_t pos, bool currentAffinity, bool& outAffinity) {
        outAffinity = false;
        size_t logicalEnd = getLogicalLineEnd(pos);
        if (!wordWrapEnabled) return logicalEnd;

        RECT rc; GetClientRect(hwnd, &rc);
        float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if (pos > pt.length()) pos = pt.length();

        int curLineIdx = getLineIdx(pos);
        size_t curStart = lineStarts[curLineIdx];
        size_t curEnd = (curLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[curLineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') {
            curLineStr.pop_back();
            if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        }
        std::wstring curWLine = UTF8ToW(curLineStr);
        if (curWLine.empty()) return logicalEnd;

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return logicalEnd;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount == 0) curLineCount = 1;
        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        if (curActual == 0) curActual = 1;

        std::vector<UINT32> curVisualStarts(curActual);
        std::vector<UINT32> curVisualEnds(curActual);
        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            curVisualStarts[i] = cum;
            cum += curLineMetrics[i].length;
            curVisualEnds[i] = cum;
        }

        size_t utf8Off = (pos >= curStart) ? (pos - curStart) : 0;
        if (utf8Off > curLineStr.size()) utf8Off = curLineStr.size();
        UINT32 u16Idx = (UINT32)utf8OffsetToUtf16Count(curLineStr, utf8Off);
        if (u16Idx > curWLine.size()) u16Idx = (UINT32)curWLine.size();

        int curVisualLine = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (currentAffinity && i > 0 && u16Idx == curVisualStarts[i]) {
                curVisualLine = (int)i - 1;
                break;
            }
            if (i == curActual - 1 || u16Idx < curVisualEnds[i]) {
                curVisualLine = (int)i;
                break;
            }
        }

        UINT32 endU16 = curVisualEnds[curVisualLine];
        std::wstring wSub = curWLine.substr(0, endU16);
        size_t visualEnd = curStart + WToUTF8(wSub).size();

        curLayout->Release();

        if (pos >= visualEnd) {
            outAffinity = false;
            return logicalEnd;
        }
        if ((UINT32)curVisualLine + 1 < curActual) {
            outAffinity = true;
        } else {
            outAffinity = false;
        }
        return visualEnd;
    }
    bool isVisualLineWrapBoundary(size_t nextPos, size_t curPos) {
        if (!wordWrapEnabled) return false;
        int curLine = getLineIdx(curPos);
        int nextLine = getLineIdx(nextPos);
        if (curLine != nextLine) return false;

        size_t curStart = lineStarts[curLine];
        size_t curEnd = (curLine + 1 < (int)lineStarts.size()) ? lineStarts[curLine + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        if (curLen == 0) return false;

        RECT rc; GetClientRect(hwnd, &rc);
        float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if ((float)curLen * (8.0f * charWidth) < clientW) return false;

        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') {
            curLineStr.pop_back();
            if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        }
        std::wstring curWLine = UTF8ToW(curLineStr);
        if (curWLine.empty()) return false;

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return false;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount <= 1) {
            curLayout->Release();
            return false;
        }

        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        curLayout->Release();
        if (curActual <= 1) return false;

        size_t nextUtf8Off = (nextPos >= curStart) ? (nextPos - curStart) : 0;
        if (nextUtf8Off > curLineStr.size()) nextUtf8Off = curLineStr.size();
        UINT32 targetU16 = (UINT32)utf8OffsetToUtf16Count(curLineStr, nextUtf8Off);

        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (i > 0 && targetU16 == cum) {
                return true;
            }
            cum += curLineMetrics[i].length;
        }
        return false;
    }
    int getLineVisualCount(int lineIdx) {
        if (!wordWrapEnabled) return 1;
        if (lineIdx < 0 || lineIdx >= (int)lineStarts.size()) return 1;
        size_t curStart = lineStarts[lineIdx];
        size_t curEnd = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        if (curLen == 0) return 1;
        RECT rc; GetClientRect(hwnd, &rc);
        float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if ((float)curLen * charWidth < clientW) return 1;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') {
            curLineStr.pop_back();
            if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        }
        if (curLineStr.empty()) return 1;
        std::wstring curWLine = UTF8ToW(curLineStr);
        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, 1000000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return 1;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        curLayout->Release();
        UINT32 count = curTm.lineCount;
        return (count > 0) ? (int)count : 1;
    }
    void scrollVisualLines(int deltaLines) {
        if (deltaLines == 0) return;
        if (!wordWrapEnabled) {
            vScrollSubLine = 0;
            vScrollPos += deltaLines;
            int maxV = std::max(0, (int)lineStarts.size() - 1);
            if (vScrollPos < 0) vScrollPos = 0;
            if (vScrollPos > maxV) vScrollPos = maxV;
            updateScrollBars();
            return;
        }
        if (deltaLines > 0) {
            while (deltaLines > 0) {
                int lineCount = getLineVisualCount(vScrollPos);
                int availableInCur = lineCount - 1 - vScrollSubLine;
                if (deltaLines <= availableInCur) {
                    vScrollSubLine += deltaLines;
                    deltaLines = 0;
                } else {
                    if (vScrollPos + 1 >= (int)lineStarts.size()) {
                        vScrollSubLine = std::max(0, lineCount - 1);
                        break;
                    }
                    deltaLines -= (availableInCur + 1);
                    vScrollPos++;
                    vScrollSubLine = 0;
                }
            }
        } else {
            int toScroll = -deltaLines;
            while (toScroll > 0) {
                if (vScrollSubLine >= toScroll) {
                    vScrollSubLine -= toScroll;
                    toScroll = 0;
                } else {
                    toScroll -= (vScrollSubLine + 1);
                    if (vScrollPos > 0) {
                        vScrollPos--;
                        int prevCount = getLineVisualCount(vScrollPos);
                        vScrollSubLine = std::max(0, prevCount - 1);
                    } else {
                        vScrollSubLine = 0;
                        break;
                    }
                }
            }
        }
        updateScrollBars();
    }
    void updateScrollBars() {
        if (suppressUI || !hwnd) return; RECT rc; GetClientRect(hwnd, &rc); float clientH = (rc.bottom - rc.top) / dpiScaleY; float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth; if (clientW < 0) clientW = 0;
        int maxH = wordWrapEnabled ? 0 : std::max(0, (int)(maxLineWidth - clientW + charWidth * 4.0f)); if (hScrollPos > maxH) hScrollPos = maxH; if (hScrollPos < 0) hScrollPos = 0;
        int maxV = std::max(0, (int)lineStarts.size() - 1); if (vScrollPos > maxV) { vScrollPos = maxV; vScrollSubLine = 0; } if (vScrollPos < 0) { vScrollPos = 0; vScrollSubLine = 0; }
        if (vScrollSubLine < 0) vScrollSubLine = 0;
        if (!wordWrapEnabled) vScrollSubLine = 0;
    }
    void getCaretPoint(float& x, float& y) { if (cursors.empty()) { x = 0; y = 0; return; } const auto& mainCursor = cursors.back(); size_t pos = mainCursor.head; int line = getLineIdx(pos); float docY = line * lineHeight; float localX = getXFromPos(pos, mainCursor.affinity); x = (localX - hScrollPos + gutterWidth) * dpiScaleX; y = (docY - (vScrollPos * lineHeight) - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f)) * dpiScaleY; }
    void ensureCaretVisible() {
        if (cursors.empty()) return; Cursor& mainCursor = cursors.back(); RECT rc; GetClientRect(hwnd, &rc); float clientH = (rc.bottom - rc.top) / dpiScaleY; float clientW = (rc.right - rc.left) / dpiScaleX; int linesVisible = (int)(clientH / lineHeight); int caretLine = getLineIdx(mainCursor.head);
        if (vScrollPos < 0) vScrollPos = 0;
        if (!wordWrapEnabled) {
            vScrollSubLine = 0;
            if (caretLine < vScrollPos) vScrollPos = caretLine; else if (caretLine >= vScrollPos + linesVisible - 1) vScrollPos = caretLine - linesVisible + 2;
        }
        else {
            if (caretLine < vScrollPos) {
                vScrollPos = caretLine;
                vScrollSubLine = 0;
            }
            else {
                int searchStartLine = std::max(vScrollPos, caretLine - linesVisible);
                if (searchStartLine > vScrollPos) {
                    vScrollPos = searchStartLine;
                    vScrollSubLine = 0;
                }
            }
            size_t startPos = lineStarts[vScrollPos]; size_t endLine = caretLine + 1; if (endLine > lineStarts.size()) endLine = lineStarts.size();
            size_t endPos = (endLine < lineStarts.size()) ? lineStarts[endLine] : pt.length();
            if (endPos > startPos) {
                std::string chunk; pt.getRange(startPos, endPos - startPos, chunk); std::wstring wchunk; UTF8ToW(chunk, wchunk);
                IDWriteTextLayout* layout = nullptr; float w = clientW - gutterWidth; if (w < 10.0f) w = 10.0f;
                if (SUCCEEDED(dwFactory->CreateTextLayout(wchunk.c_str(), (UINT32)wchunk.size(), textFormat, w, 1000000.0f, &layout))) {
                    layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
                    size_t relHead = mainCursor.head - startPos; UINT32 u16Head = (UINT32)utf8OffsetToUtf16Count(chunk, relHead);
                    DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
                    if (mainCursor.affinity && u16Head > 0) {
                        layout->HitTestTextPosition(u16Head - 1, TRUE, &px, &py, &m);
                    } else {
                        layout->HitTestTextPosition(u16Head, FALSE, &px, &py, &m);
                    }
                    float caretViewY = py - (float)vScrollSubLine * lineHeight;
                    if (caretViewY < 0.0f) {
                        int targetSub = (int)(py / lineHeight);
                        vScrollSubLine = std::max(0, targetSub);
                    }
                    else {
                        float bottomMargin = lineHeight * 1.5f;
                        if (caretViewY + lineHeight > clientH || py + bottomMargin - (float)vScrollSubLine * lineHeight > clientH) {
                            float newTopY = py + bottomMargin - clientH;
                            if (newTopY > py) newTopY = py;
                            if (newTopY > 0.0f) {
                                int newVScroll = vScrollPos;
                                int newSubLine = 0;
                                for (int i = caretLine; i >= vScrollPos; --i) {
                                    size_t lineRelPos = lineStarts[i] - startPos; UINT32 lineU16 = (UINT32)utf8OffsetToUtf16Count(chunk, lineRelPos);
                                    DWRITE_HIT_TEST_METRICS mm; FLOAT px2, py2; layout->HitTestTextPosition(lineU16, FALSE, &px2, &py2, &mm);
                                    if (py2 <= newTopY) {
                                        newVScroll = i;
                                        float diff = newTopY - py2;
                                        newSubLine = (int)std::ceil(diff / lineHeight);
                                        break;
                                    }
                                }
                                vScrollPos = newVScroll;
                                vScrollSubLine = std::max(0, newSubLine);
                            }
                        }
                    }
                    layout->Release();
                }
            }
            else {
                vScrollSubLine = 0;
            }
        }
        if (vScrollPos < 0) vScrollPos = 0;
        if (vScrollSubLine < 0) vScrollSubLine = 0;
        float visibleTextW = clientW - gutterWidth; if (visibleTextW < charWidth) visibleTextW = charWidth; float caretX = getXFromPos(mainCursor.head, mainCursor.affinity); float margin = charWidth * 2.0f;
        if (!wordWrapEnabled) {
            if (caretX < hScrollPos + margin) hScrollPos = (int)(caretX - margin); else if (caretX > hScrollPos + visibleTextW - margin) hScrollPos = (int)(caretX - visibleTextW + margin);
            float requiredWidth = hScrollPos + visibleTextW + margin; if (caretX + margin * 4.0f > requiredWidth) requiredWidth = caretX + margin * 4.0f; if (requiredWidth > maxLineWidth) maxLineWidth = requiredWidth; if (hScrollPos < 0) hScrollPos = 0;
        }
        else { hScrollPos = 0; }
        updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE);
    }
    std::string textBuffer;
    std::wstring wtextBuffer;
    void buildVisibleText(int numLines, std::string& out) {
        out.clear();
        if (lineStarts.empty() || vScrollPos >= (int)lineStarts.size()) return;
        size_t startPos = lineStarts[vScrollPos]; int targetLine = vScrollPos + numLines; size_t endPos = (targetLine < (int)lineStarts.size()) ? lineStarts[targetLine] : pt.length(); if (endPos < startPos) return;
        pt.getRange(startPos, endPos - startPos, out);
    }
    size_t utf8OffsetToUtf16Count(const std::string& utf8str, size_t maxOffset) {
        size_t count = 0; size_t i = 0;
        while (i < maxOffset && i < utf8str.size()) {
            unsigned char c = (unsigned char)utf8str[i];
            if (c < 0x80) { i += 1; count += 1; }
            else if ((c & 0xE0) == 0xC0) { i += 2; count += 1; }
            else if ((c & 0xF0) == 0xE0) { i += 3; count += 1; }
            else if ((c & 0xF8) == 0xF0) { i += 4; count += 2; }
            else { i += 1; count += 1; }
        }
        return count;
    }
    size_t getDocPosFromPoint(int x, int y) {
        float dipX = x / dpiScaleX; float dipY = y / dpiScaleY; if (dipX < gutterWidth) dipX = gutterWidth; float virtualX = dipX - gutterWidth + hScrollPos; float virtualY = dipY + (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f);
        RECT rc; GetClientRect(hwnd, &rc); float clientH = (rc.bottom - rc.top) / dpiScaleY; float clientW = (rc.right - rc.left) / dpiScaleX - gutterWidth;
        int linesVisible = (int)(clientH / lineHeight) + 2; buildVisibleText(linesVisible + (wordWrapEnabled ? vScrollSubLine : 0), textBuffer); UTF8ToW(textBuffer, wtextBuffer); float layoutWidth = wordWrapEnabled ? clientW : (maxLineWidth + clientW);
        IDWriteTextLayout* layout = nullptr; HRESULT hr = dwFactory->CreateTextLayout(wtextBuffer.c_str(), (UINT32)wtextBuffer.size(), textFormat, layoutWidth, 1000000.0f, &layout); size_t resultPos = 0; size_t visibleStartOffset = (vScrollPos < (int)lineStarts.size()) ? lineStarts[vScrollPos] : pt.length();
        if (SUCCEEDED(hr) && layout) {
            if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
            BOOL isTrailing, isInside; DWRITE_HIT_TEST_METRICS metrics; layout->HitTestPoint(virtualX, virtualY, &isTrailing, &isInside, &metrics); UINT32 utf16Index = metrics.textPosition; if (isTrailing) utf16Index += metrics.length; if (utf16Index > wtextBuffer.size()) utf16Index = (UINT32)wtextBuffer.size(); std::wstring wsub = wtextBuffer.substr(0, utf16Index); std::string sub = WToUTF8(wsub); resultPos = visibleStartOffset + sub.size(); layout->Release();
        }
        if (resultPos > pt.length()) resultPos = pt.length(); return resultPos;
    }
    bool isWordChar(char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || (unsigned char)c >= 0x80; }
    void mergeCursors() {
        if (cursors.empty()) return; std::sort(cursors.begin(), cursors.end(), [](const Cursor& a, const Cursor& b) { return a.head < b.head; });
        std::vector<Cursor> merged; merged.push_back(cursors[0]);
        for (size_t i = 1; i < cursors.size(); ++i) { Cursor& prev = merged.back(); Cursor& curr = cursors[i]; if (curr.start() <= prev.end()) { size_t newStart = std::min(prev.start(), curr.start()); size_t newEnd = std::max(prev.end(), curr.end()); bool prevForward = prev.head >= prev.anchor; prev.anchor = prevForward ? newStart : newEnd; prev.head = prevForward ? newEnd : newStart; } else merged.push_back(curr); }
        cursors = merged;
    }
    void selectWordAt(size_t pos) {
        if (pos >= pt.length()) { cursors.clear(); cursors.push_back({ pos, pos, getXFromPos(pos) }); return; }
        char c = pt.charAt(pos); if (c == '\r') { if (pos + 1 < pt.length() && pt.charAt(pos + 1) == '\n') { cursors.clear(); cursors.push_back({ pos + 2, pos, getXFromPos(pos + 2) }); return; } }
        bool targetType = isWordChar(c); if (c == '\n') { cursors.clear(); cursors.push_back({ pos + 1, pos, getXFromPos(pos + 1) }); return; }
        size_t start = pos; while (start > 0) { char p = pt.charAt(start - 1); if (isWordChar(p) != targetType || p == '\n' || p == '\r') break; start--; }
        size_t end = pos; size_t len = pt.length(); while (end < len) { char p = pt.charAt(end); if (isWordChar(p) != targetType || p == '\n' || p == '\r') break; end++; }
        cursors.clear(); cursors.push_back({ end, start, getXFromPos(end) });
    }
    void selectLineAt(size_t pos) { int lineIdx = getLineIdx(pos); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); cursors.clear(); cursors.push_back({ end, start, getXFromPos(end) }); }
    size_t moveWordLeft(size_t pos) {
        if (pos == 0) return 0; size_t curr = pos; if (curr >= 2 && pt.charAt(curr - 1) == '\n' && pt.charAt(curr - 2) == '\r') return curr - 2; if (curr >= 1 && pt.charAt(curr - 1) == '\n') return curr - 1;
        while (curr > 0) { char c = pt.charAt(curr - 1); if (c == '\n' || c == '\r' || !isspace((unsigned char)c)) break; curr--; }
        if (curr == 0) return 0; char prev = pt.charAt(curr - 1); if (prev == '\n' || prev == '\r') return curr; bool type = isWordChar(prev);
        while (curr > 0) { char c = pt.charAt(curr - 1); if (c == '\n' || c == '\r' || isspace((unsigned char)c) || isWordChar(c) != type) break; curr--; } return curr;
    }
    size_t moveWordRight(size_t pos) {
        size_t len = pt.length(); if (pos >= len) return len; size_t curr = pos;
        if (pt.charAt(curr) == '\r') { if (curr + 1 < len && pt.charAt(curr + 1) == '\n') return curr + 2; return curr + 1; }
        if (pt.charAt(curr) == '\n') return curr + 1;
        if (!isspace((unsigned char)pt.charAt(curr))) { bool type = isWordChar(pt.charAt(curr)); while (curr < len) { char c = pt.charAt(curr); if (c == '\n' || c == '\r' || isspace((unsigned char)c) || isWordChar(c) != type) break; curr++; } }
        while (curr < len) { char c = pt.charAt(curr); if (c == '\n' || c == '\r' || !isspace((unsigned char)c)) break; curr++; } return curr;
    }
    size_t moveCaretVisual(size_t pos, bool forward) {
        size_t len = pt.length(); if (pos == 0 && !forward) return 0; if (pos >= len && forward) return len;
        if (forward) { char c = pt.charAt(pos); if (c == '\r') { if (pos + 1 < len && pt.charAt(pos + 1) == '\n') return pos + 2; } if (c == '\n') return pos + 1; }
        else { if (pos > 0) { char prev = pt.charAt(pos - 1); if (prev == '\n') { if (pos > 1 && pt.charAt(pos - 2) == '\r') return pos - 2; return pos - 1; } } }
        int lineIdx = getLineIdx(pos); size_t lineStart = lineStarts[lineIdx]; size_t nextLineStart = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : len; size_t lineEnd = nextLineStart; if (lineEnd > lineStart && pt.charAt(lineEnd - 1) == '\n') lineEnd--;
        if (pos < lineStart || pos > lineEnd) return forward ? std::min(pos + 1, len) : std::max(pos - 1, (size_t)0);
        std::string lineUtf8 = pt.getRange(lineStart, lineEnd - lineStart); std::wstring lineUtf16 = UTF8ToW(lineUtf8); size_t offsetInLine = pos - lineStart; std::string preUtf8 = lineUtf8.substr(0, offsetInLine); size_t u16Pos = UTF8ToW(preUtf8).length();
        IDWriteTextLayout* layout = nullptr; HRESULT hr = dwFactory->CreateTextLayout(lineUtf16.c_str(), (UINT32)lineUtf16.length(), textFormat, 10000000.0f, (FLOAT)lineHeight, &layout); size_t newU16Pos = u16Pos;
        if (SUCCEEDED(hr) && layout) {
            UINT32 clusterCount = 0; layout->GetClusterMetrics(NULL, 0, &clusterCount);
            if (clusterCount > 0) {
                std::vector<DWRITE_CLUSTER_METRICS> clusters(clusterCount); layout->GetClusterMetrics(clusters.data(), clusterCount, &clusterCount); size_t currentU16 = 0; bool found = false;
                if (forward) { for (const auto& cm : clusters) { size_t nextU16 = currentU16 + cm.length; if (u16Pos >= currentU16 && u16Pos < nextU16) { newU16Pos = nextU16; found = true; break; } currentU16 = nextU16; } if (!found) newU16Pos = u16Pos; }
                else { for (const auto& cm : clusters) { size_t nextU16 = currentU16 + cm.length; if (u16Pos > currentU16 && u16Pos <= nextU16) { newU16Pos = currentU16; found = true; break; } currentU16 = nextU16; } if (!found && u16Pos > 0) { if (u16Pos == lineUtf16.length()) { size_t c = 0; for (const auto& cm : clusters) { if (c + cm.length == u16Pos) { newU16Pos = c; break; } c += cm.length; } } } }
            } layout->Release();
        }
        if (newU16Pos != u16Pos) { std::wstring preNewW = lineUtf16.substr(0, newU16Pos); size_t newOffset = WToUTF8(preNewW).length(); return lineStart + newOffset; }
        return forward ? std::min(pos + 1, len) : std::max(pos - 1, (size_t)0);
    }
    size_t findText(size_t startPos, const std::string& query, bool forward, bool matchCase, bool wholeWord, bool isRegex, size_t* outLen = nullptr) {
        if (query.empty()) return std::string::npos; size_t len = pt.length(); std::string actualQuery = query; if (isRegex) actualQuery = preprocessRegexQuery(query);
        if (isRegex) {
            std::string fullText = pt.getRange(0, len);
            try {
                std::regex_constants::syntax_option_type flags = std::regex_constants::ECMAScript; if (!matchCase) flags |= std::regex_constants::icase; std::regex re(actualQuery, flags); std::smatch m; size_t foundPos = std::string::npos; size_t foundLen = 0; bool startsWithCaret = (!query.empty() && query[0] == '^'); bool endsWithDollar = (!query.empty() && query.back() == '$');
                if (forward) {
                    if (startPos > fullText.size()) startPos = 0; size_t searchStartIdx = startPos; std::regex_constants::match_flag_type searchFlags = std::regex_constants::match_default;
                    if (searchStartIdx > 0) { searchFlags |= std::regex_constants::match_not_bol; char prevChar = fullText[searchStartIdx - 1]; if (prevChar == '\n') { searchStartIdx--; if (searchStartIdx > 0 && fullText[searchStartIdx - 1] == '\r') searchStartIdx--; } else if (prevChar == '\r') searchStartIdx--; }
                    std::string::const_iterator searchStartIter = fullText.begin() + searchStartIdx;
                    while (std::regex_search(searchStartIter, fullText.cend(), m, re, searchFlags)) {
                        size_t currentMatchPos = searchStartIdx + m.position(); size_t currentMatchLen = m.length(); size_t anchorLen = 0;
                        if (startsWithCaret && m.size() > 1 && m[1].matched) anchorLen = m.length(1);
                        size_t contentPos = currentMatchPos + anchorLen; size_t contentLen = currentMatchLen - anchorLen; bool isValid = false; if (contentPos >= startPos) isValid = true;
                        if (isValid && endsWithDollar) { bool isAtLineEnd = false; size_t checkPos = contentPos + contentLen; if (checkPos >= fullText.size()) isAtLineEnd = true; else { char c = fullText[checkPos]; if (c == '\r' || c == '\n') { isAtLineEnd = true; if (contentLen == 0 && c == '\n' && checkPos > 0 && fullText[checkPos - 1] == '\r') isAtLineEnd = false; } } if (!isAtLineEnd) isValid = false; }
                        if (isValid) { foundPos = contentPos; foundLen = contentLen; if (startsWithCaret && endsWithDollar && foundLen == 0 && foundPos == fullText.size() && !fullText.empty()) { bool isAfterNewline = false; if (foundPos > 0) { char c = fullText[foundPos - 1]; if (c == '\r' || c == '\n') isAfterNewline = true; } if (!isAfterNewline) isValid = false; } if (isValid) break; }
                        size_t step = currentMatchLen; if (step == 0) { bool isBolCaret = (startsWithCaret && !(searchFlags & std::regex_constants::match_not_bol)); if (isBolCaret) step = 0; else step = 1; } if (step == 0 && (searchFlags & std::regex_constants::match_not_bol)) step = 1;
                        size_t dist = std::distance(searchStartIter, fullText.cend()); if ((size_t)m.position() + step > dist) break; size_t advance = m.position() + step; std::advance(searchStartIter, advance); searchStartIdx += advance; searchFlags |= std::regex_constants::match_not_bol;
                    }
                    if (foundPos == std::string::npos && startPos > 0) {
                        if (std::regex_search(fullText.cbegin(), fullText.cend(), m, re)) {
                            size_t mPos = m.position(); size_t mLen = m.length(); size_t aLen = 0; if (startsWithCaret && m.size() > 1 && m[1].matched) aLen = m.length(1); bool split = false; if (startsWithCaret && aLen == 1 && mPos < fullText.size() && fullText[mPos] == '\r') { if (mPos + 1 < fullText.size() && fullText[mPos + 1] == '\n') split = true; }
                            if (!split) {
                                size_t cPos = mPos + aLen; size_t cLen = mLen - aLen; bool valid = true; if (endsWithDollar) { size_t check = cPos + cLen; if (check < fullText.size()) { char c = fullText[check]; if (c == '\r' || c == '\n') { if (cLen == 0 && c == '\n' && check > 0 && fullText[check - 1] == '\r') valid = false; } else valid = false; } }
                                if (startsWithCaret && endsWithDollar && cLen == 0 && cPos == fullText.size() && !fullText.empty()) { bool isAfterNL = false; if (cPos > 0) { char c = fullText[cPos - 1]; if (c == '\r' || c == '\n') isAfterNL = true; } if (!isAfterNL) valid = false; }
                                if (valid) { foundPos = cPos; foundLen = cLen; }
                            }
                        }
                    }
                }
                else {
                    auto words_begin = std::sregex_iterator(fullText.begin(), fullText.end(), re); auto words_end = std::sregex_iterator(); size_t bestPos = std::string::npos; size_t bestLen = 0; size_t limit = (startPos == 0) ? len : startPos;
                    for (auto i = words_begin; i != words_end; ++i) {
                        size_t mPos = i->position(); size_t mLen = i->length(); size_t aLen = 0; if (startsWithCaret && i->size() > 1 && (*i)[1].matched) aLen = i->length(1);
                        if (startsWithCaret && aLen == 1 && mPos < fullText.size() && fullText[mPos] == '\r') { if (mPos + 1 < fullText.size() && fullText[mPos + 1] == '\n') continue; }
                        size_t contentStart = mPos + aLen; size_t contentLen = mLen - aLen; if (endsWithDollar) { bool isAtEnd = (contentStart + contentLen >= fullText.size()); if (!isAtEnd) { char c = fullText[contentStart + contentLen]; if (c == '\r' || c == '\n') { if (contentLen == 0 && c == '\n' && contentStart + contentLen > 0 && fullText[contentStart + contentLen - 1] == '\r') continue; } else continue; } }
                        if (startsWithCaret && endsWithDollar && contentLen == 0 && contentStart == fullText.size() && !fullText.empty()) { bool isAfterNL = false; if (contentStart > 0) { char c = fullText[contentStart - 1]; if (c == '\r' || c == '\n') isAfterNL = true; } if (!isAfterNL) continue; }
                        if (contentStart < limit) { bestPos = contentStart; bestLen = contentLen; }
                    }
                    if (bestPos != std::string::npos) { foundPos = bestPos; foundLen = bestLen; }
                }
                if (foundPos != std::string::npos) { if (outLen) *outLen = foundLen; return foundPos; }
            }
            catch (...) { return std::string::npos; }
            return std::string::npos;
        }
        size_t qLen = query.length(); if (outLen) *outLen = qLen; auto toLower = [](char c) { return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c; }; size_t cur = startPos;
        if (forward) { if (cur >= len) cur = 0; }
        else { if (cur == 0) cur = len; else cur--; } size_t count = 0;
        while (count < len) {
            bool match = true;
            for (size_t i = 0; i < qLen; ++i) { size_t p = cur + i; if (p >= len) { match = false; break; } char c1 = pt.charAt(p); char c2 = query[i]; if (!matchCase) { c1 = toLower(c1); c2 = toLower(c2); } if (c1 != c2) { match = false; break; } }
            if (match && wholeWord) { if (cur > 0 && isWordChar(pt.charAt(cur - 1))) match = false; if (match && (cur + qLen < len) && isWordChar(pt.charAt(cur + qLen))) match = false; }
            if (match) { size_t nextPos = cur + qLen; if (nextPos < len) { unsigned char b1 = (unsigned char)pt.charAt(nextPos); if (b1 == 0xE2 && nextPos + 2 < len) { unsigned char b2 = (unsigned char)pt.charAt(nextPos + 1); unsigned char b3 = (unsigned char)pt.charAt(nextPos + 2); if (b2 == 0x80 && b3 == 0x8D) match = false; } else if (b1 == 0xEF && nextPos + 2 < len) { unsigned char b2 = (unsigned char)pt.charAt(nextPos + 1); unsigned char b3 = (unsigned char)pt.charAt(nextPos + 2); if (b2 == 0xB8 && b3 == 0x8F) match = false; } else if (b1 == 0xF0 && nextPos + 3 < len) { unsigned char b2 = (unsigned char)pt.charAt(nextPos + 1); unsigned char b3 = (unsigned char)pt.charAt(nextPos + 2); unsigned char b4 = (unsigned char)pt.charAt(nextPos + 3); if (b2 == 0x9F && b3 == 0x8F && (b4 >= 0xBB && b4 <= 0xBF)) match = false; } } }
            if (match) return cur;
            if (forward) { cur++; if (cur >= len) cur = 0; }
            else { if (cur == 0) cur = len - 1; else cur--; } count++;
        }
        return std::string::npos;
    }
    void findNext(bool forward) {
        if (searchQuery.empty()) { showFindDialog(false); return; }
        size_t currentCursorPos = forward ? (cursors.empty() ? 0 : cursors.back().end()) : (cursors.empty() ? 0 : cursors.back().start());
        size_t searchStart = currentCursorPos; bool hasWrapped = false;
        while (true) {
            size_t matchLen = 0; size_t pos = findText(searchStart, searchQuery, forward, searchMatchCase, searchWholeWord, searchRegex, &matchLen);
            if (pos == std::string::npos) {
                if (forward && !hasWrapped) { searchStart = 0; hasWrapped = true; continue; }
                else if (!forward && !hasWrapped) { searchStart = pt.length(); hasWrapped = true; continue; }
                MessageBeep(MB_ICONWARNING); return;
            }
            size_t matchEnd = pos + matchLen;
            if (forward) {
                if (!hasWrapped && matchEnd <= currentCursorPos) {
                    size_t nextStart = searchStart + 1;
                    if (searchStart + 1 < pt.length() && pt.charAt(searchStart) == '\r' && pt.charAt(searchStart + 1) == '\n') nextStart++;
                    searchStart = nextStart; if (searchStart > pt.length()) { searchStart = 0; hasWrapped = true; } continue;
                }
            }
            cursors.clear(); cursors.push_back({ matchEnd, pos, getXFromPos(matchEnd) }); ensureCaretVisible(); updateTitleBar(); break;
        }
    }
    void replaceNext() {
        if (cursors.empty() || searchQuery.empty()) return; Cursor& c = cursors.back(); if (!c.hasSelection()) { findNext(true); return; }
        size_t len = c.end() - c.start(); size_t start = c.start(); std::string selText = pt.getRange(start, len); bool match = false; std::string replacement = replaceQuery;
        if (searchRegex) {
            try {
                std::string actualQuery = preprocessRegexQuery(searchQuery); std::regex_constants::syntax_option_type flags = std::regex_constants::ECMAScript;
                if (!searchMatchCase) flags |= std::regex_constants::icase; std::regex re(actualQuery, flags); std::smatch m; std::string rawFmt = UnescapeString(replaceQuery, newlineStr); std::string fmt;
                for (size_t i = 0; i < rawFmt.size(); ++i) {
                    if (rawFmt[i] == '$') {
                        fmt += '$'; if (i + 1 < rawFmt.size()) {
                            if (isdigit((unsigned char)rawFmt[i + 1])) {
                                i++; std::string numStr; while (i < rawFmt.size() && isdigit((unsigned char)rawFmt[i])) { numStr += rawFmt[i]; i++; } i--;
                                int grp = std::stoi(numStr); if (grp > 0) grp++; fmt += std::to_string(grp);
                            }
                            else { fmt += rawFmt[i + 1]; i++; }
                        }
                    }
                    else fmt += rawFmt[i];
                }
                if (std::regex_match(selText, m, re)) match = true;
                else if (start > 0) {
                    int backStep = 0; if (pt.charAt(start - 1) == '\n') { backStep = 1; if (start > 1 && pt.charAt(start - 2) == '\r') backStep = 2; }
                    else if (pt.charAt(start - 1) == '\r') backStep = 1;
                    if (backStep > 0) { std::string extendedText = pt.getRange(start - backStep, len + backStep); if (std::regex_match(extendedText, m, re)) match = true; }
                }
                if (match) replacement = m.format(fmt);
            }
            catch (...) {}
        }
        else {
            if (len == searchQuery.length()) {
                match = true; for (size_t i = 0; i < len; ++i) {
                    char c1 = selText[i]; char c2 = searchQuery[i]; if (!searchMatchCase) { c1 = (c1 >= 'A' && c1 <= 'Z') ? c1 + ('a' - 'A') : c1; c2 = (c2 >= 'A' && c2 <= 'Z') ? c2 + ('a' - 'A') : c2; }
                    if (c1 != c2) { match = false; break; }
                }
            }
            if (match) replacement = replaceQuery;
        }
        if (match) {
            commitPadding(); EditBatch batch; batch.beforeCursors = cursors; pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, selText });
            pt.insert(start, replacement); batch.ops.push_back({ EditOp::Insert, start, replacement }); cursors.clear(); cursors.push_back({ start + replacement.size(), start, getXFromPos(start + replacement.size()) });
            batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); findNext(true);
        }
        else findNext(true);
    }
    void replaceAll() {
        if (searchQuery.empty()) return; struct Match { size_t start; size_t len; std::string replacementText; }; std::vector<Match> matches; size_t docLen = pt.length(); ensureRegexReady();
        if (searchRegex) {
            if (isRegexValid) {
                std::string fullText = pt.getRange(0, docLen); std::string rawFmt = UnescapeString(replaceQuery, newlineStr); std::string fmt;
                for (size_t i = 0; i < rawFmt.size(); ++i) {
                    if (rawFmt[i] == '$') { fmt += '$'; if (i + 1 < rawFmt.size()) { if (isdigit((unsigned char)rawFmt[i + 1])) { i++; std::string numStr; while (i < rawFmt.size() && isdigit((unsigned char)rawFmt[i])) { numStr += rawFmt[i]; i++; } i--; int grp = std::stoi(numStr); if (grp > 0) grp++; fmt += std::to_string(grp); } else { fmt += rawFmt[i + 1]; i++; } } }
                    else fmt += rawFmt[i];
                }
                try {
                    bool startsWithCaret = (!searchQuery.empty() && searchQuery[0] == '^'); bool endsWithDollar = (!searchQuery.empty() && searchQuery.back() == '$');
                    auto searchStart = fullText.cbegin(); std::smatch m; size_t currentOffset = 0; std::regex_constants::match_flag_type flags = std::regex_constants::match_default;
                    while (std::regex_search(searchStart, fullText.cend(), m, cachedRegex, flags)) {
                        size_t matchPos = currentOffset + m.position(); size_t matchLen = m.length(); size_t anchorLen = 0;
                        if (startsWithCaret && m.size() > 1 && m[1].matched) anchorLen = m.length(1);
                        size_t contentPos = matchPos + anchorLen; size_t contentLen = matchLen - anchorLen;
                        if (endsWithDollar) { if (contentLen > 0) { if (fullText[contentPos + contentLen - 1] == '\n') { contentLen--; if (contentLen > 0 && fullText[contentPos + contentLen - 1] == '\r') contentLen--; } } }
                        bool isValid = true;
                        if (endsWithDollar) { bool isAtLineEnd = false; size_t checkPos = contentPos + contentLen; if (checkPos >= fullText.size()) isAtLineEnd = true; else { char c = fullText[checkPos]; if (c == '\r' || c == '\n') { isAtLineEnd = true; if (contentLen == 0 && c == '\n' && checkPos > 0 && fullText[checkPos - 1] == '\r') isAtLineEnd = false; } } if (!isAtLineEnd) isValid = false; }
                        if (isValid && startsWithCaret && endsWithDollar && contentLen == 0 && contentPos == fullText.size() && !fullText.empty()) { bool isAfterNewline = false; if (contentPos > 0) { char c = fullText[contentPos - 1]; if (c == '\r' || c == '\n') isAfterNewline = true; } if (!isAfterNewline) isValid = false; }
                        if (isValid && !matches.empty()) { const auto& last = matches.back(); if (last.start == contentPos && last.len == 0 && contentLen == 0) isValid = false; }
                        if (isValid) { std::string rText = m.format(fmt); matches.push_back({ contentPos, contentLen, rText }); }
                        size_t step = matchLen; if (step == 0) { bool isBolCaret = (startsWithCaret && !(flags & std::regex_constants::match_not_bol)); if (isBolCaret) step = 0; else step = 1; }
                        if (step == 0 && (flags & std::regex_constants::match_not_bol)) step = 1; size_t relativeAdvance = m.position() + step; size_t remaining = std::distance(searchStart, fullText.cend());
                        if (relativeAdvance > remaining) break; std::advance(searchStart, relativeAdvance); currentOffset += relativeAdvance; flags |= std::regex_constants::match_not_bol;
                    }
                    if (startsWithCaret && fullText.empty()) { bool alreadyMatched = !matches.empty(); if (!alreadyMatched) matches.push_back({ 0, 0, fmt }); }
                }
                catch (...) { return; }
            }
        }
        else {
            size_t currentPos = 0;
            while (true) { size_t matchLen = 0; size_t pos = findText(currentPos, searchQuery, true, searchMatchCase, searchWholeWord, false, &matchLen); if (pos == std::string::npos || pos < currentPos) break; matches.push_back({ pos, matchLen, replaceQuery }); currentPos = pos + matchLen; if (currentPos > docLen) break; }
        }
        if (matches.empty()) { MessageBeep(MB_ICONASTERISK); return; }
        commitPadding(); EditBatch batch; batch.beforeCursors = cursors;
        for (auto it = matches.rbegin(); it != matches.rend(); ++it) {
            size_t start = it->start; size_t len = it->len; if (start + len > pt.length()) continue;
            std::string deleted = pt.getRange(start, len); pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, deleted }); pt.insert(start, it->replacementText); batch.ops.push_back({ EditOp::Insert, start, it->replacementText });
        }
        size_t finalMatchIdx = matches.size() - 1; long long offsetBeforeFinal = 0; for (size_t i = 0; i < finalMatchIdx; ++i) { offsetBeforeFinal += (long long)matches[i].replacementText.size() - (long long)matches[i].len; }
        size_t lastReplaceStart = (size_t)((long long)matches.back().start + offsetBeforeFinal); size_t lastReplaceEnd = lastReplaceStart + matches.back().replacementText.size();
        cursors.clear(); cursors.push_back({ lastReplaceEnd, lastReplaceStart, getXFromPos(lastReplaceEnd) }); batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
        ShowTaskDialog(GetResString(IDS_REPLACE_DONE).c_str(), (std::to_wstring(matches.size()) + GetResString(IDS_REPLACE_COUNT)).c_str(), nullptr, TDCBF_OK_BUTTON, TD_INFORMATION_ICON);
        if (hFindDlg && IsWindowVisible(hFindDlg)) SetFocus(hFindDlg);
    }
    void updateFindReplaceUI(HWND dlg, bool replaceMode) {
        if (!dlg) return; isReplaceMode = replaceMode; int show = replaceMode ? SW_SHOW : SW_HIDE; ShowWindow(GetDlgItem(dlg, IDC_REPLACE_LABEL), show); ShowWindow(GetDlgItem(dlg, IDC_REPLACE_EDIT), show); ShowWindow(GetDlgItem(dlg, IDC_REPLACE_BTN), show); ShowWindow(GetDlgItem(dlg, IDC_REPLACE_ALL_BTN), show); SetWindowTextW(dlg, replaceMode ? GetResString(IDS_REPLACE_TITLE).c_str() : GetResString(IDS_FIND_TITLE).c_str());
    }
    static INT_PTR CALLBACK FindDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
        Editor* pThis = (Editor*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
        switch (message) {
        case WM_INITDIALOG:
            pThis = (Editor*)lParam; SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)pThis);
            if (pThis && pThis->isDarkMode) {
                ApplyDialogTheme(hDlg, true);
            }
            { RECT rcParent, rcDlg; GetWindowRect(pThis->hwnd, &rcParent); GetWindowRect(hDlg, &rcDlg); int x = rcParent.left + ((rcParent.right - rcParent.left) - (rcDlg.right - rcDlg.left)) / 2; int y = rcParent.top + ((rcParent.bottom - rcParent.top) - (rcDlg.bottom - rcDlg.top)) / 2; SetWindowPos(hDlg, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER); }
            SetDlgItemTextW(hDlg, IDC_FIND_EDIT, UTF8ToW(pThis->searchQuery).c_str()); SetDlgItemTextW(hDlg, IDC_REPLACE_EDIT, UTF8ToW(pThis->replaceQuery).c_str()); CheckDlgButton(hDlg, IDC_FIND_CASE, pThis->searchMatchCase ? BST_CHECKED : BST_UNCHECKED); CheckDlgButton(hDlg, IDC_FIND_WORD, pThis->searchWholeWord ? BST_CHECKED : BST_UNCHECKED); CheckDlgButton(hDlg, IDC_FIND_REGEX, pThis->searchRegex ? BST_CHECKED : BST_UNCHECKED); pThis->updateFindReplaceUI(hDlg, pThis->isReplaceMode); SetFocus(GetDlgItem(hDlg, IDC_FIND_EDIT)); SendMessage(GetDlgItem(hDlg, IDC_FIND_EDIT), EM_SETSEL, 0, -1); return FALSE;
        case WM_CTLCOLORDLG:
            if (pThis && pThis->isDarkMode) {
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLORSTATIC:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkMode(hdc, TRANSPARENT);
                SetTextColor(hdc, RGB(230, 230, 230));
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLOREDIT:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkColor(hdc, RGB(30, 30, 30));
                SetTextColor(hdc, RGB(255, 255, 255));
                static HBRUSH hbrDarkEdit = CreateSolidBrush(RGB(30, 30, 30));
                return (INT_PTR)hbrDarkEdit;
            }
            break;
        case WM_ACTIVATE: if (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE) { HWND hEdit = GetDlgItem(hDlg, IDC_FIND_EDIT); if (hEdit) { SetFocus(hEdit); SendMessage(hEdit, EM_SETSEL, 0, -1); } } return FALSE;
        case WM_COMMAND:
            if (LOWORD(wParam) == IDC_FIND_CASE || LOWORD(wParam) == IDC_FIND_WORD || LOWORD(wParam) == IDC_FIND_REGEX) { bool bCase = IsDlgButtonChecked(hDlg, IDC_FIND_CASE) == BST_CHECKED; bool bWord = IsDlgButtonChecked(hDlg, IDC_FIND_WORD) == BST_CHECKED; bool bRegex = IsDlgButtonChecked(hDlg, IDC_FIND_REGEX) == BST_CHECKED; pThis->updateSearchFlags(bCase, bWord, bRegex); InvalidateRect(pThis->hwnd, NULL, FALSE); }
            if (HIWORD(wParam) == EN_CHANGE) { wchar_t wbuf[1024]; if (LOWORD(wParam) == IDC_FIND_EDIT) { GetDlgItemTextW(hDlg, IDC_FIND_EDIT, wbuf, 1024); pThis->updateSearchQuery(WToUTF8(wbuf)); InvalidateRect(pThis->hwnd, NULL, FALSE); } if (LOWORD(wParam) == IDC_REPLACE_EDIT) { GetDlgItemTextW(hDlg, IDC_REPLACE_EDIT, wbuf, 1024); pThis->replaceQuery = WToUTF8(wbuf); } }
            if (LOWORD(wParam) == IDC_FIND_NEXT || LOWORD(wParam) == IDOK) { pThis->findNext(true); return TRUE; }
            if (LOWORD(wParam) == IDC_REPLACE_BTN) { if (!pThis->isReplaceMode) return TRUE; pThis->replaceNext(); return TRUE; }
            if (LOWORD(wParam) == IDC_REPLACE_ALL_BTN) { if (!pThis->isReplaceMode) return TRUE; pThis->replaceAll(); return TRUE; }
            if (LOWORD(wParam) == IDC_FIND_CANCEL || LOWORD(wParam) == IDCANCEL) { DestroyWindow(hDlg); pThis->hFindDlg = NULL; return TRUE; }
            break;
        } return FALSE;
    }
    void showFindDialog(bool replaceMode) {
        isReplaceMode = replaceMode; auto [candidate, _] = getHighlightTarget(); bool hasSelection = !cursors.empty() && cursors.back().hasSelection(); bool shouldUpdate = false;
        if (hasSelection) { if (!candidate.empty()) shouldUpdate = true; }
        else { if (searchQuery.empty() && !candidate.empty()) shouldUpdate = true; }
        if (shouldUpdate) updateSearchQuery(candidate);
        if (hFindDlg) { updateFindReplaceUI(hFindDlg, isReplaceMode); SetFocus(hFindDlg); if (shouldUpdate) { SetDlgItemTextW(hFindDlg, IDC_FIND_EDIT, UTF8ToW(searchQuery).c_str()); SendMessage(GetDlgItem(hFindDlg, IDC_FIND_EDIT), EM_SETSEL, 0, -1); } return; }
        hFindDlg = CreateDialogParamW(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_FIND_DIALOG), hwnd, FindDlgProc, (LPARAM)this); ShowWindow(hFindDlg, SW_SHOW);
    }
    void gotoLine(int lineOneBased) { int totalLines = (int)lineStarts.size(); if (totalLines == 0) return; int target = lineOneBased; if (target < 1) target = 1; if (target > totalLines) target = totalLines; int lineIdx = target - 1; size_t newPos = lineStarts[lineIdx]; rollbackPadding(); cursors.clear(); cursors.push_back({ newPos, newPos, getXFromPos(newPos) }); vScrollSubLine = 0; ensureCaretVisible(); updateTitleBar(); InvalidateRect(hwnd, NULL, FALSE); }

    char getMatchingBracketChar(char c) {
        if (c == '(') return ')';
        if (c == '[') return ']';
        if (c == '{') return '}';
        if (c == ')') return '(';
        if (c == ']') return '[';
        if (c == '}') return '{';
        return '\0';
    }

    bool isForwardBracket(char c) { return c == '(' || c == '[' || c == '{'; }

    bool findMatchingBracketFromIter(size_t p, size_t& matchPos) {
        if (p >= pt.length()) return false;
        char c = pt.charAt(p);
        char m = getMatchingBracketChar(c);
        if (!m) return false;

        int depth = 1;
        if (isForwardBracket(c)) {
            for (size_t i = p + 1; i < pt.length(); ++i) {
                char curr = pt.charAt(i);
                if (curr == c) depth++;
                else if (curr == m) {
                    depth--;
                    if (depth == 0) { matchPos = i; return true; }
                }
            }
        }
        else {
            if (p == 0) return false;
            for (size_t i = p - 1; ; --i) {
                char curr = pt.charAt(i);
                if (curr == c) depth++;
                else if (curr == m) {
                    depth--;
                    if (depth == 0) { matchPos = i; return true; }
                }
                if (i == 0) break;
            }
        }
        return false;
    }

    bool getAdjacentBrackets(size_t pos, size_t& p1, size_t& p2) {
        if (pos < pt.length()) {
            if (findMatchingBracketFromIter(pos, p2)) { p1 = pos; return true; }
        }
        if (pos > 0) {
            if (findMatchingBracketFromIter(pos - 1, p2)) { p1 = pos - 1; return true; }
        }
        return false;
    }

    void jumpToMatchingBracket() {
        if (cursors.empty()) return;
        rollbackPadding();
        size_t pos = cursors.back().head;
        size_t p1, p2;
        if (getAdjacentBrackets(pos, p1, p2)) {
            size_t target = p2;
            cursors.clear();
            cursors.push_back({ target, target, getXFromPos(target) });
            ensureCaretVisible();
            updateTitleBar();
            InvalidateRect(hwnd, NULL, FALSE);
        }
    }

    void jumpToFileEdge(bool start, bool select) { size_t target = start ? 0 : pt.length(); if (!select) { cursors.clear(); cursors.push_back({ target, target, getXFromPos(target) }); } else { for (auto& c : cursors) { c.head = target; c.desiredX = getXFromPos(c.head); } } if (start) { vScrollPos = 0; vScrollSubLine = 0; hScrollPos = 0; } ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
    static INT_PTR CALLBACK GoToDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
        Editor* pThis = (Editor*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
        switch (message) {
        case WM_INITDIALOG:
            pThis = (Editor*)lParam; SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)pThis);
            if (pThis && pThis->isDarkMode) {
                ApplyDialogTheme(hDlg, true);
            }
            { RECT rcParent, rcDlg; GetWindowRect(pThis->hwnd, &rcParent); GetWindowRect(hDlg, &rcDlg); int x = rcParent.left + ((rcParent.right - rcParent.left) - (rcDlg.right - rcDlg.left)) / 2; int y = rcParent.top + ((rcParent.bottom - rcParent.top) - (rcDlg.bottom - rcDlg.top)) / 2; SetWindowPos(hDlg, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER); wchar_t fmt[256]; GetDlgItemTextW(hDlg, IDC_GOTO_LABEL, fmt, 256); wchar_t buf[256]; swprintf_s(buf, fmt, (int)pThis->lineStarts.size()); SetDlgItemTextW(hDlg, IDC_GOTO_LABEL, buf); size_t curPos = pThis->cursors.empty() ? 0 : pThis->cursors.back().head; int curLine = pThis->getLineIdx(curPos) + 1; SetDlgItemInt(hDlg, IDC_GOTO_EDIT, curLine, FALSE); SetFocus(GetDlgItem(hDlg, IDC_GOTO_EDIT)); SendMessage(GetDlgItem(hDlg, IDC_GOTO_EDIT), EM_SETSEL, 0, -1); } return FALSE;
        case WM_CTLCOLORDLG:
            if (pThis && pThis->isDarkMode) {
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLORSTATIC:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkMode(hdc, TRANSPARENT);
                SetTextColor(hdc, RGB(230, 230, 230));
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLOREDIT:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkColor(hdc, RGB(30, 30, 30));
                SetTextColor(hdc, RGB(255, 255, 255));
                static HBRUSH hbrDarkEdit = CreateSolidBrush(RGB(30, 30, 30));
                return (INT_PTR)hbrDarkEdit;
            }
            break;
        case WM_COMMAND: if (LOWORD(wParam) == IDOK) { BOOL translated = FALSE; int line = GetDlgItemInt(hDlg, IDC_GOTO_EDIT, &translated, FALSE); if (translated) pThis->gotoLine(line); EndDialog(hDlg, IDOK); return TRUE; } if (LOWORD(wParam) == IDCANCEL) { EndDialog(hDlg, IDCANCEL); return TRUE; } break;
        } return FALSE;
    }
    void showGoToDialog() { DialogBoxParamW(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_GOTO_DIALOG), hwnd, GoToDlgProc, (LPARAM)this); }
    void rollbackPadding() {
        if (pendingPadding.ops.empty()) return;
        for (int i = (int)pendingPadding.ops.size() - 1; i >= 0; --i) { const auto& op = pendingPadding.ops[i]; if (op.type == EditOp::Insert) { pt.erase(op.pos, op.text.size()); size_t len = op.text.size(); for (auto& c : cursors) { if (c.head > op.pos) { if (c.head < op.pos + len) c.head = op.pos; else c.head -= len; } if (c.anchor > op.pos) { if (c.anchor < op.pos + len) c.anchor = op.pos; else c.anchor -= len; } } } }
        pendingPadding.ops.clear(); pendingPadding.beforeCursors.clear(); pendingPadding.afterCursors.clear(); rebuildLineStarts();
    }
    void commitPadding() { if (pendingPadding.ops.empty()) return; undo.push(pendingPadding); pendingPadding.ops.clear(); pendingPadding.beforeCursors.clear(); pendingPadding.afterCursors.clear(); }
    void updateRectSelection() {
        suppressUI = true; if (pendingPadding.ops.empty()) pendingPadding.beforeCursors = cursors; rollbackPadding();
        int startLineIdx = std::min(rectAnchorLine, rectHeadLine); int endLineIdx = std::max(rectAnchorLine, rectHeadLine); if (startLineIdx < 0) startLineIdx = 0; int currentMaxLine = (int)lineStarts.size() - 1;
        if (endLineIdx > currentMaxLine) { int linesToAdd = endLineIdx - currentMaxLine; size_t insertPos = pt.length(); std::string newLines; for (int k = 0; k < linesToAdd; ++k) newLines += newlineStr; pt.insert(insertPos, newLines); pendingPadding.ops.push_back({ EditOp::Insert, insertPos, newLines }); rebuildLineStarts(); }
        if (endLineIdx >= (int)lineStarts.size()) endLineIdx = (int)lineStarts.size() - 1; float targetAnchorX = rectAnchorX; float targetHeadX = rectHeadX; std::vector<int> lines; for (int i = startLineIdx; i <= endLineIdx; ++i) lines.push_back(i); std::reverse(lines.begin(), lines.end()); cursors.clear(); float requiredX = std::max(targetAnchorX, targetHeadX);
        for (int lineIdx : lines) { size_t start = lineStarts[lineIdx]; size_t nextStart = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); size_t end = nextStart; if (end > start && pt.charAt(end - 1) == '\n') end--; if (end > start && pt.charAt(end - 1) == '\r') end--; std::string lineStr = pt.getRange(start, end - start); std::wstring wLine = UTF8ToW(lineStr); float currentWidth = (float)wLine.length() * charWidth; if (requiredX > currentWidth) { int spacesNeeded = (int)((requiredX - currentWidth) / charWidth + 0.5f); if (spacesNeeded > 0) { std::string spaces(spacesNeeded, ' '); pt.insert(end, spaces); pendingPadding.ops.push_back({ EditOp::Insert, end, spaces }); } } }
        if (!pendingPadding.ops.empty()) rebuildLineStarts();
        for (int i = startLineIdx; i <= endLineIdx; ++i) { size_t anc = getPosFromLineAndX(i, targetAnchorX); size_t hd = getPosFromLineAndX(i, targetHeadX); cursors.push_back({ hd, anc, targetHeadX }); } suppressUI = false; rebuildLineStarts(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void performDragMove() {
        if (dragMoveDestPos >= dragMoveSourceStart && dragMoveDestPos <= dragMoveSourceEnd) return; std::string text = pt.getRange(dragMoveSourceStart, dragMoveSourceEnd - dragMoveSourceStart); EditBatch batch; batch.beforeCursors = cursors; pt.erase(dragMoveSourceStart, text.size()); batch.ops.push_back({ EditOp::Erase, dragMoveSourceStart, text }); size_t insertPos = dragMoveDestPos; if (insertPos > dragMoveSourceStart) insertPos -= text.size(); pt.insert(insertPos, text); batch.ops.push_back({ EditOp::Insert, insertPos, text }); cursors.clear(); cursors.push_back({ insertPos + text.size(), insertPos, getXFromPos(insertPos + text.size()) }); batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag();
    }
    void render() {
        if (!rend || !swapChain) return;
        if (!targetBitmap) {
            IDXGISurface* dxgiBackBuffer = nullptr; swapChain->GetBuffer(0, __uuidof(IDXGISurface), (void**)&dxgiBackBuffer);
            if (dxgiBackBuffer) {
                D2D1_BITMAP_PROPERTIES1 bitmapProperties = D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW, D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED), 96.0f * dpiScaleX, 96.0f * dpiScaleY);
                rend->CreateBitmapFromDxgiSurface(dxgiBackBuffer, &bitmapProperties, &targetBitmap); dxgiBackBuffer->Release();
            }
        }
        rend->SetTarget(targetBitmap);
        rend->BeginDraw();
        rend->Clear(background);
        RECT rc; GetClientRect(hwnd, &rc); D2D1_SIZE_F size = rend->GetSize(); float clientW = size.width; float clientH = size.height; int linesVisible = (int)(clientH / lineHeight) + 2; buildVisibleText(linesVisible + (wordWrapEnabled ? vScrollSubLine : 0), textBuffer); std::string& text = textBuffer; size_t visibleStartOffset = (vScrollPos < (int)lineStarts.size()) ? lineStarts[vScrollPos] : pt.length(); size_t mainCaretPos = cursors.empty() ? 0 : cursors.back().head; size_t caretOffsetInVisible = std::string::npos; if (mainCaretPos >= visibleStartOffset) caretOffsetInVisible = mainCaretPos - visibleStartOffset; bool hasIME = !imeComp.empty() && caretOffsetInVisible != std::string::npos && caretOffsetInVisible <= text.size(); if (hasIME) text.insert(caretOffsetInVisible, imeComp); UTF8ToW(text, wtextBuffer); float actualClientW = clientW - gutterWidth; if (actualClientW < 0) actualClientW = 0; float layoutWidth = wordWrapEnabled ? actualClientW : (maxLineWidth + clientW); IDWriteTextLayout* layout = nullptr; ID2D1SolidColorBrush* caretBrush = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(wtextBuffer.c_str(), (UINT32)wtextBuffer.size(), textFormat, layoutWidth, 1000000.0f, &layout);
        if (SUCCEEDED(hr) && layout) { if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP); }
        D2D1_MATRIX_3X2_F transform = D2D1::Matrix3x2F::Translation(gutterWidth - (float)hScrollPos, -(wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f)); float imeCx = 0, imeCy = 0; D2D1_RECT_F textClipRect = D2D1::RectF(gutterWidth, 0, clientW, clientH); rend->PushAxisAlignedClip(textClipRect, D2D1_ANTIALIAS_MODE_ALIASED); rend->SetTransform(transform); ensureRegexReady();
        if (SUCCEEDED(hr) && layout) {
            if (isOverwriteMode) rend->CreateSolidColorBrush(D2D1::ColorF(caretColor.r, caretColor.g, caretColor.b, 0.5f), &caretBrush); else rend->CreateSolidColorBrush(caretColor, &caretBrush);
            ID2D1SolidColorBrush* selBrush = nullptr; rend->CreateSolidColorBrush(selColor, &selBrush); ID2D1SolidColorBrush* hlBrush = nullptr; rend->CreateSolidColorBrush(highlightColor, &hlBrush); ID2D1SolidColorBrush* autoHlBrush = nullptr; rend->CreateSolidColorBrush(autoHlColor, &autoHlBrush); auto [autoStr, isWholeWord] = getHighlightTarget();
            if (!autoStr.empty() && autoStr != searchQuery) {
                std::string t = text; size_t offset = 0; size_t qLen = autoStr.length();
                while ((offset = t.find(autoStr, offset)) != std::string::npos) {
                    bool match = true; if (isWholeWord) { if (offset > 0 && isWordChar(t[offset - 1])) match = false; if (match && (offset + qLen < t.length()) && isWordChar(t[offset + qLen])) match = false; }
                    if (match) { size_t startU16 = utf8OffsetToUtf16Count(t, offset); size_t lenU16 = utf8OffsetToUtf16Count(t, offset + qLen) - startU16; UINT32 count = 0; layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, 0, 0, &count); if (count > 0) { std::vector<DWRITE_HIT_TEST_METRICS> m(count); layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, &m[0], count, &count); for (const auto& mm : m) { float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + mm.width, top + lineHeight), autoHlBrush); } } } offset++;
                }
            }
            autoHlBrush->Release();
            size_t p1, p2;
            if (cursors.size() == 1 && getAdjacentBrackets(cursors[0].head, p1, p2)) {
                ID2D1SolidColorBrush* bracketBrush = nullptr;
                rend->CreateSolidColorBrush(D2D1::ColorF(0.5f, 0.5f, 0.5f, 0.4f), &bracketBrush);
                auto drawBracketHl = [&](size_t globalPos) {
                    if (globalPos >= visibleStartOffset && globalPos < visibleStartOffset + text.size()) {
                        size_t utf8Off = globalPos - visibleStartOffset;
                        size_t startU16 = utf8OffsetToUtf16Count(text, utf8Off);
                        UINT32 count = 0;
                        layout->HitTestTextRange((UINT32)startU16, 1, 0, 0, 0, 0, &count);
                        if (count > 0) {
                            std::vector<DWRITE_HIT_TEST_METRICS> metrics(count);
                            layout->HitTestTextRange((UINT32)startU16, 1, 0, 0, &metrics[0], count, &count);
                            for (const auto& mm : metrics) {
                                float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight;
                                float drawWidth = (mm.width > 0) ? mm.width : charWidth;
                                rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + drawWidth, top + lineHeight), bracketBrush);
                            }
                        }
                    }
                    };
                drawBracketHl(p1);
                drawBracketHl(p2);
                bracketBrush->Release();
            }
            if (!searchQuery.empty()) {
                if (searchRegex) {
                    if (isRegexValid) {
                        try {
                            bool startsWithCaret = (!searchQuery.empty() && searchQuery[0] == '^'); bool endsWithDollar = (!searchQuery.empty() && searchQuery.back() == '$'); auto searchStart = text.cbegin(); std::smatch m; std::regex_constants::match_flag_type flags = std::regex_constants::match_default;
                            while (std::regex_search(searchStart, text.cend(), m, cachedRegex, flags)) {
                                size_t matchPos = std::distance(text.cbegin(), searchStart) + m.position(); size_t matchLen = m.length(); size_t anchorLen = 0; if (startsWithCaret && m.size() > 1 && m[1].matched) anchorLen = m.length(1); size_t contentPos = matchPos + anchorLen; size_t contentLen = matchLen - anchorLen; bool shouldHighlight = true;
                                if (endsWithDollar) { bool isAtLineEnd = false; if (contentPos + contentLen >= text.size()) isAtLineEnd = true; else { char c = text[contentPos + contentLen]; if (c == '\r' || c == '\n') { isAtLineEnd = true; if (contentLen == 0 && c == '\n' && contentPos + contentLen > 0 && text[contentPos + contentLen - 1] == '\r') isAtLineEnd = false; } } if (!isAtLineEnd) shouldHighlight = false; if (shouldHighlight && contentPos > 0 && contentPos < text.size()) { if (text[contentPos] == '\n' && text[contentPos - 1] == '\r') shouldHighlight = false; } }
                                if (shouldHighlight && startsWithCaret && endsWithDollar && contentLen == 0) { size_t globalPos = visibleStartOffset + contentPos; if (globalPos == pt.length() && pt.length() > 0) { bool isAfterNewline = false; if (globalPos > 0) { char c = pt.charAt(globalPos - 1); if (c == '\r' || c == '\n') isAfterNewline = true; } if (!isAfterNewline) shouldHighlight = false; } }
                                if (shouldHighlight) {
                                    if (contentLen > 0 || (contentLen == 0 && (startsWithCaret || endsWithDollar))) {
                                        size_t startU16 = utf8OffsetToUtf16Count(text, contentPos);
                                        if (contentLen == 0) { FLOAT px, py; DWRITE_HIT_TEST_METRICS m; layout->HitTestTextPosition((UINT32)startU16, FALSE, &px, &py, &m); float top = std::floor((m.top + lineHeight * 0.5f) / lineHeight) * lineHeight; float drawW = (m.width > 0) ? m.width : charWidth; rend->FillRectangle(D2D1::RectF(px, top, px + drawW, top + lineHeight), hlBrush); }
                                        else { size_t lenU16 = utf8OffsetToUtf16Count(text, contentPos + contentLen) - startU16; UINT32 count = 0; layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, 0, 0, &count); if (count > 0) { std::vector<DWRITE_HIT_TEST_METRICS> metrics(count); layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, &metrics[0], count, &count); for (const auto& mm : metrics) { float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; float drawWidth = (mm.width > 0) ? mm.width : charWidth; rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + drawWidth, top + lineHeight), hlBrush); } } }
                                    }
                                }
                                size_t step = matchLen; if (step == 0) { bool isBolCaret = (startsWithCaret && !(flags & std::regex_constants::match_not_bol)); if (isBolCaret) step = 0; else step = 1; } if (step == 0 && (flags & std::regex_constants::match_not_bol)) step = 1; size_t advance = m.position() + step; if (std::distance(searchStart, text.cend()) < (ptrdiff_t)advance) break; std::advance(searchStart, advance); flags |= std::regex_constants::match_not_bol;
                            }
                        }
                        catch (...) {}
                    }
                }
                else {
                    std::string q = searchQuery; std::string t = text; if (!searchMatchCase) { std::transform(q.begin(), q.end(), q.begin(), ::tolower); std::transform(t.begin(), t.end(), t.begin(), ::tolower); } size_t offset = 0;
                    while ((offset = t.find(q, offset)) != std::string::npos) {
                        bool match = true; if (searchWholeWord) { if (offset > 0 && isWordChar(text[offset - 1])) match = false; if (match && (offset + q.length() < text.length()) && isWordChar(text[offset + q.length()])) match = false; }
                        if (match) { size_t startU16 = utf8OffsetToUtf16Count(text, offset); size_t lenU16 = utf8OffsetToUtf16Count(text, offset + q.length()) - startU16; UINT32 count = 0; layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, 0, 0, &count); if (count > 0) { std::vector<DWRITE_HIT_TEST_METRICS> m(count); layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, &m[0], count, &count); for (const auto& mm : m) { float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + mm.width, top + lineHeight), hlBrush); } } } offset += 1;
                    }
                }
            }
            ID2D1Geometry* unifiedSelectionGeo = nullptr; std::vector<D2D1_RECT_F> rawRects; float hInset = 4.0f; float vInset = 0.0f;
            for (const auto& cursor : cursors) {
                size_t s = cursor.start(); size_t e = cursor.end(); size_t relS = (s > visibleStartOffset) ? s - visibleStartOffset : 0; size_t relE = (e > visibleStartOffset) ? e - visibleStartOffset : 0; if (hasIME) { if (relS >= caretOffsetInVisible) relS += imeComp.size(); if (relE >= caretOffsetInVisible) relE += imeComp.size(); }
                if (relS < text.size() && relS != relE) {
                    if (relE > text.size()) relE = text.size();
                    if (relE > relS) {
                        size_t utf16Start = utf8OffsetToUtf16Count(text, relS); size_t utf16Len = utf8OffsetToUtf16Count(text, relE) - utf16Start; UINT32 count = 0; layout->HitTestTextRange((UINT32)utf16Start, (UINT32)utf16Len, 0, 0, 0, 0, &count);
                        if (count > 0) { std::vector<DWRITE_HIT_TEST_METRICS> m(count); layout->HitTestTextRange((UINT32)utf16Start, (UINT32)utf16Len, 0, 0, &m[0], count, &count); for (const auto& mm : m) { float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rawRects.push_back(D2D1::RectF(mm.left, top, mm.left + mm.width, top + lineHeight)); } }
                        for (size_t k = relS; k < relE; ++k) { bool shouldDraw = false; if (text[k] == '\n') shouldDraw = true; else if (text[k] == '\r') { if (k + 1 >= text.size() || text[k + 1] != '\n') shouldDraw = true; } if (shouldDraw) { UINT32 idx16 = (UINT32)utf8OffsetToUtf16Count(text, k); DWRITE_HIT_TEST_METRICS m; FLOAT px, py; layout->HitTestTextPosition(idx16, FALSE, &px, &py, &m); float top = std::floor((m.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rawRects.push_back(D2D1::RectF(px - 0.5f, top, px + charWidth, top + lineHeight)); } }
                    }
                }
            }
            std::sort(rawRects.begin(), rawRects.end(), [](const D2D1_RECT_F& a, const D2D1_RECT_F& b) { if (std::abs(a.top - b.top) > 1.0f) return a.top < b.top; return a.left < b.left; }); std::vector<D2D1_RECT_F> mergedRects;
            if (!rawRects.empty()) { mergedRects.push_back(rawRects[0]); for (size_t i = 1; i < rawRects.size(); ++i) { D2D1_RECT_F& curr = mergedRects.back(); const D2D1_RECT_F& next = rawRects[i]; bool sameLine = std::abs(curr.top - next.top) < 1.0f; bool touches = next.left <= curr.right + 1.0f; if (sameLine && touches) { curr.right = std::max(curr.right, next.right); curr.bottom = std::max(curr.bottom, next.bottom); } else mergedRects.push_back(next); } }
            if (!mergedRects.empty()) { for (const auto& rect : mergedRects) rend->FillRectangle(rect, selBrush); } selBrush->Release(); hlBrush->Release();
            ID2D1SolidColorBrush* brush = nullptr; rend->CreateSolidColorBrush(textColor, &brush);
            applySyntaxHighlighting(layout, text, visibleStartOffset);
            rend->DrawTextLayout(D2D1::Point2F(0.0f, 0.0f), layout, brush, (D2D1_DRAW_TEXT_OPTIONS)0x00000004);
            brush->Release();
            ID2D1SolidColorBrush* wsBrush = nullptr; rend->CreateSolidColorBrush(D2D1::ColorF(0.50f, 0.50f, 0.50f, 0.2f), &wsBrush); float strokeWidth = std::max(1.5f, currentFontSize * 0.05f); float sz = charWidth * 1.0f; float halfSz = sz * 0.5f;
            for (size_t i = 0; i < wtextBuffer.size(); ++i) {
                bool isCR = (wtextBuffer[i] == L'\r'); bool isLF = (wtextBuffer[i] == L'\n'); bool isCRLF = (isCR && i + 1 < wtextBuffer.size() && wtextBuffer[i + 1] == L'\n'); bool isStandAloneCR = (isCR && !isCRLF);
                if (isLF || isCRLF || isStandAloneCR) {
                    FLOAT px, py; DWRITE_HIT_TEST_METRICS m; layout->HitTestTextPosition((UINT32)i, FALSE, &px, &py, &m); float cx = px + charWidth * 0.5f; float cy = py + lineHeight * 0.5f; ID2D1PathGeometry* pathGeo = nullptr; d2dFactory->CreatePathGeometry(&pathGeo); ID2D1GeometrySink* sink = nullptr; pathGeo->Open(&sink); float arrowSize = sz * 0.35f;
                    if (isCRLF) { float vLineTop = cy - halfSz; float vLineBottom = cy + halfSz * 0.3f; float hLineRight = cx + halfSz * 0.6f; float hLineLeft = cx - halfSz * 0.6f; sink->BeginFigure(D2D1::Point2F(hLineRight, vLineTop), D2D1_FIGURE_BEGIN_HOLLOW); sink->AddLine(D2D1::Point2F(hLineRight, vLineBottom)); sink->AddLine(D2D1::Point2F(hLineLeft, vLineBottom)); sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, vLineBottom - arrowSize)); sink->EndFigure(D2D1_FIGURE_END_OPEN); sink->BeginFigure(D2D1::Point2F(hLineLeft, vLineBottom), D2D1_FIGURE_BEGIN_HOLLOW); sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, vLineBottom + arrowSize)); sink->EndFigure(D2D1_FIGURE_END_OPEN); i++; }
                    else if (isStandAloneCR) { float hLineRight = cx + halfSz * 0.6f; float hLineLeft = cx - halfSz * 0.6f; sink->BeginFigure(D2D1::Point2F(hLineRight, cy), D2D1_FIGURE_BEGIN_HOLLOW); sink->AddLine(D2D1::Point2F(hLineLeft, cy)); sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, cy - arrowSize)); sink->EndFigure(D2D1_FIGURE_END_OPEN); sink->BeginFigure(D2D1::Point2F(hLineLeft, cy), D2D1_FIGURE_BEGIN_HOLLOW); sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, cy + arrowSize)); sink->EndFigure(D2D1_FIGURE_END_OPEN); }
                    else { float stemTop = cy - halfSz * 0.8f; float stemBottom = cy + halfSz * 0.8f; sink->BeginFigure(D2D1::Point2F(cx, stemTop), D2D1_FIGURE_BEGIN_HOLLOW); sink->AddLine(D2D1::Point2F(cx, stemBottom)); sink->AddLine(D2D1::Point2F(cx - arrowSize, stemBottom - arrowSize)); sink->EndFigure(D2D1_FIGURE_END_OPEN); sink->BeginFigure(D2D1::Point2F(cx, stemBottom), D2D1_FIGURE_BEGIN_HOLLOW); sink->AddLine(D2D1::Point2F(cx + arrowSize, stemBottom - arrowSize)); sink->EndFigure(D2D1_FIGURE_END_OPEN); }
                    sink->Close(); sink->Release(); rend->DrawGeometry(pathGeo, wsBrush, strokeWidth, roundJoinStyle); pathGeo->Release();
                }
            } wsBrush->Release();
            if (hasIME) {
                UINT32 imeStart = (UINT32)utf8OffsetToUtf16Count(text, caretOffsetInVisible); std::wstring imeCompWide = UTF8ToW(imeComp); UINT32 imeLen = (UINT32)imeCompWide.size(); UINT32 count = 0; layout->HitTestTextRange(imeStart, imeLen, 0, 0, 0, 0, &count);
                if (count > 0) { std::vector<DWRITE_HIT_TEST_METRICS> m(count); layout->HitTestTextRange(imeStart, imeLen, 0, 0, &m[0], count, &count); ID2D1SolidColorBrush* underlineBrush = nullptr; rend->CreateSolidColorBrush(textColor, &underlineBrush); for (const auto& mm : m) { float x = mm.left; float y = std::floor(mm.top + mm.height - 2.0f) + 0.5f; float w = mm.width; if (dotStyle) rend->DrawLine(D2D1::Point2F(x, y), D2D1::Point2F(x + w, y), underlineBrush, 1.5f, dotStyle); else rend->DrawLine(D2D1::Point2F(x, y), D2D1::Point2F(x + w, y), underlineBrush, 1.0f); } underlineBrush->Release(); }
            }
        }
        rend->SetTransform(D2D1::Matrix3x2F::Identity()); rend->PopAxisAlignedClip();
        ID2D1SolidColorBrush* gutterBgBrush = nullptr; rend->CreateSolidColorBrush(gutterBg, &gutterBgBrush); rend->FillRectangle(D2D1::RectF(0, 0, gutterWidth, clientH), gutterBgBrush); gutterBgBrush->Release();
        ID2D1SolidColorBrush* gutterTextBrush = nullptr; rend->CreateSolidColorBrush(gutterText, &gutterTextBrush);
        int startLine = vScrollPos; int endLine = startLine + linesVisible; if (endLine > (int)lineStarts.size()) endLine = (int)lineStarts.size();
        D2D1_RECT_F gutterClipRect = D2D1::RectF(0, 0, gutterWidth, clientH);
        rend->PushAxisAlignedClip(gutterClipRect, D2D1_ANTIALIAS_MODE_ALIASED);
        for (int i = startLine; i < endLine; i++) {
            std::wstring numStr = std::to_wstring(i + 1); float yPos = (float)((i - startLine)) * lineHeight;
            if (layout) { size_t lineStartPos = lineStarts[i]; size_t relStart = (lineStartPos >= visibleStartOffset) ? lineStartPos - visibleStartOffset : 0; if (hasIME && relStart > caretOffsetInVisible) relStart += imeComp.size(); if (relStart <= text.size()) { size_t utf16Start = utf8OffsetToUtf16Count(text, relStart); FLOAT px, py; DWRITE_HIT_TEST_METRICS m; layout->HitTestTextPosition((UINT32)utf16Start, FALSE, &px, &py, &m); yPos = py - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f); } }
            if (yPos + lineHeight > 0 && yPos < clientH) {
                IDWriteTextLayout* numLayout = nullptr; if (SUCCEEDED(dwFactory->CreateTextLayout(numStr.c_str(), (UINT32)numStr.size(), textFormat, gutterWidth, lineHeight, &numLayout))) { numLayout->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_TRAILING); float xPos = -(charWidth * 0.5f); rend->DrawTextLayout(D2D1::Point2F(xPos, yPos), numLayout, gutterTextBrush, (D2D1_DRAW_TEXT_OPTIONS)0x00000004); numLayout->Release(); }
            }
        }
        rend->PopAxisAlignedClip();
        gutterTextBrush->Release();
        if (layout && caretBrush) {
            rend->PushAxisAlignedClip(textClipRect, D2D1_ANTIALIAS_MODE_ALIASED); D2D1_ANTIALIAS_MODE oldMode = rend->GetAntialiasMode(); rend->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED); rend->SetTransform(transform);
            if (isDragMoving) { size_t relPos = (dragMoveDestPos > visibleStartOffset) ? dragMoveDestPos - visibleStartOffset : 0; if (hasIME && relPos > caretOffsetInVisible) relPos += imeComp.size(); if (relPos <= text.size()) { DWRITE_HIT_TEST_METRICS m; FLOAT px, py; layout->HitTestTextPosition((UINT32)utf8OffsetToUtf16Count(text, relPos), FALSE, &px, &py, &m); px = std::round(px); rend->FillRectangle(D2D1::RectF(px, py, px + 2.0f, py + lineHeight), caretBrush); } }
            for (const auto& cursor : cursors) {
                size_t head = cursor.head; size_t relHead = (head > visibleStartOffset) ? head - visibleStartOffset : 0; if (hasIME && relHead >= caretOffsetInVisible) relHead += imeComp.size();
                if (relHead <= text.size()) {
                    UINT32 u16Pos = (UINT32)utf8OffsetToUtf16Count(text, relHead);
                    DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
                    if (cursor.affinity && u16Pos > 0) {
                        layout->HitTestTextPosition(u16Pos - 1, TRUE, &px, &py, &m);
                    } else {
                        layout->HitTestTextPosition(u16Pos, FALSE, &px, &py, &m);
                    }
                    px = std::round(px);
                    if (isOverwriteMode) { float cw = m.width; if (cw == 0) cw = charWidth; rend->FillRectangle(D2D1::RectF(px, py, px + cw, py + lineHeight), caretBrush); }
                    else rend->FillRectangle(D2D1::RectF(px, py, px + 2.0f, py + lineHeight), caretBrush);
                    if (&cursor == &cursors.back()) { imeCx = px; imeCy = py; }
                }
            }
            rend->SetTransform(D2D1::Matrix3x2F::Identity()); rend->SetAntialiasMode(oldMode); rend->PopAxisAlignedClip();
        }
        if (caretBrush) caretBrush->Release(); if (layout) layout->Release();
        HIMC hIMC = ImmGetContext(hwnd);
        if (hIMC) { COMPOSITIONFORM cf = {}; cf.dwStyle = CFS_POINT; cf.ptCurrentPos.x = (LONG)((imeCx + gutterWidth - hScrollPos) * dpiScaleX); cf.ptCurrentPos.y = (LONG)((imeCy - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f)) * dpiScaleY); ImmSetCompositionWindow(hIMC, &cf); CANDIDATEFORM cdf = {}; cdf.dwIndex = 0; cdf.dwStyle = CFS_CANDIDATEPOS; cdf.ptCurrentPos.x = (LONG)((imeCx + gutterWidth - hScrollPos) * dpiScaleX); cdf.ptCurrentPos.y = (LONG)((imeCy - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f) + lineHeight) * dpiScaleY); ImmSetCandidateWindow(hIMC, &cdf); ImmReleaseContext(hwnd, hIMC); }
        if (GetTickCount64() < zoomPopupEndTime) { D2D1_RECT_F popupRect = D2D1::RectF(clientW / 2 - 80, clientH / 2 - 40, clientW / 2 + 80, clientH / 2 + 40); ID2D1SolidColorBrush* popupBg = nullptr; ID2D1SolidColorBrush* popupText = nullptr; if (isDarkMode) { rend->CreateSolidColorBrush(D2D1::ColorF(0.2f, 0.2f, 0.2f, 0.7f), &popupBg); rend->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f), &popupText); } else { rend->CreateSolidColorBrush(D2D1::ColorF(0.93f, 0.93f, 0.93f, 0.85f), &popupBg); rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f), &popupText); } rend->FillRoundedRectangle(D2D1::RoundedRect(popupRect, 10.0f, 10.0f), popupBg); if (popupTextFormat) rend->DrawText(zoomPopupText.c_str(), (UINT32)zoomPopupText.size(), popupTextFormat, popupRect, popupText); popupBg->Release(); popupText->Release(); }
        if (showHelpPopup) {
            float helpW = 500.0f; float helpH = 588.0f;
            D2D1_RECT_F helpRect = D2D1::RectF((clientW - helpW) / 2, (clientH - helpH) / 2, (clientW + helpW) / 2, (clientH + helpH) / 2);
            ID2D1SolidColorBrush* popupBg = nullptr;
            ID2D1SolidColorBrush* popupText = nullptr;
            ID2D1SolidColorBrush* popupBorder = nullptr;
            if (isDarkMode) {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.2f, 0.2f, 0.2f, 0.7f), &popupBg);
                rend->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f), &popupText);
            } else {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.93f, 0.93f, 0.93f, 0.85f), &popupBg);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f), &popupText);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.8f, 0.8f, 0.8f, 1.0f), &popupBorder);
            }
            rend->FillRoundedRectangle(D2D1::RoundedRect(helpRect, 10.0f, 10.0f), popupBg);
            if (popupBorder) {
                rend->DrawRoundedRectangle(D2D1::RoundedRect(helpRect, 10.0f, 10.0f), popupBorder, 1.0f);
                popupBorder->Release();
            }
            IDWriteTextLayout* helpLayout = nullptr;
            if (SUCCEEDED(dwFactory->CreateTextLayout(helpTextStr.c_str(), (UINT32)helpTextStr.size(), helpTextFormat, helpW - 40, helpH - 20, &helpLayout))) {
                rend->DrawTextLayout(D2D1::Point2F(helpRect.left + 20, helpRect.top + 10), helpLayout, popupText, (D2D1_DRAW_TEXT_OPTIONS)0x00000004);
                helpLayout->Release();
            }
            popupBg->Release();
            popupText->Release();
        }
        {
            const float SB_HIT_WIDTH = 20.0f; const float SB_MIN_WIDTH = 4.0f; const float SB_MAX_WIDTH = 10.0f; const float SB_PADDING = 0.0f; ID2D1SolidColorBrush* sbBrushIdle = nullptr; ID2D1SolidColorBrush* sbBrushActive = nullptr; rend->CreateSolidColorBrush(D2D1::ColorF(0.5f, 0.5f, 0.5f, 0.4f), &sbBrushIdle); rend->CreateSolidColorBrush(D2D1::ColorF(0.6f, 0.6f, 0.6f, 0.8f), &sbBrushActive);
            if (!lineStarts.empty()) { float total = (float)lineStarts.size(); float currentV = (float)vScrollPos; if (wordWrapEnabled && lineStarts.size() == 1) { int count = getLineVisualCount(0); if (count > 1) { total = (float)count; currentV = (float)vScrollSubLine; } } float viewportLines = clientH / lineHeight; if (total > 1.0f) { bool isActive = isVScrollHover || isVScrollDragging; float currentSize = isActive ? SB_MAX_WIDTH : SB_MIN_WIDTH; ID2D1SolidColorBrush* currentBrush = isActive ? sbBrushActive : sbBrushIdle; float maxScroll = std::max(1.0f, total - 1.0f); float trackH = clientH - (SB_PADDING * 2); if (maxLineWidth > clientW && !wordWrapEnabled) trackH -= SB_HIT_WIDTH; float virtualTotal = total + viewportLines - 1.0f; float thumbH = trackH * (viewportLines / virtualTotal); if (thumbH < 30.0f) thumbH = 30.0f; if (thumbH > trackH) thumbH = trackH; float progress = currentV / maxScroll; if (progress > 1.0f) progress = 1.0f; if (progress < 0.0f) progress = 0.0f; float thumbY = SB_PADDING + (trackH - thumbH) * progress; D2D1_RECT_F rect = D2D1::RectF(clientW - currentSize - SB_PADDING, thumbY, clientW - SB_PADDING, thumbY + thumbH); rend->FillRoundedRectangle(D2D1::RoundedRect(rect, currentSize / 2.0f, currentSize / 2.0f), currentBrush); } }
            if (!wordWrapEnabled && maxLineWidth > clientW) {
                float total = maxLineWidth;
                float visible = clientW;
                bool isActive = isHScrollHover || isHScrollDragging;
                float currentSize = isActive ? SB_MAX_WIDTH : SB_MIN_WIDTH;
                ID2D1SolidColorBrush* currentBrush = isActive ? sbBrushActive : sbBrushIdle;
                float maxScroll = std::max(1.0f, total - visible);
                float trackW = clientW - (SB_PADDING * 2);
                if (!lineStarts.empty() && (float)lineStarts.size() > 1.0f) trackW -= SB_HIT_WIDTH;
                float thumbW = trackW * (visible / total);
                if (thumbW < 30.0f) thumbW = 30.0f;
                if (thumbW > trackW) thumbW = trackW;
                float progress = (float)hScrollPos / maxScroll;
                if (progress > 1.0f) progress = 1.0f;
                if (progress < 0.0f) progress = 0.0f;
                float thumbX = SB_PADDING + (trackW - thumbW) * progress;
                D2D1_RECT_F rect = D2D1::RectF(thumbX, clientH - currentSize - SB_PADDING, thumbX + thumbW, clientH - SB_PADDING);
                rend->FillRoundedRectangle(D2D1::RoundedRect(rect, currentSize / 2.0f, currentSize / 2.0f), currentBrush);
            }
            if (sbBrushIdle) sbBrushIdle->Release(); if (sbBrushActive) sbBrushActive->Release();
        }
        rend->EndDraw();
        swapChain->Present(1, 0);
    }
    void resizeSwapChain(int w, int h) {
        if (rend && swapChain) { rend->SetTarget(nullptr); if (targetBitmap) { targetBitmap->Release(); targetBitmap = nullptr; } swapChain->ResizeBuffers(2, w, h, DXGI_FORMAT_B8G8R8A8_UNORM, 0); updateScrollBars(); if (hwnd) InvalidateRect(hwnd, NULL, FALSE); }
    }
    void insertAtCursors(const std::string& text) {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size());
        for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i;
        std::sort(indices.begin(), indices.end(), [&](int a, int b) {return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx];
            if (isOverwriteMode && !c.hasSelection()) { char ch = (c.head < pt.length()) ? pt.charAt(c.head) : 0; if (ch != 0 && ch != '\n' && ch != '\r') { size_t nextPos = moveCaretVisual(c.head, true); size_t charLen = nextPos - c.head; if (charLen > 0) { std::string d = pt.getRange(c.head, charLen); pt.erase(c.head, charLen); batch.ops.push_back({ EditOp::Erase, c.head, d }); for (auto& o : cursors) { if (o.head > c.head) o.head -= charLen; if (o.anchor > c.head) o.anchor -= charLen; } } } }
            if (c.hasSelection()) { size_t s = c.start(); size_t l = c.end() - s; std::string d = pt.getRange(s, l); pt.erase(s, l); batch.ops.push_back({ EditOp::Erase,s,d }); for (auto& o : cursors) { if (o.head > s)o.head -= l; if (o.anchor > s)o.anchor -= l; } c.head = s; c.anchor = s; }
        }
        for (int idx : indices) { Cursor& c = cursors[idx]; size_t p = c.head; pt.insert(p, text); batch.ops.push_back({ EditOp::Insert,p,text }); size_t l = text.size(); for (auto& o : cursors) { if (o.head >= p)o.head += l; if (o.anchor >= p)o.anchor += l; } }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag();
    }
    void deleteForwardAtCursors() {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size());
        for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i;
        std::sort(indices.begin(), indices.end(), [&](int a, int b) {return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx]; size_t s = c.start(); size_t l = 0;
            if (c.hasSelection()) l = c.end() - s;
            else { if (s + 1 < pt.length() && pt.charAt(s) == '\r' && pt.charAt(s + 1) == '\n') l = 2; else { size_t n = moveCaretVisual(s, true); if (n > s) l = n - s; } }
            if (l > 0 && s + l <= pt.length()) { std::string d = pt.getRange(s, l); pt.erase(s, l); batch.ops.push_back({ EditOp::Erase,s,d }); for (auto& o : cursors) { if (o.head > s) o.head -= l; if (o.anchor > s) o.anchor -= l; } c.head = s; c.anchor = s; }
        }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag();
    }
    void backspaceAtCursors(bool allowCharDeletion = true) {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size());
        for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i;
        std::sort(indices.begin(), indices.end(), [&](int a, int b) {return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx]; size_t s = c.start(); size_t l = 0;
            if (c.hasSelection()) l = c.end() - s;
            else if (allowCharDeletion && s > 0) { if (s >= 2 && pt.charAt(s - 1) == '\n' && pt.charAt(s - 2) == '\r') { l = 2; s -= 2; } else { size_t p = moveCaretVisual(s, false); if (p < s) { l = s - p; s = p; } } }
            if (l > 0) { std::string d = pt.getRange(s, l); pt.erase(s, l); batch.ops.push_back({ EditOp::Erase,s,d }); for (auto& o : cursors) { if (o.head > s) o.head -= l; if (o.anchor > s) o.anchor -= l; } c.head = s; c.anchor = s; }
        }
        if (!batch.ops.empty()) { batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); }
    }
    void insertRectangularBlock(const std::string& text) {
        commitPadding(); if (cursors.empty()) return; size_t basePos = cursors.back().head; float baseX = getXFromPos(basePos); int startLine = getLineIdx(basePos); std::vector<std::string> lines; std::stringstream ss(text); std::string line;
        while (std::getline(ss, line)) { if (!line.empty() && line.back() == '\r') line.pop_back(); lines.push_back(line); }
        EditBatch batch; batch.beforeCursors = cursors; std::vector<Cursor> newCursors; size_t accumulatedDelta = 0;
        for (size_t i = 0; i < lines.size(); ++i) {
            int targetLineIdx = startLine + (int)i; std::string content = lines[i];
            if (targetLineIdx >= (int)lineStarts.size()) {
                size_t insertAt = pt.length(); std::string nl = newlineStr; pt.insert(insertAt, nl); batch.ops.push_back({ EditOp::Insert, insertAt, nl }); int spacesNeeded = (int)((baseX) / charWidth + 0.5f); std::string spaces = ""; if (spacesNeeded > 0) spaces = std::string(spacesNeeded, ' '); size_t contentPos = insertAt + nl.size();
                if (!spaces.empty()) { pt.insert(contentPos, spaces); batch.ops.push_back({ EditOp::Insert, contentPos, spaces }); contentPos += spaces.size(); }
                pt.insert(contentPos, content); batch.ops.push_back({ EditOp::Insert, contentPos, content }); size_t endPos = contentPos + content.size(); newCursors.push_back({ endPos, contentPos, baseX + (float)UTF8ToW(content).length() * charWidth });
            }
            else {
                size_t lineStart = lineStarts[targetLineIdx] + accumulatedDelta; size_t scanPos = lineStart; size_t maxLen = pt.length();
                while (scanPos < maxLen && pt.charAt(scanPos) != '\n') scanPos++; size_t lineEnd = scanPos; if (lineEnd > lineStart && pt.charAt(lineEnd - 1) == '\r') lineEnd--;
                std::string currentLineStr = pt.getRange(lineStart, lineEnd - lineStart); std::wstring wCurrentLine = UTF8ToW(currentLineStr); size_t insertOffset = wCurrentLine.length(); float actualLineWidth = 0.0f; IDWriteTextLayout* layout = nullptr; HRESULT hr = dwFactory->CreateTextLayout(wCurrentLine.c_str(), (UINT32)wCurrentLine.size(), textFormat, 10000.0f, (FLOAT)lineHeight, &layout);
                if (SUCCEEDED(hr) && layout) { BOOL isTrailing, isInside; DWRITE_HIT_TEST_METRICS m; layout->HitTestPoint(baseX, 1.0f, &isTrailing, &isInside, &m); size_t u16Pos = m.textPosition; if (isTrailing) u16Pos += m.length; std::string pre = WToUTF8(wCurrentLine.substr(0, u16Pos)); insertOffset = pre.size(); DWRITE_TEXT_METRICS tm; if (SUCCEEDED(layout->GetMetrics(&tm))) actualLineWidth = tm.widthIncludingTrailingWhitespace; else actualLineWidth = (float)wCurrentLine.length() * charWidth; layout->Release(); }
                else actualLineWidth = (float)wCurrentLine.length() * charWidth;
                size_t insertPos = lineStart + insertOffset; std::string spaces = ""; if (insertPos == lineEnd && baseX > actualLineWidth + 1.0f) { int spacesNeeded = (int)((baseX - actualLineWidth) / charWidth + 0.5f); if (spacesNeeded > 0) spaces = std::string(spacesNeeded, ' '); }
                size_t addedBytes = 0; if (!spaces.empty()) { pt.insert(insertPos, spaces); batch.ops.push_back({ EditOp::Insert, insertPos, spaces }); insertPos += spaces.size(); addedBytes += spaces.size(); }
                pt.insert(insertPos, content); batch.ops.push_back({ EditOp::Insert, insertPos, content }); addedBytes += content.size(); accumulatedDelta += addedBytes; size_t endPos = insertPos + content.size(); newCursors.push_back({ endPos, insertPos, baseX + (float)UTF8ToW(content).length() * charWidth });
            }
        }
        cursors = newCursors; batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void convertCase(bool toUpper) {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; bool isChanged = false; std::vector<int> indices(cursors.size()); for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i; std::sort(indices.begin(), indices.end(), [&](int a, int b) { return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) { Cursor& c = cursors[idx]; if (!c.hasSelection()) continue; size_t start = c.start(); size_t len = c.end() - start; std::string text = pt.getRange(start, len); std::wstring wText = UTF8ToW(text); if (toUpper) CharUpperBuffW(&wText[0], (DWORD)wText.size()); else CharLowerBuffW(&wText[0], (DWORD)wText.size()); std::string newText = WToUTF8(wText); if (text == newText) continue; isChanged = true; pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, text }); pt.insert(start, newText); batch.ops.push_back({ EditOp::Insert, start, newText }); long long diff = (long long)newText.size() - (long long)len; if (c.head > c.anchor) { c.head = start + newText.size(); c.anchor = start; } else { c.head = start; c.anchor = start + newText.size(); } if (diff != 0) { for (size_t k = 0; k < cursors.size(); ++k) { if ((int)k == idx) continue; Cursor& other = cursors[k]; if (other.start() > start) { if (other.head > start) other.head = (size_t)((long long)other.head + diff); if (other.anchor > start) other.anchor = (size_t)((long long)other.anchor + diff); } } } }
        if (isChanged) { batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
    }
    std::vector<int> getSelectedLineIndices() { std::vector<int> lines; for (const auto& c : cursors) { int startLine = getLineIdx(c.start()); int endLine = getLineIdx(c.end()); if (c.hasSelection() && c.end() > c.start()) { if (c.end() > 0 && pt.charAt(c.end() - 1) == '\n') { if (endLine > startLine) endLine--; } } for (int i = startLine; i <= endLine; ++i) lines.push_back(i); } std::sort(lines.begin(), lines.end()); lines.erase(std::unique(lines.begin(), lines.end()), lines.end()); return lines; }
    void duplicateLines(bool up) {
        commitPadding(); if (cursors.empty()) return; std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::string blockText; size_t blockStart = lineStarts[lines.front()]; size_t blockEnd = (lines.back() + 1 < (int)lineStarts.size()) ? lineStarts[lines.back() + 1] : pt.length(); blockText = pt.getRange(blockStart, blockEnd - blockStart); bool needNewline = false; if (blockText.empty() || blockText.back() != '\n') { blockText += newlineStr; needNewline = true; } size_t insertPos;
        if (up) insertPos = blockStart; else { insertPos = blockEnd; if (needNewline && blockEnd == pt.length() && blockEnd > 0 && pt.charAt(blockEnd - 1) != '\n') { pt.insert(blockEnd, newlineStr); batch.ops.push_back({ EditOp::Insert, blockEnd, newlineStr }); insertPos += newlineStr.length(); } }
        pt.insert(insertPos, blockText); batch.ops.push_back({ EditOp::Insert, insertPos, blockText }); batch.afterCursors.clear(); size_t newSelectionStart = insertPos; size_t newSelectionEnd = insertPos + blockText.size(); batch.afterCursors.push_back({ newSelectionEnd, newSelectionStart, getXFromPos(newSelectionEnd) }); cursors = batch.afterCursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void moveLines(bool up) {
        commitPadding(); if (cursors.empty()) return; std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; if (up && lines.front() == 0) return; if (!up && lines.back() >= (int)lineStarts.size() - 1) return; int startLine = lines.front(); int endLine = lines.back(); size_t rangeStart = lineStarts[startLine]; size_t rangeEnd = (endLine + 1 < (int)lineStarts.size()) ? lineStarts[endLine + 1] : pt.length(); std::string textToMove = pt.getRange(rangeStart, rangeEnd - rangeStart); bool isLastLineNoNewline = (rangeEnd == pt.length()) && (textToMove.empty() || textToMove.back() != '\n'); EditBatch batch; batch.beforeCursors = cursors;
        if (up) {
            int targetLineIdx = startLine - 1; size_t targetStart = lineStarts[targetLineIdx]; size_t targetEnd = rangeStart; std::string lineAbove = pt.getRange(targetStart, targetEnd - targetStart); long long diff = -(long long)(rangeStart - targetStart);
            if (isLastLineNoNewline) { textToMove += newlineStr; if (!lineAbove.empty() && lineAbove.back() == '\n') { if (lineAbove.size() >= 2 && lineAbove[lineAbove.size() - 2] == '\r') lineAbove.pop_back(), lineAbove.pop_back(); else lineAbove.pop_back(); } }
            size_t deleteLen = rangeEnd - targetStart; std::string deletedAll = pt.getRange(targetStart, deleteLen); pt.erase(targetStart, deleteLen); batch.ops.push_back({ EditOp::Erase, targetStart, deletedAll }); std::string newText = textToMove + lineAbove; pt.insert(targetStart, newText); batch.ops.push_back({ EditOp::Insert, targetStart, newText });
            for (auto& c : cursors) { c.head = (size_t)((long long)c.head + diff); c.anchor = (size_t)((long long)c.anchor + diff); c.desiredX = getXFromPos(c.head); }
        }
        else {
            int targetLineIdx = endLine + 1; size_t targetStart = rangeEnd; size_t targetEnd = (targetLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[targetLineIdx + 1] : pt.length(); std::string lineBelow = pt.getRange(targetStart, targetEnd - targetStart);
            if (targetEnd == pt.length() && (lineBelow.empty() || lineBelow.back() != '\n')) { lineBelow += newlineStr; if (!textToMove.empty() && textToMove.back() == '\n') { if (textToMove.size() >= 2 && textToMove[textToMove.size() - 2] == '\r') textToMove.pop_back(), textToMove.pop_back(); else textToMove.pop_back(); } }
            size_t deleteLen = targetEnd - rangeStart; std::string deletedAll = pt.getRange(rangeStart, deleteLen); pt.erase(rangeStart, deleteLen); batch.ops.push_back({ EditOp::Erase, rangeStart, deletedAll }); std::string newText = lineBelow + textToMove; pt.insert(rangeStart, newText); batch.ops.push_back({ EditOp::Insert, rangeStart, newText }); long long diff = (long long)lineBelow.size();
            for (auto& c : cursors) { c.head = (size_t)((long long)c.head + diff); c.anchor = (size_t)((long long)c.anchor + diff); c.desiredX = getXFromPos(c.head); }
        }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void addCursor(bool up) {
        rollbackPadding();
        if (cursors.empty() || lineStarts.empty()) return;
        int targetLine = -1;
        if (up) {
            size_t minLineIdx = lineStarts.size();
            size_t topIdx = 0;
            for (size_t i = 0; i < cursors.size(); ++i) {
                size_t l = getLineIdx(cursors[i].head);
                if (l < minLineIdx) {
                    minLineIdx = l;
                    topIdx = i;
                }
            }
            if (minLineIdx == 0) return;
            targetLine = (int)minLineIdx - 1;
            const auto& refCursor = cursors[topIdx];
            size_t newHead = getPosFromLineAndX(targetLine, refCursor.desiredX);
            size_t newAnchor = newHead;
            if (refCursor.hasSelection()) {
                float anchorX = getXFromPos(refCursor.anchor);
                newAnchor = getPosFromLineAndX(targetLine, anchorX);
            }
            cursors.push_back({ newHead, newAnchor, refCursor.desiredX });
        } else {
            int maxLineIdx = -1;
            size_t bottomIdx = 0;
            for (size_t i = 0; i < cursors.size(); ++i) {
                int l = (int)getLineIdx(cursors[i].head);
                if (l > maxLineIdx) {
                    maxLineIdx = l;
                    bottomIdx = i;
                }
            }
            if (maxLineIdx < 0 || maxLineIdx + 1 >= (int)lineStarts.size()) return;
            targetLine = maxLineIdx + 1;
            const auto& refCursor = cursors[bottomIdx];
            size_t newHead = getPosFromLineAndX(targetLine, refCursor.desiredX);
            size_t newAnchor = newHead;
            if (refCursor.hasSelection()) {
                float anchorX = getXFromPos(refCursor.anchor);
                newAnchor = getPosFromLineAndX(targetLine, anchorX);
            }
            cursors.push_back({ newHead, newAnchor, refCursor.desiredX });
        }
        mergeCursors();
        ensureCaretVisible();
        if (up && targetLine >= 0 && targetLine < vScrollPos) {
            vScrollPos = targetLine;
            updateScrollBars();
        }
        InvalidateRect(hwnd, NULL, FALSE);
    }
    void setClipboard(const std::string& text, bool isLineCopy, bool isRectCopy) {
        if (text.empty()) return;
        if (OpenClipboard(hwnd)) { EmptyClipboard(); std::wstring w = UTF8ToW(text); HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, (w.size() + 1) * sizeof(wchar_t)); if (h) { void* p = GlobalLock(h); memcpy(p, w.c_str(), (w.size() + 1) * sizeof(wchar_t)); GlobalUnlock(h); SetClipboardData(CF_UNICODETEXT, h); } if (isLineCopy) { HGLOBAL hLine = GlobalAlloc(GMEM_MOVEABLE, 1); if (hLine) SetClipboardData(cfMsDevLine, hLine); } if (isRectCopy) { HGLOBAL hCol = GlobalAlloc(GMEM_MOVEABLE, 1); if (hCol) SetClipboardData(cfMsDevCol, hCol); } CloseClipboard(); }
    }
    void copyToClipboard() {
        bool hasSelection = false; for (const auto& c : cursors) { if (c.hasSelection()) { hasSelection = true; break; } } std::string t;
        if (hasSelection) { std::vector<Cursor> s = cursors; std::sort(s.begin(), s.end(), [](const Cursor& a, const Cursor& b) { return a.start() < b.start(); }); for (size_t i = 0; i < s.size(); ++i) { if (s[i].hasSelection()) { std::string part = pt.getRange(s[i].start(), s[i].end() - s[i].start()); t += part; if (i < s.size() - 1 && !part.empty() && part.back() != '\n' && part.back() != '\r') t += "\r\n"; } } setClipboard(t, false, cursors.size() > 1); }
        else { std::vector<int> processedLines; std::vector<Cursor> s = cursors; std::sort(s.begin(), s.end(), [](const Cursor& a, const Cursor& b) { return a.head < b.head; }); for (const auto& c : s) { int lineIdx = getLineIdx(c.head); bool dup = false; for (int p : processedLines) if (p == lineIdx) dup = true; if (dup) continue; processedLines.push_back(lineIdx); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); std::string lineText = pt.getRange(start, end - start); t += lineText; if (lineIdx == (int)lineStarts.size() - 1) { if (lineText.empty() || lineText.back() != '\n') t += newlineStr; } } setClipboard(t, true, false); }
    }
    void cutToClipboard() { bool hasSelection = false; for (const auto& c : cursors) { if (c.hasSelection()) { hasSelection = true; break; } } if (hasSelection) { copyToClipboard(); insertAtCursors(""); } else { std::string t; std::vector<int> processedLines; std::vector<Cursor> s = cursors; std::sort(s.begin(), s.end(), [](const Cursor& a, const Cursor& b) { return a.head < b.head; }); for (const auto& c : s) { int lineIdx = getLineIdx(c.head); bool dup = false; for (int p : processedLines) if (p == lineIdx) dup = true; if (dup) continue; processedLines.push_back(lineIdx); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); std::string lineText = pt.getRange(start, end - start); t += lineText; if (lineIdx == (int)lineStarts.size() - 1) { if (lineText.empty() || lineText.back() != '\n') t += newlineStr; } } setClipboard(t, true, false); deleteLines(); } }
    void deleteLines() {
        rollbackPadding(); std::vector<Cursor> originalCursors = cursors; std::vector<Cursor> delRanges; bool hasSelection = false; for (const auto& c : cursors) if (c.hasSelection()) hasSelection = true;
        if (hasSelection) { for (const auto& c : cursors) { int sLine = getLineIdx(c.start()); int eLine = getLineIdx(c.end()); if (c.hasSelection() && c.end() > 0 && pt.charAt(c.end() - 1) == '\n' && eLine > sLine) eLine--; size_t start = lineStarts[sLine]; size_t end = (eLine + 1 < (int)lineStarts.size()) ? lineStarts[eLine + 1] : pt.length(); if (end == pt.length() && start > 0) { char prev = pt.charAt(start - 1); if (prev == '\n') { start--; if (start > 0 && pt.charAt(start - 1) == '\r') start--; } else if (prev == '\r') start--; } delRanges.push_back({ end, start, 0.0f }); } }
        else { for (const auto& c : cursors) { int lineIdx = getLineIdx(c.head); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); if (end == pt.length() && start > 0) { char prev = pt.charAt(start - 1); if (prev == '\n') { start--; if (start > 0 && pt.charAt(start - 1) == '\r') start--; } else if (prev == '\r') start--; } delRanges.push_back({ end, start, 0.0f }); } }
        cursors = delRanges; mergeCursors(); insertAtCursors(""); if (!undo.undoStack.empty()) undo.undoStack.back().beforeCursors = originalCursors;
    }
    void pasteFromClipboard() {
        if (!IsClipboardFormatAvailable(CF_UNICODETEXT)) return;
        if (OpenClipboard(hwnd)) {
            bool isRect = IsClipboardFormatAvailable(cfMsDevCol); bool isLine = IsClipboardFormatAvailable(cfMsDevLine); HGLOBAL h = GetClipboardData(CF_UNICODETEXT);
            if (h) {
                const wchar_t* p = (const wchar_t*)GlobalLock(h);
                if (p) {
                    std::wstring w(p); GlobalUnlock(h); std::string utf8 = WToUTF8(w);
                    if (isRect) insertRectangularBlock(utf8);
                    else if (isLine) {
                        bool hasAnySelection = false; for (const auto& c : cursors) if (c.hasSelection()) hasAnySelection = true;
                        if (hasAnySelection) insertAtCursors(utf8);
                        else { rollbackPadding(); rebuildLineStarts(); std::vector<size_t> relativeOffsets; for (auto& c : cursors) { int lineIdx = getLineIdx(c.head); size_t lineStart = lineStarts[lineIdx]; relativeOffsets.push_back((c.head > lineStart) ? (c.head - lineStart) : 0); c.head = lineStart; c.anchor = lineStart; } insertAtCursors(utf8); for (size_t i = 0; i < cursors.size(); ++i) { if (i < relativeOffsets.size()) { cursors[i].head += relativeOffsets[i]; cursors[i].anchor = cursors[i].head; cursors[i].desiredX = getXFromPos(cursors[i].head); } } ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
                    }
                    else insertAtCursors(utf8);
                }
            } CloseClipboard();
        }
    }
    void doInsert(size_t pos, const std::string& s) { cursors.clear(); cursors.push_back({ pos, pos, getXFromPos(pos) }); insertAtCursors(s); }
    void performUndo() { if (!undo.canUndo())return; EditBatch b = undo.popUndo(); for (int i = (int)b.ops.size() - 1; i >= 0; --i) { const auto& o = b.ops[i]; if (o.type == EditOp::Insert)pt.erase(o.pos, o.text.size()); else pt.insert(o.pos, o.text); }cursors = b.beforeCursors; rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); }
    void performRedo() { if (!undo.canRedo())return; EditBatch b = undo.popRedo(); for (const auto& o : b.ops) { if (o.type == EditOp::Insert)pt.insert(o.pos, o.text); else pt.erase(o.pos, o.text.size()); }cursors = b.afterCursors; rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); }
    int ShowTaskDialog(const wchar_t* title, const wchar_t* instruction, const wchar_t* content, TASKDIALOG_COMMON_BUTTON_FLAGS buttons, PCWSTR icon) { return ShowCustomTaskDialog(hwnd, title, instruction, content, buttons, icon, isDarkMode); }
    bool checkUnsavedChanges() { if (!isDirty)return true; int r = ShowTaskDialog(GetResString(IDS_CONFIRM_TITLE).c_str(), GetResString(IDS_SAVE_PROMPT).c_str(), currentFilePath.empty() ? GetResString(IDS_UNTITLED).c_str() : currentFilePath.c_str(), TDCBF_YES_BUTTON | TDCBF_NO_BUTTON | TDCBF_CANCEL_BUTTON, TD_WARNING_ICON); if (r == IDCANCEL) return false; if (r == IDYES) { if (currentFilePath.empty()) return saveFileAs(); else return saveFile(currentFilePath); } return true; }
    bool openFile() { if (!checkUnsavedChanges()) return false; WCHAR f[MAX_PATH] = { 0 }; OPENFILENAMEW o = { 0 }; o.lStructSize = sizeof(o); o.hwndOwner = hwnd; o.lpstrFile = f; o.nMaxFile = MAX_PATH; o.lpstrFilter = L"All\0*.*\0Text\0*.txt\0"; o.nFilterIndex = 1; o.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST; std::wstring initialDir; if (!currentFilePath.empty()) { size_t lastSlash = currentFilePath.find_last_of(L"\\/"); if (lastSlash != std::wstring::npos) { initialDir = currentFilePath.substr(0, lastSlash); o.lpstrInitialDir = initialDir.c_str(); } } SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hAppIcon); if (GetOpenFileNameW(&o)) return openFileFromPath(f); updateWindowIcon(); return false; }
    bool writeContentToHandle(HANDLE h) {
        std::string contentUtf8; size_t totalLen = pt.length(); if (totalLen > 0) contentUtf8 = pt.getRange(0, totalLen); bool ok = true; DWORD w = 0;
        if (currentEncoding == ENC_UTF16LE || currentEncoding == ENC_UTF16BE) {
            std::wstring wStr = Utf8ToUtf16(contentUtf8); unsigned char bomLE[] = { 0xFF, 0xFE }; unsigned char bomBE[] = { 0xFE, 0xFF };
            if (currentEncoding == ENC_UTF16LE) WriteFile(h, bomLE, 2, &w, NULL);
            else { WriteFile(h, bomBE, 2, &w, NULL); SwapBytes(&wStr[0], wStr.size()); }
            DWORD bytesToWrite = (DWORD)(wStr.size() * sizeof(wchar_t));
            if (!WriteFile(h, wStr.data(), bytesToWrite, &w, NULL) || w != bytesToWrite) ok = false;
        }
        else if (currentEncoding == ENC_LOCAL) {
            std::string localStr = Utf8ToLocal(contentUtf8, currentCodePage);
            if (!localStr.empty()) { if (!WriteFile(h, localStr.data(), (DWORD)localStr.size(), &w, NULL) || w != localStr.size()) ok = false; }
        }
        else {
            if (currentEncoding == ENC_UTF8_BOM) { unsigned char bom[] = { 0xEF, 0xBB, 0xBF }; WriteFile(h, bom, 3, &w, NULL); }
            if (!contentUtf8.empty()) { if (!WriteFile(h, contentUtf8.data(), (DWORD)contentUtf8.size(), &w, NULL) || w != contentUtf8.size()) ok = false; }
        }
        return ok;
    }
    bool saveFileElevated(const std::wstring& p, const std::wstring& existingTempFile = L"") {
        int r = ShowTaskDialog(GetResString(IDS_APP_TITLE).c_str(), GetResString(IDS_ELEVATED_SAVE_PROMPT).c_str(), p.c_str(), TDCBF_YES_BUTTON | TDCBF_NO_BUTTON, TD_SHIELD_ICON);
        if (r != IDYES) {
            return false;
        }
        std::wstring tempPath;
        bool deleteTempOnDone = false;
        if (!existingTempFile.empty()) {
            tempPath = existingTempFile;
            deleteTempOnDone = true;
        } else {
            wchar_t sysTempDir[MAX_PATH] = { 0 };
            wchar_t sysTempFile[MAX_PATH] = { 0 };
            if (GetTempPathW(MAX_PATH, sysTempDir) == 0 || GetTempFileNameW(sysTempDir, L"miu", 0, sysTempFile) == 0) {
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
                return false;
            }
            HANDLE h = CreateFileW(sysTempFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
            if (h == INVALID_HANDLE_VALUE) {
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), sysTempFile, TDCBF_OK_BUTTON, TD_ERROR_ICON);
                return false;
            }
            bool ok = writeContentToHandle(h);
            CloseHandle(h);
            if (!ok) {
                DeleteFileW(sysTempFile);
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_WRITE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
                return false;
            }
            tempPath = sysTempFile;
            deleteTempOnDone = true;
        }
        wchar_t exePath[MAX_PATH] = { 0 };
        GetModuleFileNameW(NULL, exePath, MAX_PATH);
        std::wstring params = L"--elevated-save \"" + tempPath + L"\" \"" + p + L"\"";
        SHELLEXECUTEINFOW sei = { sizeof(sei) };
        sei.cbSize = sizeof(sei);
        sei.fMask = SEE_MASK_NOCLOSEPROCESS;
        sei.hwnd = hwnd;
        sei.lpVerb = L"runas";
        sei.lpFile = exePath;
        sei.lpParameters = params.c_str();
        sei.nShow = SW_HIDE;
        if (!ShellExecuteExW(&sei)) {
            DWORD err = GetLastError();
            if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
            if (err != ERROR_CANCELLED) {
                std::wstring msg = GetResString(IDS_SAVE_ERR) + std::to_wstring(err);
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), msg.c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            }
            return false;
        }
        WaitForSingleObject(sei.hProcess, 30000);
        DWORD exitCode = 1;
        GetExitCodeProcess(sei.hProcess, &exitCode);
        CloseHandle(sei.hProcess);
        if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
        if (exitCode != 0) {
            std::wstring msg = GetResString(IDS_SAVE_ERR) + std::to_wstring(exitCode);
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), msg.c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        std::vector<Cursor> savedCursors = cursors; int savedV = vScrollPos; int savedSubV = vScrollSubLine; int savedH = hScrollPos;
        if (fileMap) fileMap->close();
        if (!openFileFromPath(p)) {
            ShowTaskDialog(GetResString(IDS_FATAL_ERROR).c_str(), GetResString(IDS_REOPEN_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        cursors = savedCursors; vScrollPos = savedV; vScrollSubLine = savedSubV; hScrollPos = savedH;
        updateScrollBars(); ensureCaretVisible(); updateTitleBar(); updateWindowIcon(); updateFileTime();
        return true;
    }
    bool saveFile(const std::wstring& p) {
        std::wstring t = p + L".tmp";
        HANDLE h = CreateFileW(t.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (h == INVALID_HANDLE_VALUE) {
            DWORD err = GetLastError();
            if (err == ERROR_ACCESS_DENIED) {
                return saveFileElevated(p);
            }
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), t.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        bool ok = writeContentToHandle(h);
        CloseHandle(h);
        if (!ok) {
            DeleteFileW(t.c_str());
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_WRITE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        std::vector<Cursor> savedCursors = cursors; int savedV = vScrollPos; int savedSubV = vScrollSubLine; int savedH = hScrollPos;
        std::wstring oldPath = currentFilePath;
        if (fileMap && fileMap->isMapped) fileMap->close();
        if (MoveFileExW(t.c_str(), p.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) == 0) {
            DWORD err = GetLastError();
            if (err == ERROR_ACCESS_DENIED) {
                bool elevRes = saveFileElevated(p, t);
                if (!elevRes) {
                    DeleteFileW(t.c_str());
                }
                return elevRes;
            }
            DeleteFileW(t.c_str());
            std::wstring msg = GetResString(IDS_SAVE_ERR) + std::to_wstring(err);
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), msg.c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        if (fileMap) fileMap->close();
        if (!openFileFromPath(p)) {
            ShowTaskDialog(GetResString(IDS_FATAL_ERROR).c_str(), GetResString(IDS_REOPEN_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        cursors = savedCursors; vScrollPos = savedV; vScrollSubLine = savedSubV; hScrollPos = savedH;
        updateScrollBars(); ensureCaretVisible(); updateTitleBar(); updateWindowIcon(); updateFileTime();
        return true;
    }
    bool saveFileAs() {
        WCHAR f[MAX_PATH] = { 0 }; std::wstring initialDir;
        if (!currentFilePath.empty()) {
            std::wstring fileName = currentFilePath;
            size_t lastSlash = currentFilePath.find_last_of(L"\\/");
            if (lastSlash != std::wstring::npos) {
                fileName = currentFilePath.substr(lastSlash + 1);
                if (lastSlash == 2 && currentFilePath[1] == L':') {
                    initialDir = currentFilePath.substr(0, 3);
                } else {
                    initialDir = currentFilePath.substr(0, lastSlash);
                }
            }
            wcscpy_s(f, MAX_PATH, fileName.c_str());
        }
        OPENFILENAMEW o = { 0 }; o.lStructSize = sizeof(o); o.hwndOwner = hwnd; o.lpstrFile = f; o.nMaxFile = MAX_PATH;
        o.lpstrFilter = L"All\0*.*\0Text\0*.txt\0"; o.nFilterIndex = 1; o.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
        if (!initialDir.empty()) o.lpstrInitialDir = initialDir.c_str();
        SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hAppIcon);
        if (GetSaveFileNameW(&o)) return saveFile(f);
        updateWindowIcon();
        return false;
    }
    void newFile() { if (!checkUnsavedChanges()) return; pt.initEmpty(); currentFilePath.clear(); newlineStr = "\r\n"; undo.clear(); isDirty = false; currentEncoding = ENC_UTF8_NOBOM; convertedBuffer.clear(); cursors.clear(); cursors.push_back({ 0,0,0.0f }); vScrollPos = 0; vScrollSubLine = 0; hScrollPos = 0; fileMap.reset(); rebuildLineStarts(); loadSyntaxForExtension(L""); updateThemeColors(); updateTitleBar(); updateWindowIcon(); lastWriteTime = { 0, 0 }; InvalidateRect(hwnd, NULL, FALSE); }
    void selectNextOccurrence() { if (cursors.empty()) return; Cursor c = cursors.back(); if (!c.hasSelection()) { size_t targetPos = c.head; if (targetPos > 0) { char currChar = pt.charAt(targetPos); char prevChar = pt.charAt(targetPos - 1); if (!isWordChar(currChar) && isWordChar(prevChar)) targetPos--; } selectWordAt(targetPos); InvalidateRect(hwnd, NULL, FALSE); return; } size_t start = c.start(); size_t len = c.end() - start; std::string query = pt.getRange(start, len); size_t nextPos = findText(std::max(c.head, c.anchor), query, true, true, false, false); if (nextPos != std::string::npos) { for (const auto& cur : cursors) { if (cur.start() == nextPos) return; } cursors.push_back({ nextPos + len, nextPos, getXFromPos(nextPos + len) }); ensureCaretVisible(); InvalidateRect(hwnd, NULL, FALSE); } }
    bool openFileFromPath(const std::wstring& path) {
        fileMap.reset(new MappedFile());
        if (fileMap->open(path.c_str())) {
            DetectResult encRes = DetectEncodingEx(fileMap->ptr, fileMap->size); currentEncoding = encRes.type; currentCodePage = encRes.codePage; convertedBuffer.clear(); const char* ptr = fileMap->ptr; size_t size = fileMap->size;
            switch (currentEncoding) {
            case ENC_UTF8_BOM: if (size >= 3) { ptr += 3; size -= 3; } pt.initFromFile(ptr, size); detectNewlineStyle(ptr, size); break;
            case ENC_UTF16LE: convertedBuffer = Utf16ToUtf8(ptr, size, false); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); break;
            case ENC_UTF16BE: convertedBuffer = Utf16ToUtf8(ptr, size, true); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); break;
            case ENC_LOCAL: convertedBuffer = LocalToUtf8(ptr, size, currentCodePage); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); break;
            default: pt.initFromFile(ptr, size); detectNewlineStyle(ptr, size); break;
            }
            std::wstring ext = L"";
            size_t dotPos = path.find_last_of(L".");
            if (dotPos != std::wstring::npos) ext = path.substr(dotPos + 1);
            loadSyntaxForExtension(ext);
            updateThemeColors();
            currentFilePath = path; undo.clear(); isDirty = false; undo.markSaved(); cursors.clear(); cursors.push_back({ 0, 0, 0.0f }); vScrollPos = 0; vScrollSubLine = 0; hScrollPos = 0; rebuildLineStarts(); updateTitleBar(); InvalidateRect(hwnd, NULL, FALSE); updateWindowIcon(); updateFileTime();
            addToRecentFiles(path);
            return true;
        }
        else { ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_OPEN_FAIL).c_str(), path.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON); return false; }
    }
    void indentLines(bool forceLineIndent = false) {
        bool hasSelection = false; for (const auto& c : cursors) if (c.hasSelection()) hasSelection = true; if (!hasSelection && !forceLineIndent) { insertAtCursors("\t"); return; }
        commitPadding(); std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::sort(lines.rbegin(), lines.rend());
        for (int lineIdx : lines) { size_t pos = lineStarts[lineIdx]; std::string indentStr = "\t"; pt.insert(pos, indentStr); batch.ops.push_back({ EditOp::Insert, pos, indentStr }); for (auto& c : cursors) { if (c.hasSelection()) { if (c.head > pos) c.head += indentStr.size(); if (c.anchor > pos) c.anchor += indentStr.size(); } else { if (c.head >= pos) c.head += indentStr.size(); if (c.anchor >= pos) c.anchor += indentStr.size(); } c.desiredX = getXFromPos(c.head); } }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void unindentLines() {
        commitPadding(); std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::sort(lines.rbegin(), lines.rend());
        for (int lineIdx : lines) { size_t pos = lineStarts[lineIdx]; if (pos >= pt.length()) continue; char c = pt.charAt(pos); size_t eraseLen = 0; if (c == '\t') eraseLen = 1; else if (c == ' ') eraseLen = 1; if (eraseLen > 0) { std::string deleted = pt.getRange(pos, eraseLen); pt.erase(pos, eraseLen); batch.ops.push_back({ EditOp::Erase, pos, deleted }); for (auto& c : cursors) { if (c.head > pos) c.head -= std::min(c.head - pos, eraseLen); if (c.anchor > pos) c.anchor -= std::min(c.anchor - pos, eraseLen); c.desiredX = getXFromPos(c.head); } } }
        if (!batch.ops.empty()) { batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
    }
    void insertNewlineWithAutoIndent() {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size()); for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i; std::sort(indices.begin(), indices.end(), [&](int a, int b) { return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) { Cursor& c = cursors[idx]; size_t start = c.start(); if (c.hasSelection()) { size_t len = c.end() - start; std::string deleted = pt.getRange(start, len); pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, deleted }); for (auto& o : cursors) { if (o.head > start) o.head -= len; if (o.anchor > start) o.anchor -= len; } c.head = start; c.anchor = start; } int lineIdx = getLineIdx(start); size_t lineStart = lineStarts[lineIdx]; std::string indentStr = ""; size_t p = lineStart; size_t maxLen = pt.length(); while (p < maxLen && p < start) { char ch = pt.charAt(p); if (ch == ' ' || ch == '\t') indentStr += ch; else break; p++; } std::string textToInsert = newlineStr + indentStr; pt.insert(start, textToInsert); batch.ops.push_back({ EditOp::Insert, start, textToInsert }); size_t insLen = textToInsert.size(); for (auto& o : cursors) { if (o.head >= start) o.head += insLen; if (o.anchor >= start) o.anchor += insLen; if (&o == &c) o.desiredX = getXFromPos(o.head); } }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void toggleFullScreen() {
        if (!hwnd) return; DWORD style = GetWindowLong(hwnd, GWL_STYLE);
        if (!isFullScreen) { if (GetWindowPlacement(hwnd, &prevPlacement)) { MONITORINFO mi = { sizeof(mi) }; if (GetMonitorInfo(MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY), &mi)) { SetWindowLong(hwnd, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW); SetWindowPos(hwnd, HWND_TOP, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top, SWP_NOOWNERZORDER | SWP_FRAMECHANGED); isFullScreen = true; } } }
        else { SetWindowLong(hwnd, GWL_STYLE, style | WS_OVERLAPPEDWINDOW); SetWindowPlacement(hwnd, &prevPlacement); SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED); isFullScreen = false; }
    }
} g_editor;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_COPYDATA: {
        COPYDATASTRUCT* pcds = (COPYDATASTRUCT*)lParam;
        if (pcds->dwData == 1) {
            std::wstring reqPath = (const wchar_t*)pcds->lpData;
            if (!g_editor.currentFilePath.empty() && _wcsicmp(g_editor.currentFilePath.c_str(), reqPath.c_str()) == 0) {
                addToRecentFiles(reqPath);
                return 1;
            }
        }
        return 0;
    }
    case WM_ACTIVATE:
        if (LOWORD(wParam) != WA_INACTIVE) {
            g_editor.checkFileModification();
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SETCURSOR: {
        if (LOWORD(lParam) == HTCLIENT) {
            POINT pt; GetCursorPos(&pt); ScreenToClient(hwnd, &pt); RECT rc; GetClientRect(hwnd, &rc);
            float mouseX = pt.x / g_editor.dpiScaleX; float mouseY = pt.y / g_editor.dpiScaleY;
            float clientW = (rc.right - rc.left) / g_editor.dpiScaleX; float clientH = (rc.bottom - rc.top) / g_editor.dpiScaleY;
            const float SB_HIT_WIDTH = 20.0f;
            bool onVScroll = (!g_editor.lineStarts.empty() && g_editor.lineStarts.size() > 1) && (mouseX >= clientW - SB_HIT_WIDTH);
            bool onHScroll = (!g_editor.wordWrapEnabled && g_editor.maxLineWidth > clientW) && (mouseY >= clientH - SB_HIT_WIDTH);
            if (onVScroll || onHScroll) SetCursor(LoadCursor(NULL, IDC_ARROW));
            else SetCursor(LoadCursor(NULL, IDC_IBEAM));
            return TRUE;
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    case WM_ERASEBKGND: return 1;
    case WM_CREATE: g_editor.initGraphics(hwnd); DragAcceptFiles(hwnd, TRUE); SetTimer(hwnd, 2, 2000, NULL); break;
    case WM_SETTINGCHANGE: { if (lParam && wcscmp((LPCWSTR)lParam, L"ImmersiveColorSet") == 0) g_editor.updateThemeColors(); break; }
    case WM_DPICHANGED: { float newDpiX = (float)LOWORD(wParam); float newDpiY = (float)HIWORD(wParam); RECT* const prcNewWindow = (RECT*)lParam; SetWindowPos(hwnd, NULL, prcNewWindow->left, prcNewWindow->top, prcNewWindow->right - prcNewWindow->left, prcNewWindow->bottom - prcNewWindow->top, SWP_NOZORDER | SWP_NOACTIVATE); g_editor.handleDpiChange(newDpiX, newDpiY); return 0; }
    case WM_WINDOWPOSCHANGED: return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SIZE: { RECT rc; GetClientRect(hwnd, &rc); int w = rc.right - rc.left; int h = rc.bottom - rc.top; if (w > 0 && h > 0) { g_editor.resizeSwapChain(w, h); g_editor.ensureCaretVisible(); } } break;
    case WM_LBUTTONDOWN: {
        if (g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); } int x = (short)LOWORD(lParam); int y = (short)HIWORD(lParam); RECT rc; GetClientRect(hwnd, &rc); float clientW = (rc.right - rc.left) / g_editor.dpiScaleX; float clientH = (rc.bottom - rc.top) / g_editor.dpiScaleY; float mouseX = x / g_editor.dpiScaleX; float mouseY = y / g_editor.dpiScaleY; const float SB_HIT_WIDTH = 20.0f; const float SB_PADDING = 0.0f;
        if (!g_editor.lineStarts.empty()) { float total = (float)g_editor.lineStarts.size(); float currentV = (float)g_editor.vScrollPos; if (g_editor.wordWrapEnabled && g_editor.lineStarts.size() == 1) { int count = g_editor.getLineVisualCount(0); if (count > 1) { total = (float)count; currentV = (float)g_editor.vScrollSubLine; } } float viewportLines = clientH / g_editor.lineHeight; if (total > 1.0f) { float maxScroll = std::max(1.0f, total - 1.0f); float trackH = clientH - (SB_PADDING * 2); if (g_editor.maxLineWidth > clientW && !g_editor.wordWrapEnabled) trackH -= SB_HIT_WIDTH; float virtualTotal = total + viewportLines - 1.0f; float thumbH = trackH * (viewportLines / virtualTotal); if (thumbH < 30.0f) thumbH = 30.0f; if (thumbH > trackH) thumbH = trackH; float progress = currentV / maxScroll; float thumbY = SB_PADDING + (trackH - thumbH) * progress; if (mouseX >= clientW - SB_HIT_WIDTH) { if (mouseY >= thumbY - 10 && mouseY <= thumbY + thumbH + 10) { g_editor.isVScrollDragging = true; g_editor.scrollDragOffset = mouseY - thumbY; SetCapture(hwnd); return 0; } } } }
        if (!g_editor.wordWrapEnabled && g_editor.maxLineWidth > clientW) { float total = g_editor.maxLineWidth; float visible = clientW; float maxScroll = std::max(1.0f, total - visible); float trackW = clientW - (SB_PADDING * 2); if (!g_editor.lineStarts.empty() && (float)g_editor.lineStarts.size() > 1.0f) trackW -= SB_HIT_WIDTH; float thumbW = trackW * (visible / total); if (thumbW < 30.0f) thumbW = 30.0f; if (thumbW > trackW) thumbW = trackW; float progress = (float)g_editor.hScrollPos / maxScroll; float thumbX = SB_PADDING + (trackW - thumbW) * progress; if (mouseY >= clientH - SB_HIT_WIDTH) { if (mouseX >= thumbX - 10 && mouseX <= thumbX + thumbW + 10) { g_editor.isHScrollDragging = true; g_editor.scrollDragOffset = mouseX - thumbX; SetCapture(hwnd); return 0; } } }
        SetCapture(hwnd); g_editor.isDragging = true; g_editor.rollbackPadding();
        if (abs(x - g_editor.lastClickX) < 5 && abs(y - g_editor.lastClickY) < 5 && (GetMessageTime() - g_editor.lastClickTime < GetDoubleClickTime())) g_editor.clickCount++; else g_editor.clickCount = 1;
        g_editor.lastClickTime = GetMessageTime(); g_editor.lastClickX = x; g_editor.lastClickY = y;
        if (g_editor.clickCount == 1 && !(GetKeyState(VK_SHIFT) & 0x8000)) { size_t p = g_editor.getDocPosFromPoint(x, y); bool inSel = false; for (const auto& c : g_editor.cursors) if (c.hasSelection() && p >= c.start() && p < c.end()) inSel = true; if (inSel) { g_editor.isDragMovePending = true; g_editor.dragMoveSourceStart = g_editor.cursors.back().start(); g_editor.dragMoveSourceEnd = g_editor.cursors.back().end(); return 0; } }
        g_editor.isDragMovePending = false; g_editor.isDragMoving = false;
        if (GetKeyState(VK_MENU) & 0x8000) { g_editor.isRectSelecting = true; float vx = x / g_editor.dpiScaleX - g_editor.gutterWidth + g_editor.hScrollPos; size_t p = g_editor.getDocPosFromPoint(x, y); g_editor.rectAnchorX = g_editor.rectHeadX = vx; g_editor.rectAnchorLine = g_editor.rectHeadLine = g_editor.getLineIdx(p); g_editor.updateRectSelection(); }
        else g_editor.isRectSelecting = false;
        if (x / g_editor.dpiScaleX < g_editor.gutterWidth) { int line = 0; if (g_editor.wordWrapEnabled) { size_t p = g_editor.getDocPosFromPoint((int)(g_editor.gutterWidth * g_editor.dpiScaleX + 5), y); line = g_editor.getLineIdx(p); } else { line = g_editor.vScrollPos + (int)(y / g_editor.dpiScaleY / g_editor.lineHeight); } if (line >= 0 && line < (int)g_editor.lineStarts.size()) { size_t s = g_editor.lineStarts[line]; size_t e = (line + 1 < (int)g_editor.lineStarts.size()) ? g_editor.lineStarts[line + 1] : g_editor.pt.length(); g_editor.cursors.clear(); g_editor.cursors.push_back({ e, s, g_editor.getXFromPos(e) }); } }
        else { size_t p = g_editor.getDocPosFromPoint(x, y); if (g_editor.clickCount == 2) g_editor.selectWordAt(p); else if (g_editor.clickCount == 3) g_editor.selectLineAt(p); else { if (GetKeyState(VK_SHIFT) & 0x8000) { if (!g_editor.cursors.empty()) { g_editor.cursors.back().head = p; g_editor.cursors.back().desiredX = g_editor.getXFromPos(p); } } else if (GetKeyState(VK_CONTROL) & 0x8000) g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) }); else { g_editor.cursors.clear(); g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) }); } } }
        InvalidateRect(hwnd, NULL, FALSE);
    } break;
    case WM_MOUSEMOVE: {
        if (!g_editor.isTrackingMouse) { TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT) }; tme.dwFlags = TME_LEAVE; tme.hwndTrack = hwnd; TrackMouseEvent(&tme); g_editor.isTrackingMouse = true; }
        int x = (short)LOWORD(lParam), y = (short)HIWORD(lParam); RECT rc; GetClientRect(hwnd, &rc); float clientW = (rc.right - rc.left) / g_editor.dpiScaleX; float clientH = (rc.bottom - rc.top) / g_editor.dpiScaleY; float mouseX = x / g_editor.dpiScaleX; float mouseY = y / g_editor.dpiScaleY; const float SB_HIT_WIDTH = 20.0f; const float SB_PADDING = 0.0f; bool prevVHover = g_editor.isVScrollHover; bool prevHHover = g_editor.isHScrollHover;
        if (g_editor.isVScrollDragging) { g_editor.isVScrollHover = true; g_editor.isHScrollHover = false; }
        else if (g_editor.isHScrollDragging) { g_editor.isVScrollHover = false; g_editor.isHScrollHover = true; }
        else { g_editor.isVScrollHover = (mouseX >= clientW - SB_HIT_WIDTH); g_editor.isHScrollHover = (!g_editor.wordWrapEnabled && g_editor.maxLineWidth > clientW && mouseY >= clientH - SB_HIT_WIDTH); }
        if (prevVHover != g_editor.isVScrollHover || prevHHover != g_editor.isHScrollHover) InvalidateRect(hwnd, NULL, FALSE);
        if (g_editor.isVScrollDragging || g_editor.isHScrollDragging) {
            if (g_editor.isVScrollDragging) { float total = (float)g_editor.lineStarts.size(); bool singleLineWrap = (g_editor.wordWrapEnabled && g_editor.lineStarts.size() == 1); int singleCount = singleLineWrap ? g_editor.getLineVisualCount(0) : 1; if (singleLineWrap && singleCount > 1) { total = (float)singleCount; } float viewportLines = clientH / g_editor.lineHeight; float maxScroll = std::max(1.0f, total - 1.0f); float trackH = clientH - (SB_PADDING * 2); if (g_editor.maxLineWidth > clientW && !g_editor.wordWrapEnabled) trackH -= SB_HIT_WIDTH; float virtualTotal = total + viewportLines - 1.0f; float thumbH = trackH * (viewportLines / virtualTotal); if (thumbH < 30.0f) thumbH = 30.0f; if (thumbH > trackH) thumbH = trackH; float newThumbY = mouseY - g_editor.scrollDragOffset; float relativeY = newThumbY - SB_PADDING; float scrollableArea = trackH - thumbH; if (scrollableArea > 0) { float ratio = relativeY / scrollableArea; if (ratio < 0.0f) ratio = 0.0f; if (ratio > 1.0f) ratio = 1.0f; if (singleLineWrap && singleCount > 1) { g_editor.vScrollSubLine = (int)(ratio * maxScroll); if (g_editor.vScrollSubLine < 0) g_editor.vScrollSubLine = 0; if (g_editor.vScrollSubLine > (int)maxScroll) g_editor.vScrollSubLine = (int)maxScroll; } else { g_editor.vScrollPos = (int)(ratio * maxScroll); if (g_editor.vScrollPos < 0) g_editor.vScrollPos = 0; if (g_editor.vScrollPos > (int)maxScroll) g_editor.vScrollPos = (int)maxScroll; g_editor.vScrollSubLine = 0; } } }
            else if (g_editor.isHScrollDragging) { float total = g_editor.maxLineWidth; float visible = clientW; float maxScroll = std::max(1.0f, total - visible); float trackW = clientW - (SB_PADDING * 2); if (!g_editor.lineStarts.empty() && (float)g_editor.lineStarts.size() > 1.0f) trackW -= SB_HIT_WIDTH; float thumbW = trackW * (visible / total); if (thumbW < 30.0f) thumbW = 30.0f; if (thumbW > trackW) thumbW = trackW; float newThumbX = mouseX - g_editor.scrollDragOffset; float relativeX = newThumbX - SB_PADDING; float scrollableArea = trackW - thumbW; if (scrollableArea > 0) { float ratio = relativeX / scrollableArea; g_editor.hScrollPos = (int)(ratio * maxScroll); } if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; if (g_editor.hScrollPos > (int)maxScroll) g_editor.hScrollPos = (int)maxScroll; }
            g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); return 0;
        }
        if (g_editor.isDragMovePending) { if (abs(x - g_editor.lastClickX) > 5 || abs(y - g_editor.lastClickY) > 5) { g_editor.isDragMovePending = false; g_editor.isDragMoving = true; SetCursor(LoadCursor(NULL, IDC_ARROW)); } }
        if (g_editor.isDragMoving) { g_editor.dragMoveDestPos = g_editor.getDocPosFromPoint(x, y); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (g_editor.isDragging && !g_editor.isDragMovePending) {
            bool outOfBounds = (x < g_editor.gutterWidth * g_editor.dpiScaleX || x > rc.right || y < 0 || y > rc.bottom);
            if (outOfBounds) {
                if (!g_editor.isAutoScrolling) { g_editor.isAutoScrolling = true; SetTimer(hwnd, 3, 30, NULL); }
            }
            else {
                if (g_editor.isAutoScrolling) { g_editor.isAutoScrolling = false; KillTimer(hwnd, 3); }
                if (g_editor.isRectSelecting) { float vx = x / g_editor.dpiScaleX - g_editor.gutterWidth + g_editor.hScrollPos; size_t p = g_editor.getDocPosFromPoint(x, y); g_editor.rectHeadX = vx; g_editor.rectHeadLine = g_editor.getLineIdx(p); g_editor.updateRectSelection(); }
                else { size_t p = g_editor.getDocPosFromPoint(x, y); if (!g_editor.cursors.empty()) { g_editor.cursors.back().head = p; g_editor.cursors.back().desiredX = g_editor.getXFromPos(p); } }
                InvalidateRect(hwnd, NULL, FALSE);
            }
        }
    } break;
    case WM_LBUTTONUP:
        if (g_editor.isVScrollDragging || g_editor.isHScrollDragging) { g_editor.isVScrollDragging = false; g_editor.isHScrollDragging = false; ReleaseCapture(); return 0; }
        if (g_editor.isAutoScrolling) { KillTimer(hwnd, 3); g_editor.isAutoScrolling = false; }
        if (g_editor.isDragMovePending) { g_editor.isDragMovePending = false; size_t p = g_editor.getDocPosFromPoint((short)LOWORD(lParam), (short)HIWORD(lParam)); g_editor.cursors.clear(); g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) }); InvalidateRect(hwnd, NULL, FALSE); }
        else if (g_editor.isDragMoving) g_editor.performDragMove();
        g_editor.isDragging = false; g_editor.isDragMoving = false; g_editor.mergeCursors(); ReleaseCapture(); break;
    case WM_MOUSELEAVE: { g_editor.isTrackingMouse = false; g_editor.isVScrollHover = false; g_editor.isHScrollHover = false; InvalidateRect(hwnd, NULL, FALSE); return 0; }
    case WM_VSCROLL: { RECT rc; GetClientRect(hwnd, &rc); int page = (int)((rc.bottom / g_editor.dpiScaleY) / g_editor.lineHeight); switch (LOWORD(wParam)) { case SB_LINEUP: g_editor.scrollVisualLines(-1); break; case SB_LINEDOWN: g_editor.scrollVisualLines(1); break; case SB_PAGEUP: g_editor.scrollVisualLines(-page); break; case SB_PAGEDOWN: g_editor.scrollVisualLines(page); break; case SB_THUMBTRACK: { SCROLLINFO si = { sizeof(SCROLLINFO), SIF_TRACKPOS }; GetScrollInfo(hwnd, SB_VERT, &si); g_editor.vScrollPos = si.nTrackPos; g_editor.vScrollSubLine = 0; } break; } if (g_editor.vScrollPos < 0) g_editor.vScrollPos = 0; if (g_editor.vScrollPos > (int)g_editor.lineStarts.size()) g_editor.vScrollPos = (int)g_editor.lineStarts.size(); g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); } break;
    case WM_HSCROLL: { switch (LOWORD(wParam)) { case SB_LINELEFT: g_editor.hScrollPos -= 10; break; case SB_LINERIGHT: g_editor.hScrollPos += 10; break; case SB_PAGELEFT: g_editor.hScrollPos -= 100; break; case SB_PAGERIGHT: g_editor.hScrollPos += 100; break; case SB_THUMBTRACK: { SCROLLINFO si = { sizeof(SCROLLINFO), SIF_TRACKPOS }; GetScrollInfo(hwnd, SB_HORZ, &si); g_editor.hScrollPos = si.nTrackPos; } break; } if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); } break;
    case WM_MOUSEWHEEL:
        if (GET_KEYSTATE_WPARAM(wParam) & MK_CONTROL) { float s = (GET_WHEEL_DELTA_WPARAM(wParam) > 0) ? 1.1f : 0.9f; g_editor.updateFont(g_editor.currentFontSize * s); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; std::wstringstream ss; ss << (int)g_editor.currentFontSize << L"px"; g_editor.zoomPopupText = ss.str(); SetTimer(hwnd, 1, 1000, NULL); }
        else { int notches = GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA; g_editor.scrollVisualLines(-notches * 3); }
        InvalidateRect(hwnd, NULL, FALSE); break;
    case WM_MOUSEHWHEEL: { if (g_editor.wordWrapEnabled) break; int delta = GET_WHEEL_DELTA_WPARAM(wParam); g_editor.hScrollPos += delta; if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; if (g_editor.hScrollPos > (int)g_editor.maxLineWidth) g_editor.hScrollPos = (int)g_editor.maxLineWidth; g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); } break;
    case WM_TIMER:
        if (wParam == 1) { KillTimer(hwnd, 1); InvalidateRect(hwnd, NULL, FALSE); }
        else if (wParam == 2) { g_editor.checkFileModification(); }
        else if (wParam == 3) {
            if (g_editor.isDragging && g_editor.isAutoScrolling) {
                POINT pt; GetCursorPos(&pt); ScreenToClient(hwnd, &pt); RECT rc; GetClientRect(hwnd, &rc);
                float clientW = (rc.right - rc.left) / g_editor.dpiScaleX;
                bool outOfBounds = (pt.x < g_editor.gutterWidth * g_editor.dpiScaleX || pt.x > rc.right || pt.y < 0 || pt.y > rc.bottom);
                if (outOfBounds) {
                    bool scrolled = false;
                    if (pt.y < 0) { g_editor.scrollVisualLines(-1); scrolled = true; }
                    else if (pt.y > rc.bottom) { g_editor.scrollVisualLines(1); scrolled = true; }
                    if (pt.x < g_editor.gutterWidth * g_editor.dpiScaleX) { if (g_editor.hScrollPos > 0) { g_editor.hScrollPos -= 10; if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; scrolled = true; } }
                    else if (pt.x > rc.right) { int maxH = g_editor.wordWrapEnabled ? 0 : std::max(0, (int)(g_editor.maxLineWidth - clientW + g_editor.charWidth * 4.0f)); if (g_editor.hScrollPos < maxH) { g_editor.hScrollPos += 10; scrolled = true; } }
                    if (scrolled) g_editor.updateScrollBars();
                    if (g_editor.isRectSelecting) {
                        float vx = pt.x / g_editor.dpiScaleX - g_editor.gutterWidth + g_editor.hScrollPos;
                        float vy = pt.y / g_editor.dpiScaleY + (g_editor.vScrollPos * g_editor.lineHeight);
                        g_editor.rectHeadX = vx; size_t p = g_editor.getDocPosFromPoint(pt.x, pt.y); g_editor.rectHeadLine = g_editor.getLineIdx(p); g_editor.updateRectSelection();
                    }
                    else {
                        size_t p = g_editor.getDocPosFromPoint(pt.x, pt.y);
                        if (!g_editor.cursors.empty()) { g_editor.cursors.back().head = p; g_editor.cursors.back().desiredX = g_editor.getXFromPos(p); }
                    }
                    InvalidateRect(hwnd, NULL, FALSE);
                }
                else { KillTimer(hwnd, 3); g_editor.isAutoScrolling = false; }
            }
            else { KillTimer(hwnd, 3); g_editor.isAutoScrolling = false; }
        }
        break;
    case WM_CHAR: {
        if (g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); } wchar_t c = (wchar_t)wParam; if (c < 32 && c != 8 && c != 13) break;
        if (c == 8) { g_editor.highSurrogate = 0; bool hadSelection = false; for (const auto& cur : g_editor.cursors) { if (cur.hasSelection()) { hadSelection = true; break; } } g_editor.rollbackPadding(); g_editor.backspaceAtCursors(!hadSelection); if (hadSelection) { for (auto& cur : g_editor.cursors) cur.anchor = cur.head; } InvalidateRect(hwnd, NULL, FALSE); }
        else if (c == 13) { g_editor.highSurrogate = 0; g_editor.insertNewlineWithAutoIndent(); }
        else { if (c >= 0xD800 && c <= 0xDBFF) { g_editor.highSurrogate = c; return 0; } std::wstring s; if (c >= 0xDC00 && c <= 0xDFFF) { if (g_editor.highSurrogate) { s += g_editor.highSurrogate; s += c; g_editor.highSurrogate = 0; } else return 0; } else { g_editor.highSurrogate = 0; s += c; } g_editor.insertAtCursors(WToUTF8(s)); }
    } break;
    case WM_IME_STARTCOMPOSITION: return 0;
    case WM_IME_COMPOSITION: { HIMC h = ImmGetContext(hwnd); if (h) { if (lParam & GCS_RESULTSTR) { DWORD s = ImmGetCompositionStringW(h, GCS_RESULTSTR, NULL, 0); if (s) { std::vector<wchar_t> b(s / 2); ImmGetCompositionStringW(h, GCS_RESULTSTR, b.data(), s); g_editor.insertAtCursors(WToUTF8(std::wstring(b.begin(), b.end()))); g_editor.imeComp.clear(); } } if (lParam & GCS_COMPSTR) { DWORD s = ImmGetCompositionStringW(h, GCS_COMPSTR, NULL, 0); if (s) { std::vector<wchar_t> b(s / 2); ImmGetCompositionStringW(h, GCS_COMPSTR, b.data(), s); g_editor.imeComp = WToUTF8(std::wstring(b.begin(), b.end())); } else g_editor.imeComp.clear(); } ImmReleaseContext(hwnd, h); InvalidateRect(hwnd, NULL, FALSE); } return 0; } break;
    case WM_IME_ENDCOMPOSITION: g_editor.imeComp.clear(); InvalidateRect(hwnd, NULL, FALSE); break;
    case WM_IME_SETCONTEXT: lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW; return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SYSCHAR:
        if (wParam == 'Z' || wParam == 'z') return 0;
        return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SYSKEYDOWN:
        if (wParam == 'Z') { g_editor.wordWrapEnabled = !g_editor.wordWrapEnabled; if (g_editor.wordWrapEnabled) g_editor.hScrollPos = 0; else g_editor.vScrollSubLine = 0; g_editor.ensureCaretVisible(); g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (wParam == VK_UP || wParam == VK_DOWN) {
            bool ctrl = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
            bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
            if (ctrl) g_editor.addCursor(wParam == VK_UP);
            else if (shift) g_editor.duplicateLines(wParam == VK_UP);
            else g_editor.moveLines(wParam == VK_UP);
            return 0;
        } if (wParam != VK_LEFT && wParam != VK_RIGHT) return DefWindowProc(hwnd, msg, wParam, lParam); break;
    case WM_KEYDOWN:
        if (wParam == VK_INSERT) { if (!(GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_SHIFT) & 0x8000)) { g_editor.isOverwriteMode = !g_editor.isOverwriteMode; InvalidateRect(hwnd, NULL, FALSE); return 0; } }
        if (wParam == VK_TAB) { if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.unindentLines(); else { if (g_editor.isRectSelecting) g_editor.insertAtCursors("\t"); else g_editor.indentLines(false); } return 0; }
        if (GetKeyState(VK_CONTROL) & 0x8000) {
            switch (wParam) {
            case 'O': g_editor.openFile(); return 0;
            case 'N': case VK_F4: g_editor.newFile(); return 0;
            case 'S': if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.saveFileAs(); else if (g_editor.currentFilePath.empty()) g_editor.saveFileAs(); else g_editor.saveFile(g_editor.currentFilePath); return 0;
            case 'W': PostMessage(hwnd, WM_CLOSE, 0, 0); return 0;
            case 'Z': g_editor.performUndo(); return 0;
            case 'Y': g_editor.performRedo(); return 0;
            case 'C': case VK_INSERT: g_editor.copyToClipboard(); return 0;
            case 'X': g_editor.cutToClipboard(); return 0;
            case 'V': g_editor.pasteFromClipboard(); return 0;
            case 'D': g_editor.selectNextOccurrence(); return 0;
            case 'G': g_editor.showGoToDialog(); return 0;
            case 'L': if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.deleteLines(); else g_editor.showGoToDialog(); return 0;
            case VK_OEM_6: g_editor.indentLines(true); return 0;
            case VK_OEM_4: g_editor.unindentLines(); return 0;
            case 'U': if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.convertCase(false); else g_editor.convertCase(true); return 0;
            case 'B': g_editor.jumpToMatchingBracket(); return 0;
            case 'A': { g_editor.rollbackPadding(); g_editor.cursors.clear(); g_editor.cursors.push_back({ g_editor.pt.length(), 0, 0.0f }); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case 'K': if (GetKeyState(VK_SHIFT) & 0x8000) { g_editor.deleteLines(); return 0; } break;
            case VK_ADD: case VK_OEM_PLUS: { g_editor.updateFont(g_editor.currentFontSize * 1.1f); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; std::wstringstream ss; ss << (int)g_editor.currentFontSize << L"px"; g_editor.zoomPopupText = ss.str(); SetTimer(hwnd, 1, 1000, NULL); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case VK_SUBTRACT: case VK_OEM_MINUS: { g_editor.updateFont(g_editor.currentFontSize * 0.9f); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; std::wstringstream ss; ss << (int)g_editor.currentFontSize << L"px"; g_editor.zoomPopupText = ss.str(); SetTimer(hwnd, 1, 1000, NULL); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case '0': case VK_NUMPAD0: { g_editor.updateFont(21.0f); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; std::wstringstream ss; ss << (int)g_editor.currentFontSize << L"px"; g_editor.zoomPopupText = ss.str(); SetTimer(hwnd, 1, 1000, NULL); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case VK_UP:
            case VK_DOWN: {
                bool alt = (GetKeyState(VK_MENU) & 0x8000) != 0;
                if (alt) {
                    g_editor.addCursor(wParam == VK_UP);
                } else {
                    bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
                    g_editor.rollbackPadding();
                    g_editor.jumpToFileEdge(wParam == VK_UP, shift);
                }
                return 0;
            }
            default: break;
            }
        }
        if ((GetKeyState(VK_SHIFT) & 0x8000) && wParam == VK_INSERT) { g_editor.pasteFromClipboard(); return 0; }
        if (wParam == VK_ESCAPE) { g_editor.rollbackPadding(); if (!g_editor.cursors.empty()) { Cursor c = g_editor.cursors.back(); c.anchor = c.head; g_editor.cursors.clear(); g_editor.cursors.push_back(c); g_editor.isRectSelecting = false; InvalidateRect(hwnd, NULL, FALSE); } return 0; }
        if (wParam == VK_DELETE) { g_editor.rollbackPadding(); g_editor.isRectSelecting = false; g_editor.deleteForwardAtCursors(); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); }
        if (wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_UP || wParam == VK_DOWN || wParam == VK_HOME || wParam == VK_END || wParam == VK_PRIOR || wParam == VK_NEXT) {
            bool shift = (GetKeyState(VK_SHIFT) & 0x8000); bool ctrl = (GetKeyState(VK_CONTROL) & 0x8000); bool alt = (GetKeyState(VK_MENU) & 0x8000);
            if (alt && shift && (wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_UP || wParam == VK_DOWN)) {
                if (!g_editor.isRectSelecting) {
                    g_editor.isRectSelecting = true;
                    if (g_editor.cursors.size() > 1) {
                        int minLine = (int)g_editor.lineStarts.size();
                        int maxLine = -1;
                        for (const auto& c : g_editor.cursors) {
                            int l = (int)g_editor.getLineIdx(c.head);
                            if (l < minLine) minLine = l;
                            if (l > maxLine) maxLine = l;
                        }
                        if (minLine > maxLine) { minLine = maxLine = 0; }
                        const auto& refCursor = g_editor.cursors.back();
                        if (refCursor.hasSelection()) {
                            g_editor.rectAnchorX = g_editor.getXFromPos(refCursor.anchor);
                            g_editor.rectHeadX = g_editor.getXFromPos(refCursor.head);
                        } else {
                            g_editor.rectAnchorX = g_editor.rectHeadX = (refCursor.desiredX > 0.0f || refCursor.head == g_editor.lineStarts[minLine]) ? refCursor.desiredX : g_editor.getXFromPos(refCursor.head);
                        }
                        g_editor.rectAnchorLine = minLine;
                        g_editor.rectHeadLine = maxLine;
                    } else {
                        size_t p = g_editor.cursors.empty() ? 0 : g_editor.cursors.back().head;
                        g_editor.rectAnchorX = g_editor.rectHeadX = g_editor.getXFromPos(p);
                        g_editor.rectAnchorLine = g_editor.rectHeadLine = g_editor.getLineIdx(p);
                    }
                }
                if (wParam == VK_LEFT || wParam == VK_RIGHT) { int lineIdx = g_editor.rectHeadLine; if (lineIdx < 0) lineIdx = 0; if (lineIdx >= (int)g_editor.lineStarts.size()) lineIdx = (int)g_editor.lineStarts.size() - 1; size_t pos = g_editor.getPosFromLineAndX(lineIdx, g_editor.rectHeadX); float textEndX = g_editor.getXFromPos(pos); bool inVirtualSpace = (g_editor.rectHeadX > textEndX + 1.0f); if (inVirtualSpace) { if (wParam == VK_LEFT) { g_editor.rectHeadX -= g_editor.charWidth; if (g_editor.rectHeadX < textEndX) g_editor.rectHeadX = textEndX; } else g_editor.rectHeadX += g_editor.charWidth; } else { bool forward = (wParam == VK_RIGHT); size_t nextPos = g_editor.moveCaretVisual(pos, forward); g_editor.rectHeadX = g_editor.getXFromPos(nextPos); } }
                if (wParam == VK_UP) { if (g_editor.rectHeadLine > 0) g_editor.rectHeadLine--; } if (wParam == VK_DOWN) { if (g_editor.rectHeadLine + 1 < (int)g_editor.lineStarts.size()) g_editor.rectHeadLine++; } g_editor.updateRectSelection(); InvalidateRect(hwnd, NULL, FALSE); return 0;
            }
            g_editor.rollbackPadding(); g_editor.isRectSelecting = false;
            for (auto& c : g_editor.cursors) {
                if (wParam == VK_LEFT) { c.affinity = false; if (c.hasSelection() && !shift) { c.head = c.start(); c.anchor = c.head; } else { if (ctrl) c.head = g_editor.moveWordLeft(c.head); else c.head = g_editor.moveCaretVisual(c.head, false); if (!shift) c.anchor = c.head; } }
                else if (wParam == VK_RIGHT) {
                    if (c.hasSelection() && !shift) {
                        c.affinity = false;
                        c.head = c.end();
                        c.anchor = c.head;
                    } else {
                        if (ctrl) {
                            c.affinity = false;
                            c.head = g_editor.moveWordRight(c.head);
                            if (!shift) c.anchor = c.head;
                        } else {
                            if (g_editor.wordWrapEnabled) {
                                size_t nextPos = g_editor.moveCaretVisual(c.head, true);
                                bool isWrap = g_editor.isVisualLineWrapBoundary(nextPos, c.head);
                                c.head = nextPos;
                                c.affinity = isWrap;
                                if (!shift) c.anchor = c.head;
                            } else {
                                c.affinity = false;
                                c.head = g_editor.moveCaretVisual(c.head, true);
                                if (!shift) c.anchor = c.head;
                            }
                        }
                    }
                }
                else if (wParam == VK_UP) { c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, true, c.affinity, c.affinity); if (!shift) c.anchor = c.head; }
                else if (wParam == VK_DOWN) { c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, false, c.affinity, c.affinity); if (!shift) c.anchor = c.head; }
                else if (wParam == VK_HOME) { if (ctrl) { c.head = 0; c.affinity = false; } else { if (g_editor.wordWrapEnabled) c.head = g_editor.moveVisualHome(c.head, c.affinity, c.affinity); else { c.affinity = false; size_t p = c.head; while (p > 0 && g_editor.pt.charAt(p - 1) != '\n') p--; c.head = p; } } if (!shift) c.anchor = c.head; }
                else if (wParam == VK_END) { if (ctrl) { c.head = g_editor.pt.length(); c.affinity = false; } else { if (g_editor.wordWrapEnabled) c.head = g_editor.moveVisualEnd(c.head, c.affinity, c.affinity); else { c.affinity = false; size_t p = c.head; size_t len = g_editor.pt.length(); while (p < len && g_editor.pt.charAt(p) != '\n') p++; if (p > 0 && p < len && g_editor.pt.charAt(p) == '\n') { if (g_editor.pt.charAt(p - 1) == '\r') p--; } c.head = p; } } if (!shift) c.anchor = c.head; c.desiredX = g_editor.getXFromPos(c.head, c.affinity); }
                else if (wParam == VK_PRIOR) { RECT r; GetClientRect(hwnd, &r); int p = (int)((r.bottom / g_editor.dpiScaleY) / g_editor.lineHeight); if (g_editor.wordWrapEnabled) { for (int i = 0; i < p; ++i) c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, true, c.affinity, c.affinity); } else { c.affinity = false; int l = g_editor.getLineIdx(c.head); c.head = g_editor.getPosFromLineAndX(std::max(0, l - p), c.desiredX); } if (!shift) c.anchor = c.head; }
                else if (wParam == VK_NEXT) { RECT r; GetClientRect(hwnd, &r); int p = (int)((r.bottom / g_editor.dpiScaleY) / g_editor.lineHeight); if (g_editor.wordWrapEnabled) { for (int i = 0; i < p; ++i) c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, false, c.affinity, c.affinity); } else { c.affinity = false; int l = g_editor.getLineIdx(c.head); c.head = g_editor.getPosFromLineAndX(std::min((int)g_editor.lineStarts.size() - 1, l + p), c.desiredX); } if (!shift) c.anchor = c.head; }
                if (wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_HOME || wParam == VK_END) c.desiredX = g_editor.getXFromPos(c.head, c.affinity);
            }
            g_editor.mergeCursors(); g_editor.ensureCaretVisible(); InvalidateRect(hwnd, NULL, FALSE);
        } break;
    case WM_DROPFILES: { if (g_editor.checkUnsavedChanges()) { HDROP hDrop = (HDROP)wParam; WCHAR file[MAX_PATH]; if (DragQueryFileW(hDrop, 0, file, MAX_PATH) && g_editor.openFileFromPath(file) && g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); } DragFinish(hDrop); } } break;
    case WM_INITMENU: updateSystemMenu(hwnd); break;
    case WM_INITMENUPOPUP: if ((BOOL)HIWORD(lParam)) updateSystemMenu(hwnd); break;
    case WM_SYSCOMMAND: {
        UINT cmd = (UINT)(wParam & 0xFFF0);
        if (cmd >= IDM_RECENT_BASE && cmd < IDM_RECENT_BASE + (UINT)(MAX_RECENT_MENU_ITEMS * 16)) {
            size_t idx = (cmd - IDM_RECENT_BASE) / 16;
            if (idx < s_sysMenuRecentFiles.size()) {
                std::wstring fileToOpen = s_sysMenuRecentFiles[idx];
                if (g_editor.checkUnsavedChanges()) {
                    if (g_editor.openFileFromPath(fileToOpen)) {
                        if (g_editor.showHelpPopup) {
                            g_editor.showHelpPopup = false;
                        }
                        EnableDarkModeForWindow(hwnd, g_editor.isDarkMode);
    updateSystemMenu(hwnd);
                        InvalidateRect(hwnd, NULL, FALSE);
                    } else {
                        removeFromRecentFiles({ fileToOpen });
                        updateJumpList();
                        updateSystemMenu(hwnd);
                    }
                }
            }
            return 0;
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    case WM_CLOSE: if (g_editor.checkUnsavedChanges()) DestroyWindow(hwnd); return 0;
    case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hwnd, &ps); g_editor.render(); EndPaint(hwnd, &ps); } break;
    case WM_DESTROY: KillTimer(hwnd, 2); KillTimer(hwnd, 3); g_editor.destroyGraphics(); PostQuitMessage(0); break;
    default: return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}
int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nShowCmd) {
    int argc; wchar_t** argv = CommandLineToArgvW(GetCommandLineW(), &argc);
    if (argv && argc >= 2 && _wcsicmp(argv[1], L"--elevated-save") == 0) {
        if (argc >= 4) {
            std::wstring src = argv[2];
            std::wstring dst = argv[3];
            BOOL ok = CopyFileW(src.c_str(), dst.c_str(), FALSE);
            if (!ok) {
                DWORD attr = GetFileAttributesW(dst.c_str());
                if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_READONLY)) {
                    SetFileAttributesW(dst.c_str(), attr & ~FILE_ATTRIBUTE_READONLY);
                    ok = CopyFileW(src.c_str(), dst.c_str(), FALSE);
                }
            }
            DWORD exitCode = ok ? 0 : GetLastError();
            DeleteFileW(src.c_str());
            LocalFree(argv);
            return (int)exitCode;
        }
        LocalFree(argv);
        return ERROR_INVALID_PARAMETER;
    }
    SetCurrentProcessExplicitAppUserModelID(L"miu");
    InitDarkMode();
    updateJumpList();
    // SetThreadUILanguage(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT));

    SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
    std::wstring fileToOpen;
    bool newWindow = false;
    bool forceF1 = false;
    int customWidth = 0;
    int customHeight = 0;

    for (int i = 1; i < argc; ++i) {
        if (_wcsicmp(argv[i], L"--lang") == 0 && i + 1 < argc) {
            std::wstring l = argv[++i];
            if (_wcsicmp(l.c_str(), L"zh-tw") == 0 || _wcsicmp(l.c_str(), L"zh-hant") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL));
            } else if (_wcsicmp(l.c_str(), L"de") == 0 || _wcsicmp(l.c_str(), L"de-de") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_GERMAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"fr") == 0 || _wcsicmp(l.c_str(), L"fr-fr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_FRENCH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"es") == 0 || _wcsicmp(l.c_str(), L"es-es") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_SPANISH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"pt") == 0 || _wcsicmp(l.c_str(), L"pt-br") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_PORTUGUESE, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"ru") == 0 || _wcsicmp(l.c_str(), L"ru-ru") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"it") == 0 || _wcsicmp(l.c_str(), L"it-it") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_ITALIAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"pl") == 0 || _wcsicmp(l.c_str(), L"pl-pl") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_POLISH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"nl") == 0 || _wcsicmp(l.c_str(), L"nl-nl") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_DUTCH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"tr") == 0 || _wcsicmp(l.c_str(), L"tr-tr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_TURKISH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"en") == 0 || _wcsicmp(l.c_str(), L"en-us") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
            } else if (_wcsicmp(l.c_str(), L"ja") == 0 || _wcsicmp(l.c_str(), L"ja-jp") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"zh-cn") == 0 || _wcsicmp(l.c_str(), L"zh-hans") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_CHINESE, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"ko") == 0 || _wcsicmp(l.c_str(), L"ko-kr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_KOREAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"vi") == 0 || _wcsicmp(l.c_str(), L"vi-vn") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_VIETNAMESE, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"uk") == 0 || _wcsicmp(l.c_str(), L"uk-ua") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_UKRAINIAN, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"id") == 0 || _wcsicmp(l.c_str(), L"id-id") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_INDONESIAN, SUBLANG_DEFAULT));
            }
        } else if (_wcsicmp(argv[i], L"--theme") == 0 && i + 1 < argc) {
            std::wstring t = argv[++i];
            if (_wcsicmp(t.c_str(), L"light") == 0) g_editor.forceTheme = 1;
            else if (_wcsicmp(t.c_str(), L"dark") == 0) g_editor.forceTheme = 2;
        } else if (_wcsicmp(argv[i], L"--f1") == 0) {
            forceF1 = true;
        } else if (_wcsicmp(argv[i], L"--new-window") == 0) {
            newWindow = true;
        } else if (_wcsicmp(argv[i], L"--width") == 0 && i + 1 < argc) {
            customWidth = _wtoi(argv[++i]);
        } else if (_wcsicmp(argv[i], L"--height") == 0 && i + 1 < argc) {
            customHeight = _wtoi(argv[++i]);
        } else if (argv[i][0] != L'-') {
            wchar_t fullPath[MAX_PATH];
            if (GetFullPathNameW(argv[i], MAX_PATH, fullPath, NULL)) {
                fileToOpen = fullPath;
            }
        }
    }

    if (!fileToOpen.empty() && !newWindow) {
        HWND hExisting = NULL;
        HWND hwndEnum = FindWindowExW(NULL, NULL, L"miu", NULL);
        while (hwndEnum != NULL) {
            COPYDATASTRUCT cds;
            cds.dwData = 1;
            cds.cbData = (DWORD)((fileToOpen.length() + 1) * sizeof(wchar_t));
            cds.lpData = (PVOID)fileToOpen.c_str();
            if (SendMessage(hwndEnum, WM_COPYDATA, 0, (LPARAM)&cds) == 1) {
                hExisting = hwndEnum;
                break;
            }
            hwndEnum = FindWindowExW(NULL, hwndEnum, L"miu", NULL);
        }
        if (hExisting) {
            if (IsIconic(hExisting)) ShowWindow(hExisting, SW_RESTORE);
            SetForegroundWindow(hExisting);
            LocalFree(argv);
            return 0;
        }
    }
    WNDCLASS wc = { 0 }; wc.lpfnWndProc = WndProc; wc.hInstance = hInstance; wc.lpszClassName = L"miu"; wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1)); RegisterClass(&wc);
    UINT dpi = GetDpiForSystem(); if (dpi == 0) dpi = 96;
    int initialWidth = customWidth > 0 ? customWidth : MulDiv(800, dpi, 96);
    int initialHeight = customHeight > 0 ? customHeight : MulDiv(640, dpi, 96);
    HWND hwnd = CreateWindowEx(WS_EX_NOREDIRECTIONBITMAP, wc.lpszClassName, L"miu", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, initialWidth, initialHeight, NULL, NULL, hInstance, NULL);
    updateSystemMenu(hwnd);
    if (!hwnd) return 0; ShowWindow(hwnd, nShowCmd);
    if (!fileToOpen.empty()) {
        g_editor.openFileFromPath(fileToOpen);
        if (forceF1) {
            g_editor.showHelpPopup = true;
            InvalidateRect(hwnd, NULL, FALSE);
        }
    }
    else {
        g_editor.showHelpPopup = true;
        InvalidateRect(hwnd, NULL, FALSE);
    }
    LocalFree(argv);
    g_editor.updateTitleBar(); MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        if (msg.message == WM_KEYDOWN) {
            if (msg.wParam == VK_F1) { g_editor.showHelpPopup = !g_editor.showHelpPopup; InvalidateRect(hwnd, NULL, FALSE); continue; }
            if (msg.wParam == VK_F3) { bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0; g_editor.findNext(!shift); continue; }
            if (msg.wParam == VK_F11) { g_editor.toggleFullScreen(); continue; }
            if (GetKeyState(VK_CONTROL) & 0x8000) { if (msg.wParam == 'F') { g_editor.showFindDialog(false); continue; } if (msg.wParam == 'H' || msg.wParam == 'R') { g_editor.showFindDialog(true); continue; } }
        }
        if (g_editor.showHelpPopup && (msg.message == WM_KEYDOWN || msg.message == WM_CHAR || msg.message == WM_LBUTTONDOWN)) { if (msg.message == WM_KEYDOWN && msg.wParam == VK_F1) {} else { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); } }
        if (!g_editor.hFindDlg || !IsDialogMessage(g_editor.hFindDlg, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); }
    }
    return 0;
}