zhipuzi_pos_windows/DuiLib/Core/UIBase.cpp

#include "StdAfx.h"
#include "UIBase.h"
#include "UIManager.h"

#ifdef _DEBUG
#include <shlwapi.h>
#pragma comment(lib, "shlwapi.lib")
#endif

namespace DuiLib {

// WM_TOUCH 消息 ID 在 winuser.h 里受 `#if _WIN32_WINNT >= 0x0601` 保护，
// 而 DuiLib 工程的 _WIN32_WINNT 兜底为 XP(0x0501)，直接引用会编译失败，这里自行声明。
#ifndef WM_TOUCH
#define WM_TOUCH 0x0240
#endif
// 注：WM_POINTER* 常量统一放在 UIManager.cpp 的 PointerMsg 命名空间里（那边才是处理方），
// 本文件不再重复定义 —— 原先为"模态期间屏蔽 owner 输入"定义的 DUI_WM_POINTER_FIRST/LAST
// 已随 IsModalBlockedInputMessage 一并删除。

namespace {

    // -------------------------------------------------------------------------
    // [模态提示音] Win7 上"点控件触发弹框"时的一声"咚"。  （已定位成因，2026-09-21）
    //
    // ── 现象（用户描述）─────────────────────────────────────────────────────
    //   Win7：手指点主窗口某个控件 → 该控件的回调里 ShowModal() 弹出模态框 →
    //         **咚** 一声。手指若点在弹框自己的显示区域内，则没有这声。
    //   用户明确边界：
    //     · 弹框**已经出现之后**再点弹框外的空白区发出咚声 —— **正常，不要动**；
    //     · 要消除的只是"点击动作发生在弹框出现之前"却发出咚声的那一声。
    //
    // ── 成因（真机日志实证，非本项目 bug）──────────────────────────────────
    //   真模态由 DialogBoxIndirectParam 创建，它会把 owner 置为 IsWindowEnabled(FALSE)
    //   以阻挡输入。而 Win32 的默认处理规定：**用户点击一个被禁用的窗口时发出
    //   MessageBeep(0)** —— 这是 Windows 有意给的"操作无效"提示音。
    //
    //   本机触摸走的是指针栈（WM_TOUCH 实测 0 条），而**触摸的手势归属是按键序列
    //   一次性决定的**：整个"按下 → 抬起"序列的指针消息全部投给**按下那一刻命中的
    //   窗口**。真机日志里可以直接看到这条规则被违反后的结果（行 1611 - 1690）：
    //
    //     1611  POINTER-MSG UP hwnd=00D4055C ...          ← owner(主窗口) 收到抬起
    //     1614  POINTER-MSG UP click-candidate diandan_fooditem
    //     1621  MODAL-DLG enter old=... owner=00D4055C     ← 回调里 ShowModal，owner 被禁用
    //     1638  INPUT-TRACE target=00D4055C msg=0x0006 WM_ACTIVATE ... enable=0
    //                                                      ↑ 这一刻 owner 才变成禁用
    //     1643  INPUT-TRACE target=00D4055C msg=0x024A WM_POINTER* ... enable=0
    //     1666  POINTER-MSG UP click-candidate diandan_nature_save   ← 弹框内点击，关闭弹框
    //     1684  INPUT-TRACE target=00D4055C msg=0x0201 WM_LBUTTONDOWN ... extra=0xFF51578B
    //                                                      ↑ 系统**补发**的、属于本次触摸的
    //                                                        提升鼠标按下，落在已启用的 owner 上
    //
    //   关键在最后一行：手势结束时（owner 已重新启用），系统才把这条**早在手势开始时就
    //   排定好归属**的提升鼠标消息投递出来。可 owner 在手势中途反复被 EnableWindow(FALSE)
    //   / TRUE 切换 —— 只要这条消息落在"owner 正处于禁用"的那一瞬间，系统就走
    //   "点击了禁用窗口"的默认处理 ⇒ 咚。
    //   Win10 无此现象，是因为它在指针层就把落点判掉，根本不会把消息投给被禁用的窗口。
    //
    // ── 为什么不用"屏蔽消息"的解法（曾误判，已弃）──────────────────────────
    //   我一度写过一个基于 WH_GETMESSAGE 的钩子，无条件丢弃投给 owner 的点击类消息。
    //   它错在：**弹框已出现后点空白区的那一声，用户明确说要保留**。而无条件丢弃会把它
    //   一起消掉 —— 连正常的"无效操作"反馈都没了，方向反了。整段删除。
    //
    // ── 采用的解法 ────────────────────────────────────────────────────────
    //   不动消息流、不挂钩子，只在**库内**把"同一次手势的第二遍处理"精确拦掉。
    //
    //   核心认识：一次触摸手势会被处理**两遍** ——
    //     第 1 遍：DuiLib 自己的触摸状态机（WM_POINTER* / WM_TOUCH）合成点击，
    //              同步派发到控件、触发业务回调；
    //     第 2 遍：系统把这次触摸"提升"成的鼠标消息（带 MOUSEEVENTF_FROMTOUCH，
    //              即 GetMessageExtraInfo() 高位的 0xFF5157xx），排在消息队列里稍后投出。
    //   第 2 遍是多余的，必须丢——它正是"咚"和"弹框被自动点掉"的元凶。
    //
    //   判定与执行（见 CPaintManagerUI::MessageHandler 里 WM_LBUTTONDOWN/UP 分支）：
    //     · m_bSuppressPromotedMouseForModal —— 由 ShowModal() 在进入模态循环**之前**置位
    //     · IsPromotedTouchMouseMessage()    —— 只丢触摸提升的，真实鼠标点击天然豁免
    //     · IsModalInputTarget(m_hWndPaint)  —— 目标是"弹框本身"或"弹框的 owner"
    //   生命周期按**手势配对**（DOWN 记账 / UP 销账，归零即解除），另有 10 秒僵尸兜底。
    //   因此"弹框已出现后点空白区"那一声（要求保留的）照旧会响。
    //
    //   撤防点（确定性，不依赖超时）：
    //     a) CWindowWnd::Close() 的 m_bDoModal 分支，在 EndDialog 之前；
    //     b) __DialogWndProc 的 WM_NCDESTROY 收尾，任何销毁路径都会走到；
    //     c) ShowModal() 返回后的兜底。
    //
    //   ⚠️ 本文件此处仅保留文字说明，不再有任何钩子/屏蔽类实现。
    //
    // ── 第十一轮补充：上面这套"三条件拦截"**单独并不足以**修掉那四个 bug ──────
    //   真机验证：第九、十两轮的改动全部无效。第十一轮找到真正的两个根因
    //   （详见 UIManager.cpp 的 AttachPaintWindow 与 TOUCH-STATE timeout-reset）：
    //
    //     (A) **AttachPaintWindow 漏清输入状态**。真模态把**同一个** manager 从旧窗口
    //         搬到弹框，控件树 m_pRoot 是同一棵。而 AttachDialog（非模态路径）会清
    //         m_pEventKey/Hover/Click/RClick，AttachPaintWindow 当初漏了同一组
    //         ⇒ m_pEventHover 仍指着主窗口那个商品控件，弹框期间没人去清它
    //         ⇒ **悬浮态一直亮到弹框关闭**（用户报的第 4 个 bug）。
    //         同时 m_pEventClick / m_bMouseCapture 等旧手势中间态被带进弹框
    //         ⇒ 弹框第一条输入就撞上"进行中的手势"，为本文件上面那套拦截**制造了输入**。
    //         已在 AttachPaintWindow 开头补齐清理。
    //
    //     (B) **TOUCH-STATE timeout-reset 只看时间、不看模态是否存活**。
    //         模态期间这些手势状态本来就是"故意冻结"的（在等嵌套模态循环返回），
    //         超时却会在 3 秒后把它们清掉 ⇒ 抑制位失效 ⇒ 第 2 遍消息漏网。
    //         **这正是用户报的"超过 3 秒就透点"**。
    //         ⚠️ 最终处理（用户明确要求"不要时间戳，完全根据状态来判断"）：
    //           该 3000ms 超时已**整段删除**，连同指针通道那条同类超时一并删除。
    //           抑制位现在只由"配对的那条提升 UP 到达"解除（纯状态）。
    //           论证见 UIManager.cpp 里被删处的长注释（逐条证明这些状态不会泄漏）。
    //
    //   结论：本文件的三条件拦截是**必要条件**（拦第 2 遍消息），
    //   但必须配合上面 (A)(B) 两条才有可能真正成立 ——
    //   之前只做拦截、不做 (A)(B)，等于"防线摆好了，但门在别处开着"。
    // -------------------------------------------------------------------------

    typedef BOOL (WINAPI* PFN_REGISTER_TOUCH_WINDOW)(HWND, ULONG);

    // 与 SDK tagTOUCHINPUT 布局一致的私有副本（同样受 _WIN32_WINNT 保护，不能直接用）
    struct TRACE_TOUCHINPUT
    {
        LONG      x;
        LONG      y;
        HANDLE    hSource;
        DWORD     dwID;
        DWORD     dwFlags;
        DWORD     dwMask;
        DWORD     dwTime;
        ULONG_PTR dwExtraInfo;
        DWORD     cxContact;
        DWORD     cyContact;
    };
    typedef BOOL (WINAPI* PFN_GET_TOUCH_INPUT_INFO)(HANDLE, UINT, TRACE_TOUCHINPUT*, int);

    void RegisterTouchWindowIfAvailable(HWND hWnd)
    {
        if (hWnd == NULL) return;
        HMODULE hUser32 = ::GetModuleHandle(_T("user32.dll"));
        if (hUser32 == NULL) return;
        PFN_REGISTER_TOUCH_WINDOW pfnRegister =
            reinterpret_cast<PFN_REGISTER_TOUCH_WINDOW>(::GetProcAddress(hUser32, "RegisterTouchWindow"));
        if (pfnRegister != NULL)
            pfnRegister(hWnd, 0);
    }

    // 【已移除】RefreshTouchRegistration（Unregister + Register 强制重算触摸归属）。
    //
    // 它曾是"假模态 + WM_TOUCH 贪婪归属权"时代的补丁：试图用注销/重注册把触摸归属权
    // 从 owner 重新结算到弹框头上。实测无效（弹框依然零 WM_TOUCH），且真模态方案下
    // 完全没必要 —— 对话框窗口是新 HWND，创建时 RegisterTouchWindowIfAvailable 注册一次即可，
    // 系统自己就把触摸投给它。留着只会带来 C4505（未引用函数）警告，故整段删除。

    // 诊断：WM_TOUCH 究竟落在哪个窗口上（弹框自己？还是被禁用/被挡住的 owner？）。
    // ⚠️ 只 peek，绝不调用 CloseTouchInputHandle：句柄必须交给 CPaintManagerUI::OnTouchInput 关闭。
    void TraceTouchArrival(HWND hWnd, WPARAM wParam, LPARAM lParam)
    {
        HMODULE hUser32 = ::GetModuleHandle(_T("user32.dll"));
        if (hUser32 == NULL) return;
        PFN_GET_TOUCH_INPUT_INFO pfnGet =
            reinterpret_cast<PFN_GET_TOUCH_INPUT_INFO>(::GetProcAddress(hUser32, "GetTouchInputInfo"));
        int x = 0, y = 0;
        DWORD flags = 0;
        UINT cInputs = LOWORD(wParam);
        TRACE_TOUCHINPUT ti;
        ::ZeroMemory(&ti, sizeof(ti));
        if (pfnGet != NULL && cInputs > 0 && pfnGet((HANDLE)lParam, 1, &ti, (int)sizeof(ti)))
        {
            x = (int)(ti.x / 100);
            y = (int)(ti.y / 100);
            flags = ti.dwFlags;
        }
        DuiLibDiag::Log(_T("WNDPROC-TOUCH hwnd=%p owner=%p parent=%p enabled=%d visible=%d pt=%d,%d flags=0x%X inputs=%u modal=%p fg=%p"),
            (void*)hWnd, (void*)::GetWindow(hWnd, GW_OWNER), (void*)::GetParent(hWnd),
            (int)::IsWindowEnabled(hWnd), (int)::IsWindowVisible(hWnd),
            x, y, (unsigned)flags, cInputs,
            (void*)DuiLib::CPaintManagerUI::GetModalWindow(), (void*)::GetForegroundWindow());
    }

    // ---------------------------------------------------------------------------
    // 【临时全量诊断】记录系统到底把哪些"输入类消息"发给了哪个窗口。
    //
    // 背景：弹框打开后，日志里既没有 WM_TOUCH（任何窗口都没有），也没有 WM_LBUTTONDOWN/UP，
    // 却能看到弹框收到 WM_MOUSEMOVE（hover）。这说明触摸可能被系统降级成了鼠标模拟，
    // 或者走了 WM_GESTURE / WM_POINTER* 另外两条通道。这三个通道目前都没被记录到，
    // 因此需要一段覆盖面更广的诊断来确定"消息到底有没有发出来、发给了谁"。
    //
    // 覆盖：WM_TOUCH(0x0240) / WM_GESTURE(0x0119) / WM_POINTER*(0x0245~0x025F 及 0x0246/0x0247 变体)
    //       WM_MOUSEMOVE(0x0200) / WM_LBUTTONDOWN(0x0201) / WM_LBUTTONUP(0x0202)
    //       WM_NCMOUSEMOVE(0x00A0) / WM_MOUSEACTIVATE(0x0021) / WM_SETCURSOR(0x0020)
    //
    // ⚠️ 纯只读诊断：不改消息流向、不返回值、不消费句柄。只为定位问题，验证完请删除。
    // ---------------------------------------------------------------------------
    // MSG-ID 常量（不引用任何 WM_* 宏，避免 _WIN32_WINNT 版本段差异导致编译不过）
    const UINT DUI_MSG_WM_TOUCH              = 0x0240;
    const UINT DUI_MSG_WM_GESTURE            = 0x0119;
    const UINT DUI_MSG_WM_GESTURENOTIFY      = 0x011A;
    const UINT DUI_MSG_WM_MOUSEMOVE          = 0x0200;
    const UINT DUI_MSG_WM_LBUTTONDOWN        = 0x0201;
    const UINT DUI_MSG_WM_LBUTTONUP          = 0x0202;
    const UINT DUI_MSG_WM_LBUTTONDBLCLK      = 0x0203;
    const UINT DUI_MSG_WM_RBUTTONDOWN        = 0x0204;
    const UINT DUI_MSG_WM_RBUTTONUP          = 0x0205;
    const UINT DUI_MSG_WM_NCMOUSEMOVE        = 0x00A0;
    const UINT DUI_MSG_WM_NCLBUTTONDOWN      = 0x00A1;
    const UINT DUI_MSG_WM_MOUSEACTIVATE      = 0x0021;
    const UINT DUI_MSG_WM_SETCURSOR          = 0x0020;
    const UINT DUI_MSG_WM_NCHITTEST          = 0x0084;
    const UINT DUI_MSG_WM_ACTIVATE           = 0x0006;
    const UINT DUI_MSG_WM_ACTIVATEAPP        = 0x001C;
    const UINT DUI_MSG_WM_SETFOCUS           = 0x0007;
    const UINT DUI_MSG_WM_KILLFOCUS          = 0x0008;

    void TraceInputMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        LPCTSTR pszName = NULL;
        switch (uMsg)
        {
        // ⚠️ case 必须是"编译期常量表达式"。这些常量在匿名 namespace 里是 const UINT
        //    且已初始化，属于 ICE，可以安全用作 case 标签。
        case DUI_MSG_WM_TOUCH:         pszName = _T("WM_TOUCH"); break;
        case DUI_MSG_WM_GESTURE:       pszName = _T("WM_GESTURE"); break;
        case DUI_MSG_WM_GESTURENOTIFY: pszName = _T("WM_GESTURENOTIFY"); break;
        case DUI_MSG_WM_MOUSEMOVE:     pszName = _T("WM_MOUSEMOVE"); break;
        case DUI_MSG_WM_LBUTTONDOWN:   pszName = _T("WM_LBUTTONDOWN"); break;
        case DUI_MSG_WM_LBUTTONUP:     pszName = _T("WM_LBUTTONUP"); break;
        case DUI_MSG_WM_LBUTTONDBLCLK: pszName = _T("WM_LBUTTONDBLCLK"); break;
        case DUI_MSG_WM_RBUTTONDOWN:   pszName = _T("WM_RBUTTONDOWN"); break;
        case DUI_MSG_WM_RBUTTONUP:     pszName = _T("WM_RBUTTONUP"); break;
        case DUI_MSG_WM_NCMOUSEMOVE:   pszName = _T("WM_NCMOUSEMOVE"); break;
        case DUI_MSG_WM_NCLBUTTONDOWN: pszName = _T("WM_NCLBUTTONDOWN"); break;
        case DUI_MSG_WM_MOUSEACTIVATE: pszName = _T("WM_MOUSEACTIVATE"); break;
        case DUI_MSG_WM_SETCURSOR:     pszName = _T("WM_SETCURSOR"); break;
        case DUI_MSG_WM_NCHITTEST:     pszName = _T("WM_NCHITTEST"); break;
        case DUI_MSG_WM_ACTIVATE:      pszName = _T("WM_ACTIVATE"); break;
        case DUI_MSG_WM_ACTIVATEAPP:   pszName = _T("WM_ACTIVATEAPP"); break;
        case DUI_MSG_WM_SETFOCUS:      pszName = _T("WM_SETFOCUS"); break;
        case DUI_MSG_WM_KILLFOCUS:     pszName = _T("WM_KILLFOCUS"); break;
        default: break;
        }

        // 覆盖 WM_POINTER* 一段（0x0245~0x0260，不同 SDK 版本消息号有差异，统一按范围判断）
        const bool bPointerMsg = (uMsg >= 0x0245 && uMsg <= 0x0260);
        if (pszName == NULL && !bPointerMsg) return;

        // WM_MOUSEMOVE / WM_NCMOUSEMOVE / WM_NCHITTEST / WM_SETCURSOR 极其频繁，
        // 全量记录会瞬间刷爆日志，这里每类限流 300ms。
        const bool bNoisy = (uMsg == DUI_MSG_WM_MOUSEMOVE || uMsg == DUI_MSG_WM_NCMOUSEMOVE
            || uMsg == DUI_MSG_WM_NCHITTEST || uMsg == DUI_MSG_WM_SETCURSOR);
        if (bNoisy)
        {
            static DWORD s_dwLastNoisyTick = 0;
            static UINT  s_uLastNoisyMsg = 0;
            const DWORD dwNow = ::GetTickCount();
            if (s_uLastNoisyMsg == uMsg && (LONG)(dwNow - s_dwLastNoisyTick) < 300) return;
            s_dwLastNoisyTick = dwNow;
            s_uLastNoisyMsg = uMsg;
        }

        DWORD dwExtra = (DWORD)(DWORD_PTR)::GetMessageExtraInfo();
        DuiLibDiag::Log(_T("INPUT-TRACE target=%p msg=0x%04X %s w=0x%08X l=0x%08X extra=0x%08X fromtouch=%d modal=%p fg=%p enable=%d"),
            (void*)hWnd, uMsg, pszName != NULL ? pszName : _T("WM_POINTER*"),
            (unsigned)wParam, (unsigned)lParam, (unsigned)dwExtra,
            (int)((dwExtra & 0xFFFFFF80) == 0xFF515700),
            (void*)DuiLib::CPaintManagerUI::GetModalWindow(),
            (void*)::GetForegroundWindow(),
            (int)::IsWindowEnabled(hWnd));
    }

    // 【已移除】LogProcessWindowList / EnumProc_LogWnd（本进程顶层窗口清单，MODAL-WNDLIST）。
    // 它们是排查"WM_TOUCH 究竟投给了哪个陌生 HWND"的临时诊断，只被已删除的假模态消息循环调用。
    // 真模态方案下弹框自己就是触摸目标，这份清单不再需要，删除以免 C4505。

    // 【已搬移】FindManagerByPaintWindow 原本定义在这里（匿名 namespace 内）。
    //
    // 为什么必须搬走：UIBase.h 里为了让 UIManager.cpp 也能调用它，已经加了一份
    // 声明 `DuiLib::CPaintManagerUI* FindManagerByPaintWindow(HWND);`。
    // 于是同一个翻译单元里同时存在
    //     · 匿名 namespace 内的 DuiLib::`anonymous-namespace'::FindManagerByPaintWindow
    //     · 头文件声明的      DuiLib::FindManagerByPaintWindow
    // 两个候选，调用点（UIBase.cpp 里 793/1076/1124/1207/1367/1395 等）无法抉择，
    // MSVC 直接报 C2668「对重载函数的调用不明确」。
    // ⇒ 现在把它挪到匿名 namespace **之外**，作为 DuiLib 的正式成员，
    //    与头文件那份声明严格一一对应（定义见本文件下方 namespace 收尾之后）。

    // ---------------------------------------------------------------------------
    // [WM_TOUCH 归属权] "补调原窗口过程"的中转函数。
    //
    // 为什么需要它：
    //   WM_TOUCH 不是被系统直接投递的。系统先发一条"特殊标记的 WM_MOUSEMOVE"
    //   （开了 raw input 时是 WM_INPUT），只有这条消息走到 DefWindowProc 里，
    //   DefWindowProc 才会把驻留的 WM_TOUCH "翻译"并派发出来
    //   （来源：The Witness 作者的逆向结论；MSDN《Architectural Overview》的
    //   greedy 段落也印证了这套投递模型）。
    //   本库的 CPaintManagerUI::MessageHandler 为了不让"触摸提升出来的鼠标移动"
    //   破坏拖拽/悬浮状态机，会吞掉它（return true），从而跳过了 DefWindowProc
    //   ⇒ 窗口（尤其 #32770 真模态弹框，它依赖 DefDlgProc→DefWindowProc 这条链）
    //   后续永远收不到 WM_TOUCH。
    //
    // 这个中转函数由 CPaintManagerUI::RelayDefWindowProc 回调，
    // 作用就是"把消息喂给原窗口过程一次"，补上被跳过的那次副作用。
    // 用静态变量保存"当前转发目标"：因为回调签名不带 this，
    // 而每个窗口过程在同一时刻只有一个绑定关系（主窗口 or 某个弹框）。
    // 真模态切换 HWND 时通过 SetDefProcRelay 重新绑定，不会串。
    //
    // ⚠️ 位置要求：必须定义在 __DialogWndProc 之前（它比 __WndProc 先出现）。
    // ---------------------------------------------------------------------------
    WNDPROC g_pfnRelayTarget = NULL;
    HWND    g_hWndRelayBound = NULL;

    LRESULT CALLBACK RelayWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        // 只有"当前正在转发的窗口"才有效：避免悬垂到已销毁窗口的过程上。
        if (g_pfnRelayTarget == NULL || g_hWndRelayBound != hWnd)
            return 0;
        return ::CallWindowProc(g_pfnRelayTarget, hWnd, uMsg, wParam, lParam);
    }

    // 把"原窗口过程"登记为转发目标（绑定到指定 HWND）。
    void BindRelayTarget(WNDPROC pfnOldProc, HWND hWnd)
    {
        g_pfnRelayTarget = pfnOldProc;
        g_hWndRelayBound = hWnd;
    }

    // DetachPaintWindow 之后、AttachPaintWindow 之前，用这个取出"待挂载的 manager"。
    // 因为此时 manager 已从 m_aPreMessages 摘除，FindManagerByPaintWindow 找不到它了，
    // 所以用一个文件级静态变量中转（只在 ShowModal 的单线程窗口过程里使用，无需同步）。
    static DuiLib::CPaintManagerUI* g_pDetachedManager = NULL;

    void SetDetachedManager(DuiLib::CPaintManagerUI* pManager) { g_pDetachedManager = pManager; }
    DuiLib::CPaintManagerUI* GetDetachedManager() { return g_pDetachedManager; }

    // 【已移除】IsModalBlockedInputMessage —— 假模态时代的"在消息循环里丢弃发给 owner 的输入消息"。
    // 现在 ShowModal 走真模态（DialogBoxIndirectParam），系统对话框管理器自带 owner 禁用，
    // 这条兜底不但多余，还会误伤：真模态期间 owner 本就需要收到 WM_ACTIVATE/WM_KILLFOCUS 之类的
    // 通知消息，无差别丢弃会让 owner 的状态机错乱。故整段删除，不再保留。
}

// ---------------------------------------------------------------------------
// 真模态（DialogBox）辅助：按 paint window 找到对应的 CPaintManagerUI。
//
// ⚠️ 必须定义在**匿名 namespace 之外**（即 DuiLib 命名空间直接成员），
//    因为 UIBase.h 里有一份同名声明供 UIManager.cpp 使用。若同时存在匿名
//    namespace 内的一份，调用点会因两个候选而报 C2668「调用不明确」。
//
// 用途：
//   · ShowModal 里要把 manager 从旧 HWND 迁到对话框新 HWND 时需要先找到它；
//   · CPaintManagerUI::IsModalBackdropWindow 判定"本句柄是否就是弹框自己的
//     manager 窗口"时也依赖它（透传闸门的一条关键判据）。
// 实现：遍历 CPaintManagerUI::GetPaintManagers()，比对 GetPaintWindow()。
// ---------------------------------------------------------------------------
DuiLib::CPaintManagerUI* FindManagerByPaintWindow(HWND hWnd)
{
    if (hWnd == NULL) return NULL;
    CStdPtrArray* pManagers = DuiLib::CPaintManagerUI::GetPaintManagers();
    if (pManagers == NULL) return NULL;
    for (int i = 0; i < pManagers->GetSize(); ++i)
    {
        DuiLib::CPaintManagerUI* pManager = static_cast<DuiLib::CPaintManagerUI*>(pManagers->GetAt(i));
        if (pManager != NULL && pManager->GetPaintWindow() == hWnd) return pManager;
    }
    return NULL;
}

/////////////////////////////////////////////////////////////////////////////////////
//
//

void UILIB_API DUI__Trace(LPCTSTR pstrFormat, ...)
{
#ifdef _DEBUG
	TCHAR szBuffer[2048] = {0};
    va_list args;
    va_start(args, pstrFormat);
	_vsntprintf(szBuffer, 2048, pstrFormat, args); 
    va_end(args);
    
	CDuiString strMsg = szBuffer;
    strMsg += _T("\n");
    OutputDebugString(strMsg.GetData());

#endif
}

LPCTSTR DUI__TraceMsg(UINT uMsg)
{
#define MSGDEF(x) if(uMsg==x) return _T(#x)
    MSGDEF(WM_SETCURSOR);
    MSGDEF(WM_NCHITTEST);
    MSGDEF(WM_NCPAINT);
    MSGDEF(WM_PAINT);
    MSGDEF(WM_ERASEBKGND);
    MSGDEF(WM_NCMOUSEMOVE);  
    MSGDEF(WM_MOUSEMOVE);
    MSGDEF(WM_MOUSELEAVE);
    MSGDEF(WM_MOUSEHOVER);   
    MSGDEF(WM_NOTIFY);
    MSGDEF(WM_COMMAND);
    MSGDEF(WM_MEASUREITEM);
    MSGDEF(WM_DRAWITEM);   
    MSGDEF(WM_LBUTTONDOWN);
    MSGDEF(WM_LBUTTONUP);
    MSGDEF(WM_LBUTTONDBLCLK);
    MSGDEF(WM_RBUTTONDOWN);
    MSGDEF(WM_RBUTTONUP);
    MSGDEF(WM_RBUTTONDBLCLK);
    MSGDEF(WM_SETFOCUS);
    MSGDEF(WM_KILLFOCUS);  
    MSGDEF(WM_MOVE);
    MSGDEF(WM_SIZE);
    MSGDEF(WM_SIZING);
    MSGDEF(WM_MOVING);
    MSGDEF(WM_GETMINMAXINFO);
    MSGDEF(WM_CAPTURECHANGED);
    MSGDEF(WM_WINDOWPOSCHANGED);
    MSGDEF(WM_WINDOWPOSCHANGING);   
    MSGDEF(WM_NCCALCSIZE);
    MSGDEF(WM_NCCREATE);
    MSGDEF(WM_NCDESTROY);
    MSGDEF(WM_TIMER);
    MSGDEF(WM_KEYDOWN);
    MSGDEF(WM_KEYUP);
    MSGDEF(WM_CHAR);
    MSGDEF(WM_SYSKEYDOWN);
    MSGDEF(WM_SYSKEYUP);
    MSGDEF(WM_SYSCOMMAND);
    MSGDEF(WM_SYSCHAR);
    MSGDEF(WM_VSCROLL);
    MSGDEF(WM_HSCROLL);
    MSGDEF(WM_CHAR);
    MSGDEF(WM_SHOWWINDOW);
    MSGDEF(WM_PARENTNOTIFY);
    MSGDEF(WM_CREATE);
    MSGDEF(WM_NCACTIVATE);
    MSGDEF(WM_ACTIVATE);
    MSGDEF(WM_ACTIVATEAPP);   
    MSGDEF(WM_CLOSE);
    MSGDEF(WM_DESTROY);
    MSGDEF(WM_GETICON);   
    MSGDEF(WM_GETTEXT);
    MSGDEF(WM_GETTEXTLENGTH);   
    static TCHAR szMsg[10];
    ::wsprintf(szMsg, _T("0x%04X"), uMsg);
    return szMsg;
}

/////////////////////////////////////////////////////////////////////////////////////
//
//

//////////////////////////////////////////////////////////////////////////
//
DUI_BASE_BEGIN_MESSAGE_MAP(CNotifyPump)
DUI_END_MESSAGE_MAP()

static const DUI_MSGMAP_ENTRY* DuiFindMessageEntry(const DUI_MSGMAP_ENTRY* lpEntry,TNotifyUI& msg )
{
	CDuiString sMsgType = msg.sType;
	CDuiString sCtrlName = msg.pSender->GetName();
	const DUI_MSGMAP_ENTRY* pMsgTypeEntry = NULL;
	while (lpEntry->nSig != DuiSig_end)
	{
		if(lpEntry->sMsgType==sMsgType)
		{
			if(!lpEntry->sCtrlName.IsEmpty())
			{
				if(lpEntry->sCtrlName==sCtrlName)
				{
					return lpEntry;
				}
			}
			else
			{
				pMsgTypeEntry = lpEntry;
			}
		}
		lpEntry++;
	}
	return pMsgTypeEntry;
}

bool CNotifyPump::AddVirtualWnd(CDuiString strName,CNotifyPump* pObject)
{
	if( m_VirtualWndMap.Find(strName) == NULL )
	{
		m_VirtualWndMap.Insert(strName.GetData(),(LPVOID)pObject);
		return true;
	}
	return false;
}

bool CNotifyPump::RemoveVirtualWnd(CDuiString strName)
{
	if( m_VirtualWndMap.Find(strName) != NULL )
	{
		m_VirtualWndMap.Remove(strName);
		return true;
	}
	return false;
}

bool CNotifyPump::LoopDispatch(TNotifyUI& msg)
{
	const DUI_MSGMAP_ENTRY* lpEntry = NULL;
	const DUI_MSGMAP* pMessageMap = NULL;

#ifndef UILIB_STATIC
	for(pMessageMap = GetMessageMap(); pMessageMap!=NULL; pMessageMap = (*pMessageMap->pfnGetBaseMap)())
#else
	for(pMessageMap = GetMessageMap(); pMessageMap!=NULL; pMessageMap = pMessageMap->pBaseMap)
#endif
	{
#ifndef UILIB_STATIC
		ASSERT(pMessageMap != (*pMessageMap->pfnGetBaseMap)());
#else
		ASSERT(pMessageMap != pMessageMap->pBaseMap);
#endif
		if ((lpEntry = DuiFindMessageEntry(pMessageMap->lpEntries,msg)) != NULL)
		{
			goto LDispatch;
		}
	}
	return false;

LDispatch:
	union DuiMessageMapFunctions mmf;
	mmf.pfn = lpEntry->pfn;

	bool bRet = false;
	int nSig;
	nSig = lpEntry->nSig;
	switch (nSig)
	{
	default:
		ASSERT(FALSE);
		break;
	case DuiSig_lwl:
		(this->*mmf.pfn_Notify_lwl)(msg.wParam,msg.lParam);
		bRet = true;
		break;
	case DuiSig_vn:
		(this->*mmf.pfn_Notify_vn)(msg);
		bRet = true;
		break;
	}
	return bRet;
}

void CNotifyPump::NotifyPump(TNotifyUI& msg)
{
	///遍历虚拟窗口
	if( !msg.sVirtualWnd.IsEmpty() ){
		for( int i = 0; i< m_VirtualWndMap.GetSize(); i++ ) {
			if( LPCTSTR key = m_VirtualWndMap.GetAt(i) ) {
				if( _tcsicmp(key, msg.sVirtualWnd.GetData()) == 0 ){
					CNotifyPump* pObject = static_cast<CNotifyPump*>(m_VirtualWndMap.Find(key, false));
					if( pObject && pObject->LoopDispatch(msg) )
						return;
				}
			}
		}
	}

	///
	//遍历主窗口
	LoopDispatch( msg );
}

//////////////////////////////////////////////////////////////////////////
///
CWindowWnd::CWindowWnd() : m_hWnd(NULL), m_OldWndProc(::DefWindowProc), m_bSubclassed(false), m_bUnicode(false), m_bFakeModal(false), m_bDoModal(false), m_nModalRet(0), m_pfnOldDlgWndProc(NULL), m_rcModalTarget()
{
}

HWND CWindowWnd::GetHWND() const 
{ 
    return m_hWnd; 
}

UINT CWindowWnd::GetClassStyle() const
{
    return 0;
}

LPCTSTR CWindowWnd::GetSuperClassName() const
{
    return NULL;
}

CWindowWnd::operator HWND() const
{
    return m_hWnd;
}
void CWindowWnd::EnableUnicode()
{
	m_bUnicode = true;
}
HWND CWindowWnd::CreateDuiWindow( HWND hwndParent, LPCTSTR pstrWindowName,DWORD dwStyle /*=0*/, DWORD dwExStyle /*=0*/ )
{
	return Create(hwndParent,pstrWindowName,dwStyle,dwExStyle,0,0,0,0,NULL);
}

HWND CWindowWnd::Create(HWND hwndParent, LPCTSTR pstrName, DWORD dwStyle, DWORD dwExStyle, const RECT rc, HMENU hMenu)
{
    return Create(hwndParent, pstrName, dwStyle, dwExStyle, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, hMenu);
}

HWND CWindowWnd::Create(HWND hwndParent, LPCTSTR pstrName, DWORD dwStyle, DWORD dwExStyle, int x, int y, int cx, int cy, HMENU hMenu)
{
    if( GetSuperClassName() != NULL && !RegisterSuperclass() ) return NULL;
    if( GetSuperClassName() == NULL && !RegisterWindowClass() ) return NULL;
	if(m_bUnicode) {
#ifndef UNICODE
		LPWSTR lpClassName = a2w((char*)GetWindowClassName());
		LPWSTR lpName = a2w((char*)pstrName);
#else
		LPWSTR lpClassName = (LPWSTR)GetWindowClassName();
		LPWSTR lpName = (LPWSTR)pstrName;
#endif
		m_hWnd = ::CreateWindowExW(dwExStyle, lpClassName, lpName, dwStyle, x, y, cx, cy, hwndParent, hMenu, CPaintManagerUI::GetInstance(), this);
#ifndef UNICODE
		delete []lpClassName;
		delete []lpName;
#endif
	}
	else {
		m_hWnd = ::CreateWindowEx(dwExStyle, GetWindowClassName(), pstrName, dwStyle, x, y, cx, cy, hwndParent, hMenu, CPaintManagerUI::GetInstance(), this);
	}
    ASSERT(m_hWnd!=NULL);
    RegisterTouchWindowIfAvailable(m_hWnd);
    return m_hWnd;
}

HWND CWindowWnd::Subclass(HWND hWnd)
{
    ASSERT(::IsWindow(hWnd));
    ASSERT(m_hWnd==NULL);
    m_OldWndProc = SubclassWindow(hWnd, __WndProc);
    if( m_OldWndProc == NULL ) return NULL;
    m_bSubclassed = true;
    m_hWnd = hWnd;
    ::SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LPARAM>(this));
    RegisterTouchWindowIfAvailable(m_hWnd);
    return m_hWnd;
}

void CWindowWnd::Unsubclass()
{
    ASSERT(::IsWindow(m_hWnd));
    if( !::IsWindow(m_hWnd) ) return;
    if( !m_bSubclassed ) return;
    SubclassWindow(m_hWnd, m_OldWndProc);
    m_OldWndProc = ::DefWindowProc;
    m_bSubclassed = false;
}

void CWindowWnd::ShowWindow(bool bShow /*= true*/, bool bTakeFocus /*= false*/)
{
    ASSERT(::IsWindow(m_hWnd));
    if( !::IsWindow(m_hWnd) ) return;
    ::ShowWindow(m_hWnd, bShow ? (bTakeFocus ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE) : SW_HIDE);
}

UINT CWindowWnd::ShowModal()
{
    // =========================================================================
    // 【真模态】改用 Windows 的对话框机制（DialogBoxIndirectParam）驱动模态。
    //
    // 参考：网易 nim_duilib 的 NativeWindow_Windows::DoModal()
    //       （duilib/Core/NativeWindow_Windows.cpp）
    //
    // ── 为什么必须换掉旧写法 ──────────────────────────────────────────────
    // 旧实现是"假模态"：自己 ShowWindow + EnableWindow(owner,FALSE) + TOPMOST +
    // 抢前台 + 自写 while(GetMessage) 嵌套循环。在 Win10 触摸屏上必然失败，根因是
    // 触摸消息的投递目标规则（MSDN, Getting Started with Windows Touch Messages）：
    //
    //   "WM_TOUCH messages are currently 'greedy.' After the first touch message is
    //    received on a window, all touch messages are sent to that window until
    //    another window receives focus."
    //
    // 主窗口早就 RegisterTouchWindow 过、也早就收到过 WM_TOUCH，所以触摸归属权长期
    // 在它手里；弹框是自己 Create 出来的普通窗口，**不是**系统的触摸目标。
    // 我们为此打了一堆补丁（手动焦点切换、刷新注册、消息循环转发、__WndProc 转发兜底），
    // 实测全部无效：日志里弹框始终零 WM_TOUCH、零 WM_LBUTTONDOWN/UP。
    //
    // ── 对话框为什么能解决 ────────────────────────────────────────────────
    // DialogBox 是内核实现的模态机制，它：
    //   · 由系统跑消息循环（不需要我们自写嵌套循环）；
    //   · 由系统按正确时机禁用 owner（不需要我们 EnableWindow）；
    //   · 由系统维持前台/激活（不需要 TOPMOST / SetForegroundWindow / 焦点切换）；
    //   · **把对话框窗口本身变成输入目标**，触摸自然投给它、提升的鼠标消息也落在它身上。
    //
    // 于是"贪婪归属权""提升鼠标被吞""owner 抢前台""禁用窗口收不到消息"这几类问题
    // 全部不存在 —— 不是被绕过，而是压根不成立。
    //
    // ── 如何与既有代码兼容 ────────────────────────────────────────────────
    // 调用方约定是：new → Create(hwnd, ..., UI_WNDSTYLE_DIALOG, ...) → SetIcon →
    // CenterWindow() → ShowModal()。也就是说**窗口在我们被调用之前就已经 Create 好了**，
    // CPaintManagerUI 也已 Init 到那个 HWND 上。所以这里不能另起一个对话框窗口，
    // 而是：用当前窗口的几何/样式造一个 DLGTEMPLATE，让 DialogBoxIndirectParam 去创建
    // 对话框窗口，再把旧的 HWND 销毁、把 DuiLib 的 manager 迁移到新 HWND —— 这样
    // 调用方完全无感知，`m_hWnd` 语义不变，30+ 个调用点一行都不用改。
    // =========================================================================

    ASSERT(::IsWindow(m_hWnd));
    if( !::IsWindow(m_hWnd) ) return 0;

    HWND hWndOwner = ::GetWindow(m_hWnd, GW_OWNER);
    if( hWndOwner == NULL ) hWndOwner = ::GetActiveWindow();

    // ---- 1) 采集旧窗口的几何与样式，用于构造对话框模板 ----
    RECT rcWnd = { 0 };
    ::GetWindowRect(m_hWnd, &rcWnd);
    const int nW = rcWnd.right - rcWnd.left;
    const int nH = rcWnd.bottom - rcWnd.top;

    // 【尺寸精确性】旧窗口的客户区尺寸 —— 这是迁移后必须保持不变的量。
    //
    // 为什么不能直接用窗口矩形(nW/nH)去填 DLGTEMPLATE.cx/cy：
    //   1. DLGTEMPLATE 的 cx/cy 描述的是**客户区**尺寸，不是窗口外框尺寸；
    //   2. 我们给模板设的样式（WS_CAPTION/WS_DLGFRAME/DS_MODALFRAME…）会让系统
    //      在此基础上再往外加一圈非客户区边框。
    //   若直接填 nW/nH，新窗口 = 旧窗口 + 边框 ⇒ 弹框整体变大、位置也偏。
    //
    // 因此这里取"旧窗口客户区尺寸"作为目标客户区尺寸；创建完成后再在 __DialogProc 里
    // 用 AdjustWindowRectEx 反算目标外框并 SetWindowPos 精确校正（见 __DialogProc）。
    RECT rcClient = { 0 };
    ::GetClientRect(m_hWnd, &rcClient);
    const int nClientW = rcClient.right - rcClient.left;
    const int nClientH = rcClient.bottom - rcClient.top;

    DWORD dwStyle   = (DWORD)::GetWindowLong(m_hWnd, GWL_STYLE);
    DWORD dwExStyle = (DWORD)::GetWindowLong(m_hWnd, GWL_EXSTYLE);

    // 对话框专用的样式：把我们自己那套 WS_POPUPWINDOW/WS_CAPTION/WS_DLGFRAME 换成
    // 对话框该有的组合。WS_POPUP 必须保留（否则会变成带系统标题栏的普通窗口）。
    // WS_VISIBLE 让 DialogBox 创建后直接显示。
    //
    // ⚠️ 关于 WS_CAPTION / DS_MODALFRAME：
    //   本项目的弹框（UI_WNDSTYLE_DIALOG）是**无系统标题栏的自绘弹框**，且调用方
    //   均未传 WS_THICKFRAME（固定尺寸）。所以这里**不能**自作主张加 DS_MODALFRAME 或
    //   WS_THICKFRAME —— 那会给弹框加一圈可调整大小的边框，既改变外观又改变尺寸。
    //   保持 WS_POPUP + 原有的 WS_CAPTION/WS_SYSMENU 即可（自绘弹框本来就不显示系统标题栏）。
    DWORD dwDlgStyle = WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
    if( dwStyle & WS_CAPTION )      dwDlgStyle |= WS_CAPTION | WS_SYSMENU;
    if( dwStyle & WS_THICKFRAME )   dwDlgStyle |= WS_THICKFRAME;
    if( dwStyle & WS_MINIMIZEBOX )  dwDlgStyle |= WS_MINIMIZEBOX;
    if( dwStyle & WS_MAXIMIZEBOX )  dwDlgStyle |= WS_MAXIMIZEBOX;

    // ex-style 基本原样透传（WS_EX_TOOLWINDOW / WS_EX_WINDOWEDGE 等），但清掉两类：
    //   · WS_EX_APPWINDOW     —— 对话框不该出现在任务栏；
    //   · WS_EX_DLGMODALFRAME —— 会给弹框加一圈双线边框，固定尺寸自绘弹框不需要（会改变外框尺寸）。
    dwExStyle &= ~(WS_EX_APPWINDOW | WS_EX_DLGMODALFRAME);

    // ---- 2) 构造 DLGTEMPLATE 资源 ----
    // 只用 DLGTEMPLATE 本体（不含菜单/类名/标题/字体），微软文档允许这样，
    // 系统会套用默认的对话框字体与类（#32770）。
    // 参考 nim_duilib：sizeof(DLGTEMPLATE) + 32 字节余量。
    const size_t nDataSize = sizeof(DLGTEMPLATE) + 32;
    HGLOBAL hResource = ::GlobalAlloc(GMEM_MOVEABLE, nDataSize);
    if( hResource == NULL )
    {
        DuiLibDiag::Log(_T("MODAL-DLG GlobalAlloc failed err=%u"), ::GetLastError());
        return 0;
    }
    LPDLGTEMPLATE pTemplate = (LPDLGTEMPLATE)::GlobalLock(hResource);
    if( pTemplate == NULL )
    {
        ::GlobalFree(hResource);
        return 0;
    }
    ::ZeroMemory(pTemplate, nDataSize);
    pTemplate->style = dwDlgStyle;
    pTemplate->dwExtendedStyle = dwExStyle;
    pTemplate->cdit = 0;                                  // 不使用模板内控件（控件由 DuiLib 自绘）
    // DLGTEMPLATE 的 cx/cy 单位是对话框单位(DLU)，且语义为**客户区**尺寸。
    // 这里只是给系统一个初始值（避免 0 尺寸导致奇怪的默认值），真正的精确尺寸
    // 由 __DialogProc 里创建完成后按旧客户区尺寸 + AdjustWindowRectEx 反算并 SetWindowPos 校正。
    pTemplate->x = 0;
    pTemplate->y = 0;
    pTemplate->cx = (short)(nClientW > 0 ? nClientW : nW);
    pTemplate->cy = (short)(nClientH > 0 ? nClientH : nH);

    // ---- 3) 迁移前先把旧的 HWND 记录下来，并让 manager 做好切换准备 ----
    HWND hWndOld = m_hWnd;

    m_bDoModal = true;
    m_nModalRet = 0;

    // 把"目标位置 + 目标客户区尺寸"暂存到成员，供 __DialogProc 在创建完成后精确校正。
    // 之所以不在模板里一次算准：对话框的非客户区厚度取决于实际样式（WS_CAPTION/WS_DLGFRAME/
    // WS_EX_* 组合），预估值容易差几个像素；创建后用 AdjustWindowRectEx 反算再 SetWindowPos
    // 是唯一能保证"客户区尺寸与旧窗口逐像素一致"的做法。
    m_rcModalTarget.left   = rcWnd.left;
    m_rcModalTarget.top    = rcWnd.top;
    m_rcModalTarget.right  = rcWnd.left + nClientW;
    m_rcModalTarget.bottom = rcWnd.top  + nClientH;

    DuiLibDiag::Log(_T("MODAL-DLG enter old=%p owner=%p wndrect=%d,%d,%dx%d client=%dx%d dlgstyle=0x%08X ex=0x%08X"),
        (void*)hWndOld, (void*)hWndOwner, rcWnd.left, rcWnd.top, nW, nH, nClientW, nClientH,
        (unsigned)dwDlgStyle, (unsigned)dwExStyle);

    // 记录"当前模态窗口"，供库内其它地方判断（如 OnTouchInput 的老兜底逻辑）。
    // 注意：此时还不知道新 HWND，__DialogProc 里会再次 SetModalWindow。
    HWND hPrevModal = CPaintManagerUI::GetModalWindow();

    // 关键：先把旧窗口销毁、把 manager 解绑，再让 DialogBox 创建新的对话框窗口，
    // 这样 manager 不会出现"两个 HWND 同时活着"的错乱状态。
    // 说明：调用方是在 ShowModal() 之前 Create 的，所以这里必须主动清理旧窗口。
    HWND hWndOldCaptured = m_hWnd;
    m_hWnd = NULL;   // 先置空：__DialogProc 会在 WM_INITDIALOG 里填入新句柄

    // 把 manager 从旧窗口上摘下来（保留它的控件树/资源，只换 paint window）
    CPaintManagerUI* pManager = FindManagerByPaintWindow(hWndOldCaptured);
    SetDetachedManager(pManager);

    // ---- [模态提示音] 在进入模态循环【之前】布好消音窗口 ----
    //
    // 时序（真机日志实证，见本文件头那段说明）：
    //   调用方的触摸 UP 已经消费完（点击回调正在执行），但**这次手势的提升鼠标消息
    //   还排在消息队列里没投出来**；紧接着我们在这里把 owner 交给
    //   DialogBoxIndirectParam 禁用，之后那条消息才被投递 ⇒ 撞上"点击禁用窗口"
    //   ⇒ MessageBeep(0) 咚。
    //
    // 所以必须**现在就**置位：等 DialogBoxIndirectParam 返回就太晚了。
    //
    // 抑制位的生命周期是【手势级】而不是时间级：MessageHandler 收到被抑制窗口的
    // 提升鼠标 DOWN 就"记账"、收到配对的 UP 就"销账"，账目归零即自动解除抑制；
    // 另有一条 10 秒僵尸兜底，防止配对消息永久丢失导致抑制位卡死。
    // 因此"弹框已出现后用户再点空白区"那一声（用户要求保留的）不受影响 ——
    // 那时本次手势的账早已结清，而且那一下的归属窗口本来就是弹框。
    //
    // 关闭弹框时还会【主动】撤防（见 CWindowWnd::Close 与 __DialogWndProc 的
    // WM_NCDESTROY），不依赖超时 —— 这是 Win10 "3 秒透点"的修复点。
    //
    // 位置：必须在 pManager 取到之后（否则未声明标识符），且早于下方
    //   DialogBoxIndirectParam 调用即可 —— 中间那些 Detach / DestroyWindow 不影响它，
    //   因为抑制位是 manager 的成员，会随对象一起被 Attach 到新弹框。
    if( pManager != NULL )
    {
        pManager->SetSuppressPromotedMouseForModal(true);
        // ★★【透传根治 · 代数推进点】★★
        //
        // 这是唯一**可靠**的"模态边界"信号，必须在这里推进代数。
        //
        // 为什么不能靠在 MessageHandler 里比较"当前是否有模态 vs 上次是否有模态"：
        //   真机时序是
        //     WM_LBUTTONUP（主窗口）→ 回调里同步 ShowModal() → 模态循环 →
        //     EndDialog → GetModalWindow() 归零 → **然后**那条被卡住的
        //     WM_LBUTTONDOWN 才被投递。
        //   主窗口的 MessageHandler 在**整个模态期间收不到任何消息**
        //   （owner 被 EnableWindow(FALSE)，消息抽不出来），
        //   所以"边沿检测"两边看到的都是 false ⇒ 永远不会触发 ⇒ 拦不住。
        //   ⇒ 边界必须在这里**主动**记录。
        //
        // ⚠️ 为什么推进的是**全局**代数、而不是 pManager 的成员：
        //   本项目属性弹框（CDiandanNatureWnd）自带独立的 `CPaintManagerUI m_pm`，
        //   与主窗口的 manager **不是同一个对象**。真机日志铁证：
        //       MODAL-BEEP arm manager=0DCE0960            <- 弹框的 manager
        //       MANAGER-MSG hwnd=00D20604 manager=05796840 <- 泄漏消息落在这里
        //   而"泄漏"是**线程消息队列**现象，与 manager 归属无关
        //   ⇒ 代数必须是线程级的（见 DuiLib::BumpPromotedMouseGenerationGlobal）。
        DuiLib::BumpPromotedMouseGenerationGlobal();
        // ★ V2 标记：真机自证用。看到 `gen=` 且 `v=2` 才说明跑的是**这一版**二进制。
        //   上一版这行没有 gen=/v= 字段，日志里出现的是 `MODAL-BEEP arm manager=... owner=...`
        //   ⇒ 如果新日志仍然没有 gen=/v=，那就是**没重新编译**，任何分析都不必做。
        DuiLibDiag::Log(_T("MODAL-BEEP arm v=2 manager=%p owner=%p gen=%u"),
            (void*)pManager, (void*)hWndOwner, (unsigned)DuiLib::PeekPromotedMouseGeneration());
    }

    // [第十一轮诊断] 模态开启瞬间的悬停/点击/捕获状态快照 —— **搬家前**的现场。
    //
    // 真模态会把**同一个** manager 从旧窗口搬到弹框上。此前 `AttachPaintWindow` 只换
    // paint window、**不清理** m_pEventHover / m_aNeedMouseLeaveNeeded / m_bMouseCapture，
    // 这些状态就跟着 manager 一起"住进"弹框，表现为"主窗口那个商品控件一直保持悬浮态，
    // 直到弹框关闭才恢复"（用户报的第 4 个 bug）。
    //
    // ⚠️ 该缺陷**已在第十一轮修复**：AttachPaintWindow 现在会清掉这一组输入态
    //    （见 UIManager.cpp 该函数开头的长注释）。
    //    本日志保留用于**对照验证** —— 期望看到 hover 有值（旧窗口确实残留着），
    //    而修复后弹框上不应再出现"悬浮态不消失"。若修复后本行仍打印 hover=null，
    //    说明残留另有来源，需要继续查。
    if( pManager != NULL )
    {
        DuiLibDiag::Log(_T("MODAL-STATE enter manager=%p hover=%s captured=%d dragmode=%d leaveArr=%d rclick=%s"),
            (void*)pManager,
            pManager->DbgHoverName(), (int)pManager->IsCaptured(), (int)pManager->DbgIsDragMode(),
            pManager->DbgNeedMouseLeaveCount(), pManager->DbgRClickName());
    }

    if( pManager != NULL )
    {
        pManager->DetachPaintWindow();
        DuiLibDiag::Log(_T("MODAL-DLG detach manager=%p from old=%p"),
            (void*)pManager, (void*)hWndOldCaptured);
    }
    // 销毁旧窗口（旧窗口上的窗口过程会把 m_hWnd 清空，但我们已经在上面置 NULL 了，
    // 且 manager 已摘除，不会再触发 DuiLib 的绘制路径）。
    if( ::IsWindow(hWndOldCaptured) ) ::DestroyWindow(hWndOldCaptured);

    // ---- 4) 交给系统对话框管理器跑模态循环 ----
    // 这是阻塞调用，返回时模态已结束。
    INT_PTR nRet = ::DialogBoxIndirectParam(CPaintManagerUI::GetInstance(),
                                            pTemplate,
                                            hWndOwner,
                                            CWindowWnd::__DialogProc,
                                            (LPARAM)this);

    // 资源可以释放了（DialogBoxIndirectParam 内部已把模板复制走）——
    // 但谨慎起见放在 EndDialog 之后，与 nim_duilib 一致。
    ::GlobalUnlock(hResource);
    ::GlobalFree(hResource);

    // 兜底：若 __DialogProc 因故没跑（创建失败 / WM_INITDIALOG 里 early-return），
    // 这里把中转变量清干净，避免悬垂指针影响后续 ShowModal。
    SetDetachedManager(NULL);

    // [模态提示音] 模态循环已结束 ⇒ 消音窗口撤销。
    // 注意句柄：真模态把同一个 manager Detach 到旧窗口、再 Attach 到弹框，所以
    // 此刻 pManager 可能已随弹框一起销毁 —— 用 FindManagerByPaintWindow 取不到，
    // 因此直接用进入前缓存的指针。
    // 这里只是"尽早撤销"的一层；正确性由下面两处确定性撤防保证：
    //   a) CWindowWnd::Close() 的 m_bDoModal 分支，在 EndDialog 之前撤防；
    //   b) __DialogWndProc 的 WM_NCDESTROY 收尾，任何销毁路径都会撤防。
    // 若以上都因故没跑到，MessageHandler 里还有 10 秒僵尸兜底。
    if( pManager != NULL )
    {
        pManager->SetSuppressPromotedMouseForModal(false);
        DuiLibDiag::Log(_T("MODAL-BEEP disarm manager=%p"), (void*)pManager);
    }

    m_bDoModal = false;
    CPaintManagerUI::SetModalWindow(hPrevModal);

    DuiLibDiag::Log(_T("MODAL-DLG exit hwnd=%p ret=%d m_nModalRet=%u"),
        (void*)m_hWnd, (int)nRet, m_nModalRet);

    // DialogBoxIndirectParam 返回值：-1 表示创建失败
    if( nRet == -1 )
    {
        DuiLibDiag::Log(_T("MODAL-DLG failed err=%u"), ::GetLastError());
        return 0;
    }

    return m_nModalRet;
}

// -----------------------------------------------------------------------------
// 真模态：对话框过程。
//
// 生命周期：
//   DialogBoxIndirectParam → 创建 #32770 窗口 → WM_INITDIALOG（此时才有真 HWND）
//                          → 把 manager 挂到新 HWND、换掉 GWLP_WNDPROC
//                          → return TRUE（表示我们已经处理了焦点）
// -----------------------------------------------------------------------------
INT_PTR CALLBACK CWindowWnd::__DialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    if( uMsg == WM_INITDIALOG )
    {
        // 这是对话框的第一个消息；lParam 是我们传进来的 this
        CWindowWnd* pThis = reinterpret_cast<CWindowWnd*>(lParam);
        if( pThis == NULL ) return TRUE;

        ASSERT(pThis->m_hWnd == NULL);
        pThis->m_hWnd = hDlg;

        // ---- 换掉对话框默认的窗口过程 ----
        // 这样后续所有消息（含 WM_PAINT / WM_TOUCH / 鼠标）都会走到
        // CWindowWnd::HandleMessage → CPaintManagerUI，DuiLib 的自绘与路由完全保留。
        ASSERT(pThis->m_pfnOldDlgWndProc == NULL);
        pThis->m_pfnOldDlgWndProc = (WNDPROC)::GetWindowLongPtr(hDlg, GWLP_WNDPROC);
        ::SetWindowLongPtr(hDlg, GWLP_WNDPROC, (LONG_PTR)(WNDPROC)CWindowWnd::__DialogWndProc);
        ::SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)pThis);

        // ---- 登记为当前模态窗口 ----
        CPaintManagerUI::SetModalWindow(hDlg);

        // ---- 触摸注册：对话框是全新的 HWND，必须注册，否则收不到 WM_TOUCH ----
        RegisterTouchWindowIfAvailable(hDlg);

        DuiLibDiag::Log(_T("MODAL-DLG init dlg=%p oldwndproc=%p focus=%p"),
            (void*)hDlg, (void*)pThis->m_pfnOldDlgWndProc, (void*)::GetFocus());

        // ---- 把旧的 CPaintManagerUI 挂到对话框窗口上 ----
        // 调用方在 ShowModal() 之前已 Create + manager.Init 到旧 HWND；这里把 manager 迁移过来，
        // 让 DuiLib 的全部既有逻辑（绘制 / 消息 / 控件树）在新窗口上继续工作。
        CPaintManagerUI* pManager = GetDetachedManager();
        if( pManager != NULL )
        {
            pManager->AttachPaintWindow(hDlg);
            DuiLibDiag::Log(_T("MODAL-DLG attach manager=%p to dlg=%p"), (void*)pManager, (void*)hDlg);
            // 用掉即清：避免这个文件级静态变量残留一个已失效的指针，
            // 影响下一次 ShowModal（尤其嵌套弹框：A 弹框里再开 B 弹框）。
            SetDetachedManager(NULL);
        }
        else
        {
            DuiLibDiag::Log(_T("MODAL-DLG no detached manager (dialog will Init itself)"));
        }

        // ---- [WM_TOUCH 归属权] 立刻把"补调原窗口过程"的钩子绑到本弹框 ----
        // 为什么必须在这里（而不是等 __DialogWndProc 首次进入时再绑）：
        //   __DialogProc 在 WM_INITDIALOG 里直接调 pThis->HandleMessage（见下方），
        //   这条路径**不经过** __DialogWndProc，所以"首次进入窗口过程时绑定"
        //   在这条路上不会触发。而 AttachPaintWindow 之后 manager 已经指向 hDlg，
        //   一旦有 WM_MOUSEMOVE 到达就可能需要补调 ⇒ 必须现在就绑好。
        //   绑定对象是 m_pfnOldDlgWndProc（即 #32770 原过程 / DefDlgProc）。
        if( pManager != NULL )
        {
            // m_pfnOldDlgWndProc 本身就是 WNDPROC；只有它意外为空时才回落到 DefDlgProc
            // （签名是 INT_PTR 返回，需显式转换，不能与 WNDPROC 混在三目里）。
            WNDPROC pfnDlgTarget = pThis->m_pfnOldDlgWndProc;
            if( pfnDlgTarget == NULL )
                pfnDlgTarget = reinterpret_cast<WNDPROC>(::DefDlgProc);
            BindRelayTarget(pfnDlgTarget, hDlg);
            pManager->SetDefProcRelay(&RelayWndProc, hDlg);
        }

        // ---- 尺寸校正（关键）----
        // DLGTEMPLATE 里给的 cx/cy 是对话框单位(DLU)、且语义为「客户区」，系统创建时还会
        // 按实际样式额外加一圈非客户区边框。所以不能指望"模板尺寸 == 目标尺寸"。
        // 这里用 AdjustWindowRectEx 按对话框**真实**的样式反算目标外框，再 SetWindowPos 精确校正，
        // 保证客户区尺寸与原窗口逐像素一致 —— 这正是"弹框变大了"的修法。
        //
        // 放在 AttachPaintWindow 之后、HandleMessage(WM_INITDIALOG) 之前：
        // 此时 manager 已绑定新 HWND，尺寸变化会走正常的布局流程；且业务层 OnCreate 之前
        // 窗口就已经是最终尺寸，避免"先小后大"的闪动与一次性布局错位。
        {
            const DWORD dwRealStyle   = (DWORD)::GetWindowLong(hDlg, GWL_STYLE);
            const DWORD dwRealExStyle = (DWORD)::GetWindowLong(hDlg, GWL_EXSTYLE);
            RECT rcAdjust = { 0, 0,
                              pThis->m_rcModalTarget.right  - pThis->m_rcModalTarget.left,
                              pThis->m_rcModalTarget.bottom - pThis->m_rcModalTarget.top };
            const int nClientW = rcAdjust.right;
            const int nClientH = rcAdjust.bottom;
            // 反算：以"目标客户区尺寸"为输入，得到需要的外框尺寸
            ::AdjustWindowRectEx(&rcAdjust, dwRealStyle, FALSE, dwRealExStyle);

            const int nWndW = rcAdjust.right  - rcAdjust.left;
            const int nWndH = rcAdjust.bottom - rcAdjust.top;

            RECT rcCur = { 0 };
            ::GetWindowRect(hDlg, &rcCur);
            DuiLibDiag::Log(_T("MODAL-DLG resize before cur=%dx%d clientTarget=%dx%d -> wnd=%dx%d hide=%d"),
                rcCur.right - rcCur.left, rcCur.bottom - rcCur.top,
                nClientW, nClientH, nWndW, nWndH,
                (int)((dwRealStyle & WS_VISIBLE) == 0));

            // SWP_FRAMECHANGED 让系统重新计算非客户区（样式刚被 SetWindowLongPtr 换过）
            ::SetWindowPos(hDlg, NULL,
                           pThis->m_rcModalTarget.left, pThis->m_rcModalTarget.top,
                           nWndW, nWndH,
                           SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);

            RECT rcAfter = { 0 };
            ::GetClientRect(hDlg, &rcAfter);
            DuiLibDiag::Log(_T("MODAL-DLG resize after client=%dx%d (target=%dx%d)"),
                rcAfter.right - rcAfter.left, rcAfter.bottom - rcAfter.top, nClientW, nClientH);
        }

        // 交给 CWindowWnd::HandleMessage 处理 WM_INITDIALOG，业务层的 OnCreate 等由此触发。
        pThis->HandleMessage(uMsg, wParam, lParam);

        ::SetFocus(hDlg);
        return TRUE;    // TRUE = 我们自己设置了焦点
    }

    return FALSE;
}

// -----------------------------------------------------------------------------
// 真模态：对话框窗口的窗口过程。
// 几乎就是 __WndProc 的对话框版本。
// -----------------------------------------------------------------------------
LRESULT CALLBACK CWindowWnd::__DialogWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CWindowWnd* pThis = reinterpret_cast<CWindowWnd*>(::GetWindowLongPtr(hWnd, GWLP_USERDATA));

    if( uMsg == WM_NCDESTROY && pThis != NULL )
    {
        // 顺序很关键：
        //   1) 先把窗口过程还原（此后系统调用会回到对话框默认过程）；
        //   2) 再让 DefWindowProc 做标准清理；
        //   3) 清 GWLP_USERDATA —— 必须在 HandleMessage 之前，防止重入时又拿到 this；
        //   4) 清模态登记；
        //   5) m_hWnd 置空【要在 Unsubclass 之前】—— 注意本项目弹框并不 Subclass，
        //      m_bSubclassed 恒为 false，这里只是保持与 __WndProc 一致的写法，
        //      并让 OnFinalMessage 里看到的 m_hWnd 为空（与旧行为一致）。
        if( pThis->m_pfnOldDlgWndProc != NULL )
        {
            ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)pThis->m_pfnOldDlgWndProc);
            pThis->m_pfnOldDlgWndProc = NULL;
        }
        LRESULT lRes = ::DefWindowProc(hWnd, uMsg, wParam, lParam);
        // [WM_TOUCH 归属权] 解绑转发目标，避免悬垂到已销毁的对话框窗口过程。
        {
            DuiLib::CPaintManagerUI* pMgrNc = FindManagerByPaintWindow(hWnd);
            if( pMgrNc != NULL )
            {
                pMgrNc->ClearDefProcRelay(hWnd);
                // [模态提示音 / 透点] 第二道撤防：不管弹框以哪条路径死掉
                // （Close / EndDialog / 外部 DestroyWindow / 创建失败收尾），
                // 只要它的窗口在销毁，就不允许消音窗口继续存在。
                // 抑制位跟着 manager 对象走，而 manager 可能被回收再复用，
                // 若不清就可能在下一个不相关的窗口上"诈尸"，吞掉用户的真实点击。
                pMgrNc->SetSuppressPromotedMouseForModal(false);
            }
            BindRelayTarget(NULL, NULL);
        }
        ::SetWindowLongPtr(hWnd, GWLP_USERDATA, 0L);
        CPaintManagerUI::SetModalWindow(NULL);
        pThis->m_hWnd = NULL;
        if( pThis->m_bSubclassed ) pThis->Unsubclass();
        pThis->OnFinalMessage(hWnd);
        return lRes;
    }

    // WM_INITDIALOG 已经由 __DialogProc 处理并 return TRUE，
    // 一般不会再走到这里；若系统仍投递（例如 EndDialog 之后的收尾路径），
    // 直接交回对话框默认过程，避免被 HandleMessage 当成普通消息误处理。
    if( uMsg == WM_INITDIALOG )
        return ::DefDlgProc(hWnd, uMsg, wParam, lParam);

    // 诊断：确认 WM_TOUCH 到底投递给了哪个窗口。
    if( uMsg == WM_TOUCH ) TraceTouchArrival(hWnd, wParam, lParam);
    if( pThis != NULL ) TraceInputMessage(hWnd, uMsg, wParam, lParam);

    if( pThis != NULL )
    {
        // ---------------------------------------------------------------
        // [WM_TOUCH 归属权] 注册"补调原窗口过程"的钩子。
        //
        // 真模态弹框的窗口类是系统对话框类 #32770，它把"把特殊标记的
        // WM_MOUSEMOVE 翻译成 WM_TOUCH"这件事放在 DefDlgProc → DefWindowProc 里做。
        // 而 __DialogWndProc 一旦 pThis != NULL 就全部交给 HandleMessage，
        // 再也不回落 DefDlgProc ⇒ 弹框永远收不到 WM_TOUCH（与实测吻合）。
        //
        // 这里登记的原过程是 m_pfnOldDlgWndProc（也就是 DefDlgProc），
        // 使 manager 在吞掉触摸提升鼠标消息时能补调它一次，把翻译链接上。
        // ---------------------------------------------------------------
        // ⚠️ 判据必须是"当前绑定的窗口不是本窗口"，不能写 `GetDefProcRelay() == NULL`：
        // 真模态弹框复用的是**同一个** manager 对象（从旧窗口 Detach、再 Attach 到弹框），
        // 主窗口早已注册过钩子 ⇒ 按 NULL 判断则弹框永远不重新绑定，
        // 转发目标会一直指向主窗口的原过程，补调无效甚至喂错窗口。
        DuiLib::CPaintManagerUI* pMgr = FindManagerByPaintWindow(hWnd);
        if( pMgr != NULL && pMgr->GetDefProcRelayBoundWindow() != hWnd )
        {
            // ⚠️ DefDlgProc 的签名是 `INT_PTR (CALLBACK*)(...)`，与 WNDPROC
            // （`LRESULT (CALLBACK*)(...)`）返回类型不同，三目运算符会类型不匹配。
            // 用一个显式分支赋值，避免 C2446。
            WNDPROC pfnTarget = NULL;
            if( pThis->m_pfnOldDlgWndProc != NULL )
                pfnTarget = pThis->m_pfnOldDlgWndProc;
            else
                pfnTarget = reinterpret_cast<WNDPROC>(::DefDlgProc);
            BindRelayTarget(pfnTarget, hWnd);
            pMgr->SetDefProcRelay(&RelayWndProc, hWnd);
        }
        return pThis->HandleMessage(uMsg, wParam, lParam);
    }

    return ::DefDlgProc(hWnd, uMsg, wParam, lParam);
}


void CWindowWnd::ShowModalFake()
{
    ASSERT(::IsWindow(m_hWnd));
    auto p_hwnd = GetWindowOwner(m_hWnd);
    ASSERT(::IsWindow(p_hwnd));
    ASSERT(p_hwnd);
    ::EnableWindow(p_hwnd, FALSE);
    ShowWindow();
    m_bFakeModal = true;
}

void CWindowWnd::Close(UINT nRet)
{
    if (m_bFakeModal)
    {
        auto parent_hwnd = GetWindowOwner(m_hWnd);
        ASSERT(::IsWindow(parent_hwnd));
        ::EnableWindow(parent_hwnd, TRUE);
        ::SetFocus(parent_hwnd);
        m_bFakeModal = false;
    }

    ASSERT(::IsWindow(m_hWnd));
    if (!::IsWindow(m_hWnd)) return;

    // -------------------------------------------------------------------------
    // 真模态：走 EndDialog 结束系统对话框循环。
    //
    // 旧的假模态是 PostMessage(WM_CLOSE) 让自写循环退出；真模态下必须用 EndDialog，
    // 否则 DialogBoxIndirectParam 不会返回。返回值写入 m_nModalRet，由 ShowModal 读走。
    //
    // 注意：EndDialog 会销毁对话框窗口 → 触发 WM_NCDESTROY → __DialogWndProc 收尾
    // （还原窗口过程、清 USERDATA、调 OnFinalMessage）。所以这里不要再 DestroyWindow。
    // -------------------------------------------------------------------------
    if (m_bDoModal)
    {
        m_nModalRet = nRet;

        // ---------------------------------------------------------------------
        // [模态提示音 / 透点] 关弹框时【立即】撤掉消音窗口 —— 这是 Win10 "3 秒透点"
        // 的关键修复点。
        //
        // 现象（Win10）：点商品控件弹属性框；3 秒内点"选好了"一切正常；一旦超过 3 秒
        //   再点"选好了"，弹框关掉的同时还会"透"到底下、又点到"选好了"背后的商品控件。
        //
        // 成因：消音窗口原先只靠 MessageHandler 里的超时自愈撤销，而那个超时是 3000ms
        //   （UIManager.cpp 的 TOUCH-STATE timeout-reset）。用户观察到的"3 秒"就是它。
        //   超过 3 秒后，抑制位已被超时清掉，可**这次手势的提升鼠标消息还排在队列里没
        //   投出来**（触摸 UP 的点击回调此刻正在执行）⇒ 抑制失效 ⇒ 那条残留消息被放行
        //   ⇒ 命中弹框背后的窗口 ⇒ 透点。
        //   实质是"靠一个超时 bug 去挡另一个时序 bug"，只是恰好 3 秒内不出问题。
        //
        // 修复：弹框关闭是**确定性时点**，比任何超时都可靠 —— 在 EndDialog 之前主动把
        //   同一 manager 上的抑制状态清干净（含未配对的 pending 计数，见
        //   SetSuppressPromotedMouseForModal(false) 的实现）。
        //
        // 为什么用 FindManagerByPaintWindow 而不是 ShowModal 里缓存的 pManager：
        //   真模态把同一个 manager 从旧窗口 Detach、再 Attach 到本弹框，所以此刻
        //   m_hWnd 就是弹框句柄，能直接查到它。查不到也无妨 —— 下面 EndDialog 会让
        //   __DialogWndProc 的 WM_NCDESTROY 收尾，那里还有第二道撤防。
        // ---------------------------------------------------------------------
        {
            DuiLib::CPaintManagerUI* pMgrClosing = FindManagerByPaintWindow(m_hWnd);
            if (pMgrClosing != NULL)
            {
                pMgrClosing->SetSuppressPromotedMouseForModal(false);
                DuiLibDiag::Log(_T("MODAL-BEEP disarm-on-close manager=%p hwnd=%p"),
                    (void*)pMgrClosing, (void*)m_hWnd);
            }
        }

        DuiLibDiag::Log(_T("MODAL-DLG EndDialog hwnd=%p ret=%u"), (void*)m_hWnd, nRet);
        ::EndDialog(m_hWnd, (INT_PTR)nRet);
        return;
    }

    PostMessage(WM_CLOSE, (WPARAM)nRet, 0L);
}

void CWindowWnd::CenterWindow()
{
    ASSERT(::IsWindow(m_hWnd));
    ASSERT((GetWindowStyle(m_hWnd)&WS_CHILD)==0);
    RECT rcDlg = { 0 };
    ::GetWindowRect(m_hWnd, &rcDlg);
    RECT rcArea = { 0 };
    RECT rcCenter = { 0 };
	HWND hWnd=*this;
    HWND hWndParent = ::GetParent(m_hWnd);
    HWND hWndCenter = ::GetWindowOwner(m_hWnd);
	if (hWndCenter!=NULL)
		hWnd=hWndCenter;

	// 处理多显示器模式下屏幕居中
	MONITORINFO oMonitor = {};
	oMonitor.cbSize = sizeof(oMonitor);
	::GetMonitorInfo(::MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST), &oMonitor);
	rcArea = oMonitor.rcWork;

    if( hWndCenter == NULL )
		rcCenter = rcArea;
	else
		::GetWindowRect(hWndCenter, &rcCenter);

    int DlgWidth = rcDlg.right - rcDlg.left;
    int DlgHeight = rcDlg.bottom - rcDlg.top;

    // Find dialog's upper left based on rcCenter
    int xLeft = (rcCenter.left + rcCenter.right) / 2 - DlgWidth / 2;
    int yTop = (rcCenter.top + rcCenter.bottom) / 2 - DlgHeight / 2;

    // The dialog is outside the screen, move it inside
    if( xLeft < rcArea.left ) xLeft = rcArea.left;
    else if( xLeft + DlgWidth > rcArea.right ) xLeft = rcArea.right - DlgWidth;
    if( yTop < rcArea.top ) yTop = rcArea.top;
    else if( yTop + DlgHeight > rcArea.bottom ) yTop = rcArea.bottom - DlgHeight;
    ::SetWindowPos(m_hWnd, NULL, xLeft, yTop, -1, -1, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
}

void CWindowWnd::SetIcon(UINT nRes)
{
	HICON hIcon = (HICON)::LoadImage(CPaintManagerUI::GetInstance(), MAKEINTRESOURCE(nRes), IMAGE_ICON,
		(::GetSystemMetrics(SM_CXICON) + 15) & ~15, (::GetSystemMetrics(SM_CYICON) + 15) & ~15,	// 防止高DPI下图标模糊
		LR_DEFAULTCOLOR);
	ASSERT(hIcon);
	::SendMessage(m_hWnd, WM_SETICON, (WPARAM) TRUE, (LPARAM) hIcon);

	hIcon = (HICON)::LoadImage(CPaintManagerUI::GetInstance(), MAKEINTRESOURCE(nRes), IMAGE_ICON,
		(::GetSystemMetrics(SM_CXICON) + 15) & ~15, (::GetSystemMetrics(SM_CYICON) + 15) & ~15,	// 防止高DPI下图标模糊
		LR_DEFAULTCOLOR);
	ASSERT(hIcon);
	::SendMessage(m_hWnd, WM_SETICON, (WPARAM) FALSE, (LPARAM) hIcon);
}

bool CWindowWnd::RegisterWindowClass()
{
    WNDCLASS wc = { 0 };
    wc.style = GetClassStyle();
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hIcon = NULL;
    wc.lpfnWndProc = CWindowWnd::__WndProc;
    wc.hInstance = CPaintManagerUI::GetInstance();
    wc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = NULL;
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = GetWindowClassName();
    ATOM ret = ::RegisterClass(&wc);
    ASSERT(ret!=NULL || ::GetLastError()==ERROR_CLASS_ALREADY_EXISTS);
    return ret != NULL || ::GetLastError() == ERROR_CLASS_ALREADY_EXISTS;
}

bool CWindowWnd::RegisterSuperclass()
{
	if(m_bUnicode) {
#ifndef UNICODE
		LPWSTR lpSuperClassName = a2w((char*)GetSuperClassName());
		LPWSTR lpClassName = a2w((char*)GetWindowClassName());
#else
		LPWSTR lpSuperClassName = (LPWSTR)GetSuperClassName();
		LPWSTR lpClassName = (LPWSTR)GetWindowClassName();
#endif

		// Get the class information from an existing
		// window so we can subclass it later on...
		WNDCLASSEXW wc = { 0 };
		wc.cbSize = sizeof(WNDCLASSEXW);
		if( !::GetClassInfoExW(NULL, lpSuperClassName, &wc) ) {
			if( !::GetClassInfoExW(CPaintManagerUI::GetInstance(), lpSuperClassName, &wc) ) {
				ASSERT(!"Unable to locate window class");
				return NULL;
			}
		}
		m_OldWndProc = wc.lpfnWndProc;
		wc.lpfnWndProc = CWindowWnd::__ControlProc;
		wc.hInstance = CPaintManagerUI::GetInstance();
		wc.lpszClassName = lpClassName;
		ATOM ret = ::RegisterClassExW(&wc);
#ifndef UNICODE
		delete []lpClassName;
		delete []lpSuperClassName;
#endif
		ASSERT(ret!=NULL || ::GetLastError()==ERROR_CLASS_ALREADY_EXISTS);
		return ret != NULL || ::GetLastError() == ERROR_CLASS_ALREADY_EXISTS;
	}
	else {
		// Get the class information from an existing
		// window so we can subclass it later on...
		WNDCLASSEX wc = { 0 };
		wc.cbSize = sizeof(WNDCLASSEX);
		if( !::GetClassInfoEx(NULL, GetSuperClassName(), &wc) ) {
			if( !::GetClassInfoEx(CPaintManagerUI::GetInstance(), GetSuperClassName(), &wc) ) {
				ASSERT(!"Unable to locate window class");
				return NULL;
			}
		}
		m_OldWndProc = wc.lpfnWndProc;
		wc.lpfnWndProc = CWindowWnd::__ControlProc;
		wc.hInstance = CPaintManagerUI::GetInstance();
		wc.lpszClassName = GetWindowClassName();
		ATOM ret = ::RegisterClassEx(&wc);
		ASSERT(ret!=NULL || ::GetLastError()==ERROR_CLASS_ALREADY_EXISTS);
		return ret != NULL || ::GetLastError() == ERROR_CLASS_ALREADY_EXISTS;
	}
}

// 注：RelayWndProc / BindRelayTarget 已上移到文件前部的**匿名 namespace 内**
// （约 308 / 317 行），因为 __DialogWndProc 比本函数先出现、也要用到它们。
// 另注：FindManagerByPaintWindow 也已移到匿名 namespace **之外**（约 350 行），
// 以便与 UIBase.h 里的同名声明一一对应（否则调用点会报 C2668 二义）。

LRESULT CALLBACK CWindowWnd::__WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{    CWindowWnd* pThis = NULL;
    if( uMsg == WM_NCCREATE ) {
        LPCREATESTRUCT lpcs = reinterpret_cast<LPCREATESTRUCT>(lParam);
        pThis = static_cast<CWindowWnd*>(lpcs->lpCreateParams);
        pThis->m_hWnd = hWnd;
        ::SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LPARAM>(pThis));
    } 
    else {
        pThis = reinterpret_cast<CWindowWnd*>(::GetWindowLongPtr(hWnd, GWLP_USERDATA));
        if( uMsg == WM_NCDESTROY && pThis != NULL ) {
            LRESULT lRes = ::CallWindowProc(pThis->m_OldWndProc, hWnd, uMsg, wParam, lParam);
            // [WM_TOUCH 归属权] 解绑转发目标，避免悬垂到已销毁窗口的窗口过程。
            DuiLib::CPaintManagerUI* pMgrNc = FindManagerByPaintWindow(hWnd);
            if( pMgrNc != NULL ) pMgrNc->ClearDefProcRelay(hWnd);
            BindRelayTarget(NULL, NULL);
            ::SetWindowLongPtr(pThis->m_hWnd, GWLP_USERDATA, 0L);
            if( pThis->m_bSubclassed ) pThis->Unsubclass();
            pThis->m_hWnd = NULL;
            pThis->OnFinalMessage(hWnd);
            return lRes;
        }
    }
    // 诊断：确认 WM_TOUCH 到底投递给了哪个窗口（弹框 / owner / 其它）。
    if( uMsg == WM_TOUCH ) TraceTouchArrival(hWnd, wParam, lParam);

    // 【临时全量诊断】所有输入类消息（含 WM_TOUCH / WM_GESTURE / WM_POINTER* / 鼠标 / 激活）
    // 都记一条，用来判断系统到底把消息发给了谁。
    if( pThis != NULL ) TraceInputMessage(hWnd, uMsg, wParam, lParam);

    if( pThis != NULL ) {
        // ---------------------------------------------------------------
        // [WM_TOUCH 归属权] 注册"补调原窗口过程"的钩子。
        // 把 m_OldWndProc（本窗口类的原过程）登记为转发目标，并交给 manager。
        // manager 在吞掉"触摸提升 WM_MOUSEMOVE"时会回调它一次，
        // 让系统的 WM_TOUCH 翻译链不断掉。
        //
        // 判据用"绑定窗口 != 本窗口"而非"钩子为空"：真模态弹框复用同一个
        // manager，换 HWND 时必须能重新绑定到对话框架自己的原过程。
        // 开销：仅在窗口首个消息时走一遍查找，之后靠 manager 内的指针直连。
        // ---------------------------------------------------------------
        DuiLib::CPaintManagerUI* pMgr = FindManagerByPaintWindow(hWnd);
        if( pMgr != NULL && pMgr->GetDefProcRelayBoundWindow() != hWnd )
        {
            BindRelayTarget(pThis->m_OldWndProc, hWnd);
            pMgr->SetDefProcRelay(&RelayWndProc, hWnd);
        }
        return pThis->HandleMessage(uMsg, wParam, lParam);
    } 
    else {
        return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
}

LRESULT CALLBACK CWindowWnd::__ControlProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CWindowWnd* pThis = NULL;
    if( uMsg == WM_NCCREATE ) {
        LPCREATESTRUCT lpcs = reinterpret_cast<LPCREATESTRUCT>(lParam);
        pThis = static_cast<CWindowWnd*>(lpcs->lpCreateParams);
        ::SetProp(hWnd, _T("WndX"), (HANDLE) pThis);
        pThis->m_hWnd = hWnd;
    } 
    else {
        pThis = reinterpret_cast<CWindowWnd*>(::GetProp(hWnd, _T("WndX")));
        if( uMsg == WM_NCDESTROY && pThis != NULL ) {
            LRESULT lRes = ::CallWindowProc(pThis->m_OldWndProc, hWnd, uMsg, wParam, lParam);
            if( pThis->m_bSubclassed ) pThis->Unsubclass();
            ::SetProp(hWnd, _T("WndX"), NULL);
            pThis->m_hWnd = NULL;
            pThis->OnFinalMessage(hWnd);
            return lRes;
        }
    }
    if( pThis != NULL ) {
        return pThis->HandleMessage(uMsg, wParam, lParam);
    } 
    else {
        return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
}

LRESULT CWindowWnd::SendMessage(UINT uMsg, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0*/)
{
    ASSERT(::IsWindow(m_hWnd));
    return ::SendMessage(m_hWnd, uMsg, wParam, lParam);
} 

LRESULT CWindowWnd::PostMessage(UINT uMsg, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0*/)
{
    ASSERT(::IsWindow(m_hWnd));
    return ::PostMessage(m_hWnd, uMsg, wParam, lParam);
}

void CWindowWnd::ResizeClient(int cx /*= -1*/, int cy /*= -1*/)
{
    ASSERT(::IsWindow(m_hWnd));
    RECT rc = { 0 };
    if( !::GetClientRect(m_hWnd, &rc) ) return;
    if( cx != -1 ) rc.right = cx;
    if( cy != -1 ) rc.bottom = cy;
    if( !::AdjustWindowRectEx(&rc, GetWindowStyle(m_hWnd), (!(GetWindowStyle(m_hWnd) & WS_CHILD) && (::GetMenu(m_hWnd) != NULL)), GetWindowExStyle(m_hWnd)) ) return;
    ::SetWindowPos(m_hWnd, NULL, 0, 0, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
}

LRESULT CWindowWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    return ::CallWindowProc(m_OldWndProc, m_hWnd, uMsg, wParam, lParam);
}

void CWindowWnd::OnFinalMessage(HWND /*hWnd*/)
{
}

} // namespace DuiLib