zhipuzi_pos_windows/DuiLib/Core/UIManager.cpp

#include "StdAfx.h"
#include <zmouse.h>
// [触屏诊断] 显式引入，避免依赖 tchar.h 的传递包含
#include <stdio.h>
#include <stdarg.h>
#include <tchar.h>

#pragma warning(push)
#pragma warning(disable:4838 4244)


namespace DuiLib
{

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

	// 触屏参数（NIM Duilib 模型）
	// TOUCHINPUT 的坐标以 1/100 像素为单位，必须先换算成像素
#ifndef TOUCH_COORD_TO_PIXEL
#define TOUCH_COORD_TO_PIXEL(l) ((l) / 100)
#endif
	// [触屏模型] 触摸只做两件事，不做任何“触摸→鼠标”的归一化：
	//   ①点击：由 TOUCHUP 在确认未拖动后派发 BUTTONDOWN/UP，
	//         由 CButtonUI 等控件原生 Activate()；
	//   ②滚动：WM_TOUCH 直接派发 UIEVENT_TOUCHDOWN/MOVE/UP（见 OnTouchInput），
	//         容器据此 1:1 跟手平移、滚动条据此拖滑块。
	//   “轻点 vs 拖拽”使用 m_bTouchMoved 区分，拖动不会激活控件。

	// WM_TOUCH 消息 ID 同样受 `#if _WIN32_WINNT >= 0x0601` 保护，DuiLib 工程未定义
	// _WIN32_WINNT（StdAfx.h 兜底为 XP）→ 必须自行声明，否则 switch 里引用该消息 ID
	// 会报 C2065（未声明的标识符）与 C2051（case 表达式不是常量）。实测固定值 0x0240。
	// 注：Win7+ 段受保护的不仅有结构体与函数，**消息 ID 与辅助宏同样在内**，
	//     TOUCH_COORD_TO_PIXEL 也在上面用 #ifndef 兜底，原因相同。
#ifndef WM_TOUCH
#define WM_TOUCH 0x0240
#endif

	// ======================================================================
	// ★★【悬浮态残留 · 跨 manager】这套"触摸抬手后抑制悬浮复活"的状态必须是
	//   **线程级（文件级静态）**的，绝不能用 CPaintManagerUI 的成员。★★
	//
	// 反面教材（本项目真机日志实证）：属性弹框 CDiandanNatureWnd **自带独立的
	//   CPaintManagerUI m_pm**，与主窗口的 manager 不是同一个对象
	//   （真机日志：弹框的 `MANAGER-MSG hwnd=000E04BA manager=0A29F5F8`，
	//     主窗口的 `MANAGER-MSG hwnd=001304D0 manager=07DA8C58`）。
	//
	//   用户点弹框里的「选好了」关掉弹框时：
	//     · 那次触摸由**弹框的 manager** 处理 ⇒ 抑制位与参考点写在弹框那一份上；
	//     · 弹框一销毁，系统立刻给**主窗口**补投一条 extra=0 / fromtouch=0 的
	//       WM_MOUSEMOVE（语义"指针真的停在这"）⇒ 落在**主窗口的 manager** 上。
	//   主窗口那份状态压根不知道刚刚发生过触摸：抑制位要么是假，要么参考点还停在
	//   更早那次主窗口触摸的位置 ⇒ ±8px 判据必然失败 ⇒ 解除抑制 + FindControl(pt)
	//   命中背后商品卡 ⇒ **悬浮态点亮且此后永不熄灭**。
	//   （真机日志：`MODAL-DLG exit` → `HOVER-ENTER diandan_fooditem pt=778,630`，
	//     而主窗口那份参考点还停在 1225,446 —— 相距 447 像素。）
	//
	// 与 `s_nPromotedMouseGeneration` 的理由完全相同：这是**线程消息队列**现象，
	//   与 manager 归属无关 ⇒ 状态必须线程级。
	//   （本项目 UI 单线程；若将来多线程，把这两个 static 换成 TLS 即可。）
	//
	// 参考点存**屏幕坐标**：WM_MOUSEMOVE 的 lParam 是"接收窗口的客户区坐标"，
	//   而触摸可能发生在另一个窗口里 —— 客户区坐标一换窗口就不可比。
	// ======================================================================
	static bool  s_bSuppressHoverAfterTouch = false;
	static POINT s_ptLastTouchScreen = { 0, 0 };

	// ---------------------------------------------------------------------------
	// WM_POINTER* 消息 ID（Win8+）。参考 nim_duilib NativeWindow_Windows::OnPointerMsgs。
	//
	// 为什么必须自行定义：这些宏在 winuser.h 里受 `#if _WIN32_WINNT >= 0x0602` 保护，
	// 而本工程编译目标是 0x0601（Win7），编译期不可见。用字面量绕过（数值固定）。
	//
	// 为什么必须处理：Win10 在 Pointer 栈可用时会优先投递 WM_POINTER*，而**不是** legacy
	// 的 WM_TOUCH。我们此前完全不处理这条通道 —— 一旦系统走了 Pointer 路径，窗口就
	// 既没有 WM_TOUCH 状态机、又没有触发鼠标提升，表现就是"什么都点不动"。
	// nim_duilib 的注释还明确指出：WM_POINTERCAPTURECHANGED 若不设置 bHandled，
	// 系统会把它转换成 WM_BUTTON 类消息 —— 说明系统确实在这两条通道间做隐式转换。
	// ---------------------------------------------------------------------------
	namespace PointerMsg
	{
		const UINT DUI_WM_POINTERUPDATE        = 0x0245;
		const UINT DUI_WM_POINTERDOWN          = 0x0246;
		const UINT DUI_WM_POINTERUP            = 0x0247;
		const UINT DUI_WM_POINTERENTER         = 0x0249;
		const UINT DUI_WM_POINTERLEAVE         = 0x024A;
		const UINT DUI_WM_POINTERACTIVATE      = 0x024B;
		const UINT DUI_WM_POINTERCAPTURECHANGED= 0x024C;
		const UINT DUI_WM_POINTERWHEEL         = 0x024E;
		const UINT DUI_WM_POINTERHWHEEL        = 0x024F;

		// POINTER_INFO 里我们只关心主指针判定：
		// IS_POINTER_PRIMARY_WPARAM 的等价判断 —— 低位 bit0 = isPrimary。
		//
		// ⚠️⚠️【这台收银机上这个位域完全不可信，三个消息各不相同】⚠️⚠️
		//
		// 真机日志实测（同一次触摸的三个阶段）：
		//   msg=0x0246 WM_POINTERDOWN    w=0x60170CC7   HIWORD=0x6017  bit0=1  ✓
		//   msg=0x0245 WM_POINTERUPDATE  w=0x60160CC7   HIWORD=0x6016  bit0=0  ✗
		//   msg=0x0247 WM_POINTERUP      w=0x60000CC7   HIWORD=0x6000  bit0=0  ✗
		//
		// 也就是说 **HIWORD 根本不是 MSDN 描述的 POINTER_INFO 位域**（0x6016/0x6017/0x6000
		// 这三个值里只有 bit0 在 0x6016→0x6017 之间来回抖，看不出 primary 语义）。
		// 后果极其隐蔽：
		//   · DOWN 恰好读到 bit0=1 ⇒ 蒙对了，手势能建立；
		//   · UPDATE 读到 bit0=0 ⇒ 被当成"非主指针"**全部丢掉**，实测 486/486 条全丢
		//     ⇒ 手势建立成功、抬手也能派发点击（UP 早已豁免），
		//     但**整个过程没有任何位移信息** ⇒ 表现为"能点击，但怎么划都滑不动"。
		//   · UP 读到 bit0=0 ⇒ 当初就踩过，已单独豁免。
		//
		// 结论（照搬 nim_duilib 的做法）：**不要再依赖这个位域做过滤**。
		// nim_duilib 的 OnPointerMsgs 虽然也写了 IS_POINTER_PRIMARY_WPARAM，
		// 但它只处理单指场景、且按 pointerId 取坐标，对错位不敏感。
		// 本项目改为：DOWN/UPDATE/UP 一律不做 primary 过滤，
		// 统一用 m_dwActivePointerId 精确配对（是不是"发起本次手势的那根手指"）——
		// 这个判据来自 pointerId（LOWORD，即日志里的 0x0CC7=3271），是可靠的。
		//
		// 本函数保留但恒返回 true，仅作为"位域不可信的显式记录点"，勿再改回位域判断。
		inline bool IsPrimaryPointer(WPARAM wParam)
		{
			(void)wParam;
			return true;
		}
	}
	// ---------------------------------------------------------------------------
	// [触屏诊断] 日志出口已**统一到 `DuiLibDiag`**（Utils/UIDiag.h/.cpp）。
	//
	// 原先这里有一份 `namespace TouchTrace { void Log(LPCTSTR, ...); }` 的本地实现，
	// 与 UIDiag 的写法（`[tick][tid] 文本`、UTF-8、追加写 exe 同目录 touch_trace.log、
	// 32MB 封顶）完全重复，且因为处于**匿名 namespace** 而无法被别的 .cpp 引用
	// —— 这正是当初另起 UIDiag 的原因。
	//
	// 现在本文件（以及 UIBase.cpp / UIButton.cpp）的所有诊断调用一律写
	// `DuiLibDiag::Log(...)`，只有 UIDiag.cpp 一处真正落盘。
	// 关日志 / 改路径 / 改封顶值 ⇒ **只改 UIDiag.cpp 的 Enabled()**，不要在本文件加实现。
	// ---------------------------------------------------------------------------

	static void GetChildWndRect(HWND hWnd, HWND hChildWnd, RECT& rcChildWnd)
	{
		::GetWindowRect(hChildWnd, &rcChildWnd);

		POINT pt;
		pt.x = rcChildWnd.left;
		pt.y = rcChildWnd.top;
		::ScreenToClient(hWnd, &pt);
		rcChildWnd.left = pt.x;
		rcChildWnd.top = pt.y;

		pt.x = rcChildWnd.right;
		pt.y = rcChildWnd.bottom;
		::ScreenToClient(hWnd, &pt);
		rcChildWnd.right = pt.x;
		rcChildWnd.bottom = pt.y;
	}

	static UINT MapKeyState()
	{
		UINT uState = 0;
		if (::GetKeyState(VK_CONTROL) < 0) uState |= MK_CONTROL;
		if (::GetKeyState(VK_LBUTTON) < 0) uState |= MK_LBUTTON;
		if (::GetKeyState(VK_RBUTTON) < 0) uState |= MK_RBUTTON;
		if (::GetKeyState(VK_SHIFT) < 0) uState |= MK_SHIFT;
		if (::GetKeyState(VK_MENU) < 0) uState |= MK_ALT;
		return uState;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	///
	typedef struct tagFINDTABINFO
	{
		CControlUI* pFocus;
		CControlUI* pLast;
		bool bForward;
		bool bNextIsIt;
	} FINDTABINFO;

	typedef struct tagFINDSHORTCUT
	{
		TCHAR ch;
		bool bPickNext;
	} FINDSHORTCUT;

	typedef struct tagTIMERINFO
	{
		CControlUI* pSender;
		UINT nLocalID;
		HWND hWnd;
		UINT uWinTimer;
		bool bKilled;
	} TIMERINFO;


	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	///
	tagTImageInfo::tagTImageInfo()
	{
		pImage = NULL;
		hBitmap = NULL;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	///
	tagTDrawInfo::tagTDrawInfo()
	{
		Clear();
	}

	void tagTDrawInfo::Parse(LPCTSTR pStrImage, LPCTSTR pStrModify, CPaintManagerUI* pManager)
	{
		// 1、aaa.jpg
		// 2、file='aaa.jpg' res='' restype='0' dest='0,0,0,0' source='0,0,0,0' corner='0,0,0,0' 
		// mask='#FF0000' fade='255' hole='false' xtiled='false' ytiled='false'
		sDrawString = pStrImage;
		sDrawModify = pStrModify;
		sImageName = pStrImage;

		CDuiString sItem;
		CDuiString sValue;
		LPTSTR pstr = NULL;
		for (int i = 0; i < 2; ++i)
		{
			if (i == 1) pStrImage = pStrModify;
			if (!pStrImage) continue;
			while (*pStrImage != _T('\0'))
			{
				sItem.Empty();
				sValue.Empty();
				while (*pStrImage > _T('\0') && *pStrImage <= _T(' ')) pStrImage = ::CharNext(pStrImage);
				while (*pStrImage != _T('\0') && *pStrImage != _T('=') && *pStrImage > _T(' '))
				{
					LPTSTR pstrTemp = ::CharNext(pStrImage);
					while (pStrImage < pstrTemp)
					{
						sItem += *pStrImage++;
					}
				}
				while (*pStrImage > _T('\0') && *pStrImage <= _T(' ')) pStrImage = ::CharNext(pStrImage);
				if (*pStrImage++ != _T('=')) break;
				while (*pStrImage > _T('\0') && *pStrImage <= _T(' ')) pStrImage = ::CharNext(pStrImage);
				if (*pStrImage++ != _T('\'')) break;
				while (*pStrImage != _T('\0') && *pStrImage != _T('\''))
				{
					LPTSTR pstrTemp = ::CharNext(pStrImage);
					while (pStrImage < pstrTemp)
					{
						sValue += *pStrImage++;
					}
				}
				if (*pStrImage++ != _T('\'')) break;
				if (!sValue.IsEmpty())
				{
					if (sItem == _T("file") || sItem == _T("res"))
					{
						sImageName = sValue;
					}
					else if (sItem == _T("restype"))
					{
						sResType = sValue;
					}
					else if (sItem == _T("dest"))
					{
						rcDest.left = _tcstol(sValue.GetData(), &pstr, 10);  ASSERT(pstr);
						rcDest.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);
						rcDest.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);
						rcDest.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
						//if(pManager != NULL) pManager->GetDPIObj()->Scale(&rcDest);
					}
					else if (sItem == _T("source"))
					{
						rcSource.left = _tcstol(sValue.GetData(), &pstr, 10);  ASSERT(pstr);
						rcSource.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);
						rcSource.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);
						rcSource.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
						//if(pManager != NULL) pManager->GetDPIObj()->Scale(&rcSource);
					}
					else if (sItem == _T("corner"))
					{
						rcCorner.left = _tcstol(sValue.GetData(), &pstr, 10);  ASSERT(pstr);
						rcCorner.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);
						rcCorner.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);
						rcCorner.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
						//if(pManager != NULL) pManager->GetDPIObj()->Scale(&rcCorner);
					}
					else if (sItem == _T("mask"))
					{
						if (sValue[0] == _T('#')) dwMask = _tcstoul(sValue.GetData() + 1, &pstr, 16);
						else dwMask = _tcstoul(sValue.GetData(), &pstr, 16);
					}
					else if (sItem == _T("fade"))
					{
						uFade = (UINT)_tcstoul(sValue.GetData(), &pstr, 10);
					}
					else if (sItem == _T("rotate"))
					{
						uRotate = (UINT)_tcstoul(sValue.GetData(), &pstr, 10);
						bGdiplus = true;
					}
					else if (sItem == _T("gdiplus"))
					{
						bGdiplus = (_tcsicmp(sValue.GetData(), _T("true")) == 0);
					}
					else if (sItem == _T("hole"))
					{
						bHole = (_tcsicmp(sValue.GetData(), _T("true")) == 0);
					}
					else if (sItem == _T("xtiled"))
					{
						bTiledX = (_tcsicmp(sValue.GetData(), _T("true")) == 0);
					}
					else if (sItem == _T("ytiled"))
					{
						bTiledY = (_tcsicmp(sValue.GetData(), _T("true")) == 0);
					}
					else if (sItem == _T("hsl"))
					{
						bHSL = (_tcsicmp(sValue.GetData(), _T("true")) == 0);
					}
					else if (sItem == _T("size"))
					{
						szImage.cx = _tcstol(sValue.GetData(), &pstr, 10);  ASSERT(pstr);
						szImage.cy = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);
					}
					else if (sItem == _T("align"))
					{
						sAlign = sValue;
					}
					else if (sItem == _T("padding"))
					{
						rcPadding.left = _tcstol(sValue.GetData(), &pstr, 10);  ASSERT(pstr);
						rcPadding.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);
						rcPadding.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);
						rcPadding.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
						//if(pManager != NULL) pManager->GetDPIObj()->Scale(&rcPadding);
					}
				}
				if (*pStrImage++ != _T(' ')) break;
			}
		}

		// 调整DPI资源
		if (pManager != NULL && pManager->GetDPIObj()->GetScale() != 100)
		{
			CDuiString sScale;
			sScale.Format(_T("@%d."), pManager->GetDPIObj()->GetScale());
			sImageName.Replace(_T("."), sScale);
		}
	}
	void tagTDrawInfo::Clear()
	{
		sDrawString.Empty();
		sDrawModify.Empty();
		sImageName.Empty();

		memset(&rcDest, 0, sizeof(RECT));
		memset(&rcSource, 0, sizeof(RECT));
		memset(&rcCorner, 0, sizeof(RECT));
		dwMask = 0;
		uFade = 255;
		uRotate = 0;
		bHole = false;
		bTiledX = false;
		bTiledY = false;
		bHSL = false;
		bGdiplus = false;

		szImage.cx = szImage.cy = 0;
		sAlign.Empty();
		memset(&rcPadding, 0, sizeof(RECT));
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	///
	typedef BOOL(__stdcall* PFUNCUPDATELAYEREDWINDOW)(HWND, HDC, POINT*, SIZE*, HDC, POINT*, COLORREF, BLENDFUNCTION*, DWORD);
	PFUNCUPDATELAYEREDWINDOW g_fUpdateLayeredWindow = NULL;

	HPEN m_hUpdateRectPen = NULL;

	HINSTANCE CPaintManagerUI::m_hResourceInstance = NULL;
	CDuiString CPaintManagerUI::m_pStrResourcePath;
	CDuiString CPaintManagerUI::m_pStrResourceZip;
	CDuiString CPaintManagerUI::m_pStrResourceZipPwd;  //Garfield 20160325 带密码zip包解密
	HANDLE CPaintManagerUI::m_hResourceZip = NULL;
	bool CPaintManagerUI::m_bCachedResourceZip = true;
	BYTE* CPaintManagerUI::m_cbZipBuf = nullptr;
	int CPaintManagerUI::m_nResType = UILIB_FILE;
	TResInfo CPaintManagerUI::m_SharedResInfo;
	HINSTANCE CPaintManagerUI::m_hInstance = NULL;
	bool CPaintManagerUI::m_bUseHSL = false;
	short CPaintManagerUI::m_H = 180;
	short CPaintManagerUI::m_S = 100;
	short CPaintManagerUI::m_L = 100;
	CStdPtrArray CPaintManagerUI::m_aPreMessages;
	CStdPtrArray CPaintManagerUI::m_aPlugins;

	CPaintManagerUI::CPaintManagerUI() :
		m_hWndPaint(NULL),
		m_hDcPaint(NULL),
		m_hDcOffscreen(NULL),
		m_hDcBackground(NULL),
		m_bOffscreenPaint(true),
		m_hbmpOffscreen(NULL),
		m_pOffscreenBits(NULL),
		m_hbmpBackground(NULL),
		m_pBackgroundBits(NULL),
		m_hwndTooltip(NULL),
		m_uTimerID(0x1000),
		m_pRoot(NULL),
		m_pFocus(NULL),
		m_pEventHover(NULL),
		m_pEventClick(NULL),
		m_pEventRClick(NULL),
		m_pEventKey(NULL),
		m_bFirstLayout(true),
		m_bFocusNeeded(false),
		m_bUpdateNeeded(false),
		m_bMouseTracking(false),
		m_bMouseCapture(false),
		m_bAsyncNotifyPosted(false),
		m_bUsedVirtualWnd(false),
		m_bForceUseSharedRes(false),
		m_nOpacity(0xFF),
		m_bLayered(false),
		m_bLayeredChanged(false),
		m_bShowUpdateRect(false),
		m_bUseGdiplusText(false),
		m_trh(0),
		m_bDragDrop(false),
		m_bDragMode(false),
		m_hDragBitmap(NULL),
		m_pDPI(NULL),
		m_iHoverTime(400UL),
		// [FIX] m_bNoActivate 原本未初始化：Debug 堆新块填充 0xCD -> 读到 true；
		// Release 下则是随机垃圾值，属偶发性隐患。
		// 后果：本文件中 3 处 "if (!m_bNoActivate) ::SetFocus(m_hWndPaint);"
		// (WM_LBUTTONDOWN 1738 / CPaintManagerUI::SetFocus 2442 / SetFocusNeeded 2475) 全部被跳过，
		// 系统焦点无法回到主窗口 -> 原生 EDIT 子窗 CEditWnd 收不到 WM_KILLFOCUS ->
		// 其唯一的销毁途径 PostMessage(WM_CLOSE) 永不触发 -> 光标常闪、点空白不丢焦点。
		// XML 侧仅在显式书写 noactivate 属性时才赋值(UIDlgBuilder.cpp)，故此处必须先给确定初值。
		m_bNoActivate(false),
		// 以下两个成员同样是漏网之鱼（全库无赋值点），一并清零以防后患。
		m_bIsPainting(false),
		m_pLastToolTip(NULL),
		// [指针通道] 默认【开启】。原因见成员声明处的长注释：
		// 之前"默认关闭、收到 WM_TOUCH 即永久关闭"的策略害死了真模态弹框 ——
		// 这台受测试的收银机上，WM_TOUCH 的"贪婪归属权"卡在主窗口，
		// 弹框永远收不到 WM_TOUCH，只收得到按命中投递的 WM_POINTER*；
		// 指针通道又被关掉 ⇒ 弹框彻底没有输入源，怎么点都没反应。
		// 现在改为【始终开启 + 手势级让路】：只要某一侧先开始驱动本次手势，
		// 另一侧就整段手势安静，绝不出现两套 WM_LBUTTONDOWN/UP。
		m_bPointerNormalizeEnabled(true),
		m_bPointerGestureActive(false),
		m_dwActivePointerId(0),
		m_dwPointerDownTick(0),
		// 顺序必须与 UIManager.h 里的声明顺序一致，否则 MSVC 报 -Wreorder（C5038）。
		m_pfnDefProcRelay(NULL),
		m_hWndDefProcRelay(NULL),
		m_bRelayDefProcForTouchMove(false),
		m_uDefProcRelayCount(0)
	{
		// [WM_TOUCH 归属权] 补调 DefWindowProc 的开关读取（无需重新编译即可切换）。
		// 设 DUI_RELAY_DEFPROC=1 开启；只在进程启动时读一次。
		{
			TCHAR szBuf[16] = { 0 };
			const DWORD dwLen = ::GetEnvironmentVariable(_T("DUI_RELAY_DEFPROC"), szBuf, _countof(szBuf));
			if (dwLen > 0 && dwLen < _countof(szBuf) && szBuf[0] == _T('1'))
			{
				m_bRelayDefProcForTouchMove = true;
				DuiLibDiag::Log(_T("DEFPROC-RELAY enabled by env (DUI_RELAY_DEFPROC=1)"));
			}
		}

		if (m_SharedResInfo.m_DefaultFontInfo.sFontName.IsEmpty())
		{
			m_SharedResInfo.m_dwDefaultDisabledColor = 0xFFA7A6AA;
			m_SharedResInfo.m_dwDefaultFontColor = 0xFF000000;
			m_SharedResInfo.m_dwDefaultLinkFontColor = 0xFF0000FF;
			m_SharedResInfo.m_dwDefaultLinkHoverFontColor = 0xFFD3215F;
			m_SharedResInfo.m_dwDefaultSelectedBkColor = 0xFFBAE4FF;

			LOGFONT lf = { 0 };
			::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
			lf.lfCharSet = DEFAULT_CHARSET;
			HFONT hDefaultFont = ::CreateFontIndirect(&lf);
			m_SharedResInfo.m_DefaultFontInfo.hFont = hDefaultFont;
			m_SharedResInfo.m_DefaultFontInfo.sFontName = lf.lfFaceName;
			m_SharedResInfo.m_DefaultFontInfo.iSize = -lf.lfHeight;
			m_SharedResInfo.m_DefaultFontInfo.bBold = (lf.lfWeight >= FW_BOLD);
			m_SharedResInfo.m_DefaultFontInfo.bUnderline = (lf.lfUnderline == TRUE);
			m_SharedResInfo.m_DefaultFontInfo.bItalic = (lf.lfItalic == TRUE);
			::ZeroMemory(&m_SharedResInfo.m_DefaultFontInfo.tm, sizeof(m_SharedResInfo.m_DefaultFontInfo.tm));
		}

		m_ResInfo.m_dwDefaultDisabledColor = m_SharedResInfo.m_dwDefaultDisabledColor;
		m_ResInfo.m_dwDefaultFontColor = m_SharedResInfo.m_dwDefaultFontColor;
		m_ResInfo.m_dwDefaultLinkFontColor = m_SharedResInfo.m_dwDefaultLinkFontColor;
		m_ResInfo.m_dwDefaultLinkHoverFontColor = m_SharedResInfo.m_dwDefaultLinkHoverFontColor;
		m_ResInfo.m_dwDefaultSelectedBkColor = m_SharedResInfo.m_dwDefaultSelectedBkColor;

		if (m_hUpdateRectPen == NULL)
		{
			m_hUpdateRectPen = ::CreatePen(PS_SOLID, 1, RGB(220, 0, 0));
			// Boot Windows Common Controls (for the ToolTip control)
			::InitCommonControls();
			::LoadLibrary(_T("msimg32.dll"));
		}

		m_szMinWindow.cx = 0;
		m_szMinWindow.cy = 0;
		m_szMaxWindow.cx = 0;
		m_szMaxWindow.cy = 0;
		m_szInitWindowSize.cx = 0;
		m_szInitWindowSize.cy = 0;
		m_szRoundCorner.cx = m_szRoundCorner.cy = 0;
		::ZeroMemory(&m_rcSizeBox, sizeof(m_rcSizeBox));
		::ZeroMemory(&m_rcCaption, sizeof(m_rcCaption));
		::ZeroMemory(&m_rcLayeredInset, sizeof(m_rcLayeredInset));
		::ZeroMemory(&m_rcLayeredUpdate, sizeof(m_rcLayeredUpdate));
		m_ptLastMousePos.x = m_ptLastMousePos.y = -1;

		m_pGdiplusStartupInput = new Gdiplus::GdiplusStartupInput;
		Gdiplus::GdiplusStartup(&m_gdiplusToken, m_pGdiplusStartupInput, NULL); // 加载GDI接口

		CShadowUI::Initialize(m_hInstance);

		m_pDragDrop = NULL;
	}

	CPaintManagerUI::~CPaintManagerUI()
	{
		// Delete the control-tree structures
		for (int i = 0; i < m_aDelayedCleanup.GetSize(); i++) delete static_cast<CControlUI*>(m_aDelayedCleanup[i]);
		m_aDelayedCleanup.Resize(0);
		for (int i = 0; i < m_aAsyncNotify.GetSize(); i++) delete static_cast<TNotifyUI*>(m_aAsyncNotify[i]);
		m_aAsyncNotify.Resize(0);

		m_mNameHash.Resize(0);
		if (m_pRoot != NULL) delete m_pRoot;

		::DeleteObject(m_ResInfo.m_DefaultFontInfo.hFont);
		RemoveAllFonts();
		RemoveAllImages();
		RemoveAllStyle();
		RemoveAllDefaultAttributeList();
		RemoveAllWindowCustomAttribute();
		RemoveAllOptionGroups();
		RemoveAllTimers();
		RemoveAllDrawInfos();

		if (m_hwndTooltip != NULL)
		{
			::DestroyWindow(m_hwndTooltip);
			m_hwndTooltip = NULL;
		}
		if (!m_aFonts.IsEmpty())
		{
			for (int i = 0; i < m_aFonts.GetSize(); ++i)
			{
				HANDLE handle = static_cast<HANDLE>(m_aFonts.GetAt(i));
				::RemoveFontMemResourceEx(handle);
			}
		}
		if (m_hDcOffscreen != NULL) ::DeleteDC(m_hDcOffscreen);
		if (m_hDcBackground != NULL) ::DeleteDC(m_hDcBackground);
		if (m_hbmpOffscreen != NULL) ::DeleteObject(m_hbmpOffscreen);
		if (m_hbmpBackground != NULL) ::DeleteObject(m_hbmpBackground);
		if (m_hDcPaint != NULL) ::ReleaseDC(m_hWndPaint, m_hDcPaint);
		m_aPreMessages.Remove(m_aPreMessages.Find(this));
		// 销毁拖拽图片
		if (m_hDragBitmap != NULL) ::DeleteObject(m_hDragBitmap);
		//卸载GDIPlus
		Gdiplus::GdiplusShutdown(m_gdiplusToken);
		delete m_pGdiplusStartupInput;
		// DPI管理对象
		if (m_pDPI != NULL)
		{
			delete m_pDPI;
			m_pDPI = NULL;
		}
	}

	void CPaintManagerUI::Init(HWND hWnd, LPCTSTR pstrName)
	{
		ASSERT(::IsWindow(hWnd));

		m_mNameHash.Resize();
		RemoveAllFonts();
		RemoveAllImages();
		RemoveAllStyle();
		RemoveAllDefaultAttributeList();
		RemoveAllWindowCustomAttribute();
		RemoveAllOptionGroups();
		RemoveAllTimers();

		m_sName.Empty();
		if (pstrName != NULL) m_sName = pstrName;

		if (m_hWndPaint != hWnd)
		{
			m_hWndPaint = hWnd;
			m_hDcPaint = ::GetDC(hWnd);
			m_aPreMessages.Add(this);

		// 触屏兼容：每个窗口（主窗口 + 所有弹框）统一注册 WM_TOUCH，由本类库级接管，
		// 无需 CTouchWindowBase 外挂，也无需逐窗口样板。注册是幂等的，重复调用无害。
		InitTouchSupport();
		}
	}

	// ---------------------------------------------------------------------------
	// 真模态（DialogBox）支持：manager 的 paint window 迁移。
	// 详见 UIManager.h 里的说明。这两个方法**不**触碰任何资源状态，只换窗口绑定。
	// ---------------------------------------------------------------------------
	void CPaintManagerUI::DetachPaintWindow()
	{
		if (m_hDcPaint != NULL)
		{
			::ReleaseDC(m_hWndPaint, m_hDcPaint);
			m_hDcPaint = NULL;
		}
		const int nIndex = m_aPreMessages.Find(this);
		if (nIndex >= 0) m_aPreMessages.Remove(nIndex);
		DuiLibDiag::Log(_T("MANAGER-DETACH manager=%p from hwnd=%p"), (void*)this, (void*)m_hWndPaint);
		// 注意：m_hWndPaint 暂不置空 —— AttachPaintWindow 会覆盖它。
		// 也不要清空控件树 / 字体 / 图片：那些是"内容"，迁移后要继续用。
	}

	void CPaintManagerUI::AttachPaintWindow(HWND hWnd)
	{
		ASSERT(::IsWindow(hWnd));
		if (hWnd == NULL || !::IsWindow(hWnd)) return;

		// ------------------------------------------------------------------
		// ⚠️⚠️ 【必须在这里清掉跨窗口残留的输入状态】—— 真机 bug 根治点 ⚠️⚠️
		//
		// 背景：真模态把**同一个** manager 从旧窗口 Detach、再 Attach 到弹框
		//   （见 UIBase.cpp 的 ShowModal / __DialogProc）。
		//   而 AttachDialog()（非模态路径）在挂控件树前会显式清掉一组输入状态：
		//       SetFocus(NULL); m_pEventKey=NULL; m_pEventHover=NULL;
		//       m_pEventClick=NULL; m_pEventRClick=NULL;
		//   这两个函数职责相同（都是"把 manager 挂到一个窗口/控件树上"），
		//   **但本函数当初漏了同一组清理**。迁移时这些指针和标记就原样"住进"了弹框。
		//
		// 由此产生两个真机现象：
		//   ① 「商品控件的悬浮态要等弹框关闭才消失」——
		//      m_pEventHover 仍指着主窗口那个商品控件（控件树是同一棵，没有被换掉），
		//      而弹框期间触摸消息都发往弹框，主窗口那条 HOT 就再也没人去清。
		//   ② 「弹框刚出来就被同一次手势自动点掉 / 咚一声」——
		//      m_pEventClick、m_bMouseCapture 等属于"上一次手势"的中间态被带进弹框，
		//      弹框的第一条输入消息就撞上一个"正在进行中的手势"，状态机接续错误。
		//
		// 修法：迁移时把**属于旧窗口的输入状态**全部归零，让弹框从干净状态起步。
		//   ⚠️ 只清"输入态"，绝不动控件树 / 字体 / 图片 —— 那些是"内容"，要继续用
		//      （与 DetachPaintWindow 的注释保持同一原则）。
		//   ⚠️ 这里不清 m_bSuppressPromotedTouchMouse / m_dwSuppressTick ——
		//      它们正是用来"吞掉本次手势残留的提升鼠标消息"的，清了反而会让
		//      Win7 的咚声与自动点弹框回来（见 MessageHandler 的拦截块）。
		// ------------------------------------------------------------------
		// 先把悬浮态正式收掉（发 MOUSELEAVE 给旧控件，让 HOT 立即熄灭），
		// 而不是只把指针置空 —— 只置空的话控件的 UISTATE_HOT 会留在被点亮的颜色上。
		{
			POINT ptDummy = { -1, -1 };
			ClearTouchHoverState(ptDummy);
		}
		// [顺序修复] 这里**不再**遍历全树清"按下态"。
		//
		// 为什么不在这里清：
		//   模态搬家（DetachPaintWindow → DestroyWindow(旧窗口) → AttachPaintWindow）
		//   发生在**业务回调内部**（ShowModal）。而用户报的"点击的商品按压态不消失"
		//   必须在**业务回调之前**就收掉 —— 一旦进到这里，弹框已经建好了，
		//   卡片还顶着 "pressed" 的那一帧已经画出去了。
		//   ⇒ 正确的时点是触摸链放行业务回调之前（CPaintManagerUI::TouchUp）。
		//
		// 保持现状的代价：搬家时旧窗口的输入态不再被兜底清掉。这是**有意的**——
		//   触摸链、鼠标路径各自都会在"抬起"时把自己的状态收干净；搬家再清一遍
		//   属于事后补救，而事后补救正是前面几轮"清得太晚"的病根（见 TouchUp 的注释）。

		m_pEventKey = NULL;
		m_pEventClick = NULL;
		m_pEventRClick = NULL;
		// 旧窗口上若还留着鼠标捕获 / 拖拽模式，这里一并释放：
		// 捕获属于旧 HWND，跟着 manager 搬到新窗口毫无意义，只会让新窗口误判"正在捕获"。
		if (m_bMouseCapture || m_bDragMode)
			ReleaseCapture();
		m_bMouseTracking = false;
		s_bSuppressHoverAfterTouch = true;

		m_hWndPaint = hWnd;
		m_hDcPaint = ::GetDC(hWnd);
		// 重新加入全局表（Detach 时摘除过）。若之前没摘（异常路径），避免重复添加。
		if (m_aPreMessages.Find(this) < 0) m_aPreMessages.Add(this);

		// 新窗口必须注册触摸，否则收不到 WM_TOUCH。
		InitTouchSupport();

		DuiLibDiag::Log(_T("MANAGER-ATTACH manager=%p to hwnd=%p dc=%p (input-state reset)"),
			(void*)this, (void*)m_hWndPaint, (void*)m_hDcPaint);
	}

	// ---------------------------------------------------------------------------
	// 触摸 API 懒加载包装（对标 NIM Duilib 的 RegisterTouchWindowWrapper 系列）。
	//
	// 为什么不能直接调用这些 API：DuiLib 工程自身没有定义 _WIN32_WINNT，
	// StdAfx.h 会把它兜底设成 XP(0x0501)；而 TOUCHINPUT / GetTouchInputInfo /
	// RegisterTouchWindow 在 winuser.h 里受 `#if _WIN32_WINNT >= 0x0601` 保护，
	// 直接引用会编译报错（C2065/C3861）。（主工程定义了 0x0601，所以
	// CTouchWindowBase 里能直接用，那里不受影响。）
	//
	// 因此这里完全自给自足：自行声明与 SDK 完全一致的 TOUCHINPUT 布局和事件标志，
	// 再用 GetProcAddress 取函数地址。这样：
	//   * 无论 DuiLib 的 target 版本如何都能编译通过；
	//   * 在没有触摸 API 的系统上自动降级为空操作，不会崩溃。
	// ---------------------------------------------------------------------------
	namespace TouchApi
	{
		// 与 winuser.h 的 tagTOUCHINPUT 布局逐字段一致
		typedef struct tagTouchInput
		{
			LONG      x;
			LONG      y;
			HANDLE    hSource;
			DWORD     dwID;
			DWORD     dwFlags;
			DWORD     dwMask;
			DWORD     dwTime;
			ULONG_PTR dwExtraInfo;
			DWORD     cxContact;
			DWORD     cyContact;
		} TOUCHINPUT, *PTOUCHINPUT;

		// 事件标志，数值与 winuser.h 的触摸事件标志一致。
		// 名字必须避开 SDK 的同名宏：部分 SDK 把它们定义成【宏】，且不受 _WIN32_WINNT 版本段保护，
		// 同名会被预处理器展开——声明变成 `const DWORD 0x0002 = 0x0002;`（C2059），
		// 限定使用变成 `TouchApi::0x0004`（C2589）。故改用 TOUCHEVTFLAG 前缀。
		const DWORD TOUCHEVTFLAG_MOVE = 0x0001;
		const DWORD TOUCHEVTFLAG_DOWN = 0x0002;
		const DWORD TOUCHEVTFLAG_UP   = 0x0004;

		typedef BOOL (WINAPI *PFN_RegisterTouchWindow)(HWND, ULONG);
		typedef BOOL (WINAPI *PFN_GetTouchInputInfo)(HANDLE, UINT, PTOUCHINPUT, int);
		typedef BOOL (WINAPI *PFN_CloseTouchInputHandle)(HANDLE);

		inline HMODULE GetUser32()
		{
			static HMODULE s_hMod = NULL;
			static bool s_bInited = false;
			if (!s_bInited)
			{
				s_bInited = true;
				s_hMod = ::GetModuleHandle(_T("user32.dll"));
			}
			return s_hMod;
		}

		inline PFN_RegisterTouchWindow GetRegisterTouchWindow()
		{
			static PFN_RegisterTouchWindow s_pfn = NULL;
			static bool s_bInited = false;
			if (!s_bInited)
			{
				s_bInited = true;
				HMODULE hMod = GetUser32();
				if (hMod != NULL) s_pfn = (PFN_RegisterTouchWindow)::GetProcAddress(hMod, "RegisterTouchWindow");
			}
			return s_pfn;
		}

		inline PFN_GetTouchInputInfo GetGetTouchInputInfo()
		{
			static PFN_GetTouchInputInfo s_pfn = NULL;
			static bool s_bInited = false;
			if (!s_bInited)
			{
				s_bInited = true;
				HMODULE hMod = GetUser32();
				if (hMod != NULL) s_pfn = (PFN_GetTouchInputInfo)::GetProcAddress(hMod, "GetTouchInputInfo");
			}
			return s_pfn;
		}

		inline PFN_CloseTouchInputHandle GetCloseTouchInputHandle()
		{
			static PFN_CloseTouchInputHandle s_pfn = NULL;
			static bool s_bInited = false;
			if (!s_bInited)
			{
				s_bInited = true;
				HMODULE hMod = GetUser32();
				if (hMod != NULL) s_pfn = (PFN_CloseTouchInputHandle)::GetProcAddress(hMod, "CloseTouchInputHandle");
			}
			return s_pfn;
		}
	}

	// ---------------------------------------------------------------------------
	// [触屏] 手指容差（滚动条专治）
	// 滚动条默认仅 16px 宽（CScrollBarUI::DEFAULT_SCROLLBAR_SIZE），指尖按偏 5~10px 就落到
	// 右侧内容上：内容会跟手滚动，但“滑块拖不动”——用户感知就是“滚动条没法在触屏上滑动”。
	// 两个措施：①把触点横向收进滚动条 rect，再交给滚动条自己判滑块；②若直接命中的不是
	// 滚动条，但触点容差范围内正好压在某个滚动条的滑块上，则改判为命中该滚动条。
	// ---------------------------------------------------------------------------
	// ======================================================================
	// ★★【透传根治 · 全局代数（generation）】★★
	//
	// ⚠️⚠️ 为什么必须是**文件级全局**，不能是 CPaintManagerUI 的成员 ⚠️⚠️
	//
	// 第一版写成了 manager 的成员，真机日志一验就废 —— 因为
	// **弹框和主窗口是两个不同的 manager**（本项目属性弹框 CDiandanNatureWnd
	// 自带独立的 `CPaintManagerUI m_pm`）。真机日志铁证：
	//     MODAL-BEEP arm manager=0DCE0960 ...        <- ShowModal 动的是弹框的 manager
	//     MANAGER-MSG hwnd=00D20604 manager=05796840 <- 泄漏消息落在主窗口 manager
	// 两个句柄完全不同 ⇒ 在弹框 manager 上 +gen，主窗口那份根本不知道，
	// 水位永远持平 ⇒ 拦不住。
	//
	// 而"泄漏"本质是**线程消息队列**的现象：同一次触摸提升出的一对鼠标消息
	// 排在**同一个 UI 线程**的队列里，谁被 ShowModal 阻塞、谁后到，与
	// manager 的归属无关。⇒ 代数必须是线程级的。
	//   （本项目 UI 单线程；若将来改成多线程，把这三个 static 换成 TLS 即可。）
	//
	// 语义：g_nPromotedMouseGeneration 在"进入模态循环之前" +1（由 ShowModal 调用）。
	//   此后任何 IsPromotedTouchMouseMessage() 为真、且其"已见水位"
	//   (g_nSeenPromotedMouseGeneration) 落后于当前值的消息，都产生于模态
	//   边界**之前** ⇒ 一律作废（它就是透传的那条）。
	//
	// 对外只暴露两个函数（声明在 UIBase.h）：
	//   BumpPromotedMouseGenerationGlobal() —— ShowModal 进入循环前 +1
	//   PeekPromotedMouseGeneration()       —— 日志用
	// 内部消费逻辑（Consume/Settle）留在匿名 namespace，只给本文件的
	// MessageHandler 用。
	// ======================================================================
	static UINT s_nPromotedMouseGeneration = 0;      // 当前代数
	static UINT s_nSeenPromotedMouseGeneration = 0;  // 上次处理点击类消息时的水位
	static bool s_bPromotedMouseGenTainted = false;  // 本代已作废（配对消息一并丢）

	// ★★【第四版新增 · 残留序列的"手势指纹"】★★
	//
	// 真机日志证明：**同一次手势被系统提升出来的那几条鼠标消息，extra 完全相同**
	// （三件套 MOVE/DOWN/UP 都是 0xFF515786；下一次手势变成 0xFF515787）。
	// 而 extra 的低 7 位就是"触摸标识/光标 ID"，每次手势都变 ⇒ 天然是一次性的序列号。
	//
	// 用它做什么：**精确定义"这条消息是不是残留序列的一员"**。
	//   · 跨代时记下这条消息的 extra 作为"残留指纹"；
	//   · 之后凡是 extra == 该指纹的提升消息，一律按残留处理（点击类吞掉）；
	//   · extra != 指纹 ⇒ 是**新的**一次手势 ⇒ 立刻关窗（不需要等 UP 收尾）。
	//
	// 这解决了第三版唯一的遗留缺陷：若残留序列的 UP 被系统丢弃（或落在别的窗口上），
	// 光靠"等 UP 关窗"会让窗口一直开着，把下一次真实触摸点击误吞。
	// 有了指纹，下一次手势的 extra 必然不同 ⇒ 第一次到达就自动关窗。
	static DWORD_PTR s_dwPromotedMouseTaintExtra = 0;  // 残留序列的 extra 指纹
	static bool    s_bPromotedMouseTaintExtraSet = false;

	void BumpPromotedMouseGenerationGlobal()
	{
		++s_nPromotedMouseGeneration;
		s_bPromotedMouseGenTainted = false;
		s_bPromotedMouseTaintExtraSet = false;
		s_dwPromotedMouseTaintExtra = 0;
	}

	UINT PeekPromotedMouseGeneration()
	{
		return s_nPromotedMouseGeneration;
	}

	// ======================================================================
	// ★★【第二次合成点击 · 根治】"触摸通道处理过的这次手势，其提升鼠标副本一律作废" ★★
	// ======================================================================
	//
	// 【背景：一次手势会被处理两遍】
	//   手指点一下，DuiLib 会经历两遍：
	//     ① 触摸通道（WM_TOUCH / WM_POINTER*）合成 BUTTONDOWN/BUTTONUP —— 业务的
	//        点击回调在这里跑，`ShowModal()` 的嵌套模态循环也在这里开；
	//     ② Windows 随后把**同一次触摸**提升成鼠标消息（MOVE + LBUTTONDOWN +
	//        LBUTTONUP，extra 带 MOUSEEVENTF_FROMTOUCH）。它是纯重复，必须作废。
	//
	// 【为什么 ② 一定还会来，但 ② 投给谁却会变】
	//   ② 投给谁取决于**投递那一刻**的窗口状态，与 ① 时刻可能完全不同：
	//     · 该点此刻已被弹框覆盖 ⇒ 投给**弹框**（前台且启用）⇒ 窗口过程收得到，能拦；
	//     · 该点此刻仍在 owner 上 ⇒ 投给**被禁用的 owner** ⇒ 系统直接
	//       MessageBeep(0) + 丢弃 ⇒ **窗口过程根本收不到**（真机日志实证：该坐标
	//       附近 0 条提升消息）⇒ 这就是 Win7 上"弹框一出来就咚一声"的全部成因。
	//
	// 【旧判据为什么在 Win7 上必然漏】（真机日志 touch_trace.log，2451 行 / 25 次手势）
	//   · "代数水位"：水位在**任意一条**提升消息到达时就追平。于是"点『选好了』
	//     关闭弹框"这一次手势的副本到达时，脏已被前一次手势用掉 ⇒ 无脏可判 ⇒
	//     **放行** ⇒ 透传到背后商品卡 ⇒ 弹框被重新点开。25 次里漏了 6 次，
	//     全部是"关闭弹框的那一次手势"。
	//   · "extra 指纹"：Win7 上 extra **恒为 0xFF51578A**（日志中 59/59 条完全
	//     相同），指纹去重彻底失效 —— `close-by-extra` 一次都没触发。
	//     （Win10 那边 extra 低字节每次手势都变，所以同一套方案在 Win10 上
	//      "看起来是对的"。这正是"Win10 好了、Win7 没好"的分界。）
	//
	// 【新判据：只依赖一件事实 —— 触摸通道收到了这次手势】
	//   收到了 ⇒ 提升副本必是重复 ⇒ 作废。与模态边界、代数、extra 全都无关，
	//   因此对"关闭弹框的那一次手势"同样有效（那正是旧判据唯一漏掉的一类）。
	//
	//   ⚠️ 标志**只由触摸通道**置位（BeginTouchSlideGesture —— 两条通道共用的
	//       "新手势开始"入口）。若某台机器两条通道都收不到（只会收到提升鼠标），
	//      标志恒假 ⇒ 提升鼠标照常放行 ⇒ **不会把整机点不动**。
	//      这条自限边界是本方案敢用的前提，务必保留。
	//
	// 【为什么还要比坐标】
	//   若某次手势的提升副本被系统吃掉（上面那种"咚"的情况），标志会一直挂着。
	//   此时若出现"触摸通道收不到、只能靠提升鼠标"的窗口（例如弹框的触摸注册
	//   被样式变更隐式注销），不加坐标判据就会把它的真实点击一起吞掉 ⇒ 点不动。
	//   加上 ±16px（与滑动阈值同一量级）判据后，陈旧标志不会误伤无关位置的点击。
	//   坐标一律换算到**屏幕坐标**再比 —— ② 可能落在**另一个窗口的客户区**里
	//   （弹框会拦截同一物理点的消息，lParam 是弹框的客户区坐标）。
	// ======================================================================
	static bool  s_bPromotedMouseDuplicate = false;      // 有"待作废的提升副本"
	static POINT s_ptPromotedMouseDuplicate = { 0, 0 };  // 那次手势的**屏幕**坐标
	static const int kPromotedDuplicateSlop = 16;        // 手指抖动容差（像素）

	// 三者都只在本文件内使用 ⇒ 一律 static（内部链接），避免与别的 TU 里的
	// 同名符号在 DuiLib 命名空间里撞车（C2668 的典型成因）。
	static void ArmPromotedMouseDuplicate(const POINT& ptScreen)
	{
		s_bPromotedMouseDuplicate = true;
		s_ptPromotedMouseDuplicate = ptScreen;
	}

	static void DisarmPromotedMouseDuplicate()
	{
		s_bPromotedMouseDuplicate = false;
	}

	// 本条提升鼠标消息是否属于"待作废的那次手势副本"。
	// 参数 ptClient 是消息 lParam 里的**接收窗口客户区**坐标。
	static bool IsPromotedMouseDuplicate(HWND hWndPaint, const POINT& ptClient)
	{
		if (!s_bPromotedMouseDuplicate) return false;
		POINT ptScreen = ptClient;
		if (hWndPaint != NULL && ::IsWindow(hWndPaint))
			::ClientToScreen(hWndPaint, &ptScreen);
		const LONG dx = ptScreen.x - s_ptPromotedMouseDuplicate.x;
		const LONG dy = ptScreen.y - s_ptPromotedMouseDuplicate.y;
		return (dx <= kPromotedDuplicateSlop && dx >= -kPromotedDuplicateSlop
			&& dy <= kPromotedDuplicateSlop && dy >= -kPromotedDuplicateSlop);
	}
	// ======================================================================
	// ★★【Win7"咚"声 · 根治】进模态循环之前，把"在途的提升鼠标副本"从消息队列里摘掉 ★★
	//
	// 【现象】
	//   Win7 上"点主窗口商品卡 → 弹出弹框"时会听到一声"咚"。它是**系统**发出的
	//   `MessageBeep(0)`：属于**弹框出现之前**那一次手势的提升鼠标副本，在弹框已经把
	//   owner `EnableWindow(FALSE)` 禁用之后才被投递 ⇒ 撞上"点击禁用窗口"的默认处理。
	//
	// 【已经逐条排除的方向（都有真机日志支撑，不要再回头走）】
	//   · 写在窗口过程里的闸门（MODAL-BEEP / PROMOTED-DUP）：`swallowed` 恒为 0 ——
	//     消息**根本没进窗口过程**，判据再准也无从生效。
	//   · WH_MOUSE_LL 低级鼠标钩子：钩子过程运行在**安装它的线程**（正是消息接收线程）
	//     上，队列里的鼠标消息先于钩子被抽出 ⇒ 真机日志里提升副本照旧投递，一条没少。
	//   · 让 owner 在"副本在途"期间保持启用（能消音，但不可接受）：owner 的鼠标消息
	//     会因此落到 manager 上，而真模态期间 manager 已经搬到弹框
	//     （DetachPaintWindow → AttachPaintWindow）⇒ 此时 `m_hWndPaint` 指向**弹框**，
	//     owner 的客户区坐标会被拿去**弹框的控件树**里 FindControl，可能凭空命中
	//     弹框上的某个控件。
	//
	// 【根治点：让它根本不存在】
	//   既然拦不住"投递阶段"的系统行为，就在**投递之前**把它从队列里摘掉。
	//   调用点在 `CWindowWnd::ShowModal` 进模态循环之前（见那里的长注释）。
	//   为什么那个时刻一定赶得上：这条副本是在**同一次触摸**的输入处理里被排进队列的，
	//   而调用方的触摸 UP 此刻**已经被处理完**（业务回调就是正在执行的这段代码）
	//   ⇒ 副本必然已经在队列里（真机日志亦实证：它被卡在队列里，直到弹框关闭、
	//   owner 重新启用之后才被投递）。而"摘除"与"创建弹框"之间没有任何消息泵
	//   ⇒ 摘除对投递而言是**原子**的。
	//
	// 【为什么不会误伤】
	//   · 判据只有一件事：触摸通道确实收到了这次手势
	//     （IsPromotedMouseDuplicatePending —— 与 PROMOTED-DUP 同源、同一处置位），
	//     与模态边界 / 代数水位 / extra 指纹全都无关。
	//   · 摘除范围只限"**owner 窗口**的鼠标类消息"，且只在这一个瞬间摘一次。
	//   · 被摘掉的本来就是**重复**的：这次点击已经由触摸通道的 tap 判定处理完毕
	//     （否则根本不会走到 ShowModal 这里）。
	//
	// 【用户的两条边界同时守住】
	//   · 场景①【从主窗口控件点出弹框 ⇒ 咚 必须消除】：触摸通道收到了手势 ⇒ 副本在
	//     队列里 ⇒ 摘掉 ⇒ **无声**。
	//   · 场景②【弹框已打开后，点弹框外空白区 ⇒ 咚 属正常，用户明确要求不改】：
	//     那一处属于被禁用的 owner，它的 WM_TOUCH 在**输入阶段**就被系统丢弃
	//     ⇒ BeginTouchSlideGesture 不会被调用 ⇒ 标志为假 ⇒ 不摘 ⇒ 那一声"咚"照旧。
	//
	// 【自限】
	//   若某台机器压根不产生提升副本（本项目 Win10 走 WM_POINTER*，fromtouch 消息 0 条），
	//   标志恒假 ⇒ 本机制**从不启用** ⇒ 零影响。
	// ======================================================================

	// 【同源访问器】把"提升副本在途"这一事实暴露给 UIBase.cpp（摘除的时机在那边）。
	bool CPaintManagerUI::IsPromotedMouseDuplicatePending()
	{
		return s_bPromotedMouseDuplicate;
	}

	// ★把"本次手势在途的提升鼠标副本"从本线程消息队列里就地摘掉，返回摘掉的条数。
	// 调用点：CWindowWnd::ShowModal 进模态循环之前（那里的长注释解释了为什么必须摘）。
	//
	// ⚠️ 这里**故意不销账**（不调 DisarmPromotedMouseDuplicate）：
	//   标志继续挂着，PROMOTED-DUP 那道闸门对"稍后才到的提升副本"仍然有效 ——
	//   摘除动作只是把"已经排在队列里的那些"提前清掉，不该顺带削弱仍在生效的保护。
	//   陈旧标志本身不会误伤：IsPromotedMouseDuplicate() 还要比屏幕坐标（±16px）。
	int CPaintManagerUI::DropQueuedPromotedMouseMessages(HWND hWndTarget)
	{
		if (hWndTarget == NULL || !::IsWindow(hWndTarget)) return 0;

		int nDropped = 0;
		MSG msg;
		// 范围 WM_MOUSEFIRST..WM_MOUSELAST 覆盖 MOVE / 左中右键 DOWN-UP-DBLCLK /
		// WHEEL / XBUTTON 全族 —— 提升副本只在其中。
		// 只摘"投给该窗口"的（弹框出现之前那次手势的副本，其归属窗口必然是这个 owner：
		// 消息的归属在**投递那一刻**才按"光标下的窗口"结算，而那时弹框还不存在）。
		while (::PeekMessage(&msg, hWndTarget, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE))
			++nDropped;

		return nDropped;
	}

	// 【悬浮态残留 · 跨窗口参考点】把"本窗口客户区点"记成**屏幕**坐标后，写进
	// **线程级**参考点 `s_ptLastTouchScreen`（见文件头那一大段说明：这套状态不能是
	// manager 成员，因为补投的 MOVE 会落在另一个 manager 上）。
	// 用屏幕坐标的原因：抑制"抬起后悬浮态复活"的 ±8px 判据必须用与窗口无关的坐标系，
	// 否则窗口一换（尤其弹框销毁、消息改投主窗口）判据就会失准。
	// 调用约定：凡写 `m_ptLastTouchPos` 的**触摸**路径，都应同步调一次本函数。
	void CPaintManagerUI::SetLastTouchScreenPoint(POINT ptClient)
	{
		POINT ptScreen = ptClient;
		if (m_hWndPaint != NULL && ::IsWindow(m_hWndPaint))
			::ClientToScreen(m_hWndPaint, &ptScreen);
		s_ptLastTouchScreen = ptScreen;
	}

	namespace
	{
		const int kScrollBarTouchSlop = 12;   // 手指离滚动条 rect 的最大容差（像素）

		// 本条提升鼠标消息是否"跨代"（产生于模态边界之前）。
		//
		// ================== 第三版（真机验证后重写）==================
		//
		// 前两版都错了，错法不同，记录在此避免回退：
		//
		// 【第一版】"只要跨代就置脏" ⇒ 能拦住真机那条链路，但留了一个理论风险：
		//   跨代 MOVE 置脏后，若与真正那条跨代 DOWN 之间夹一次真实鼠标点击，
		//   Settle 会把脏解掉 ⇒ DOWN 漏网。
		//
		// 【第二版】"只有点击类才置脏、MOVE 只补水位" ⇒ **真机实测直接失效**。
		//   因为真机的残留不是"一对"，而是**三件套**（extra 完全相同）：
		//       WM_MOUSEMOVE   ← ① 最先到，跨代（本条！）
		//       WM_LBUTTONDOWN ← ② 紧随
		//       WM_LBUTTONUP   ← ③
		//   ① 跨代把水位补上了且不置脏 ⇒ ② 到达时"代数不落后"且"脏为假"
		//   ⇒ **完全放行 ⇒ 透传**。真机日志铁证（272274640 那次）：
		//       PROMOTED-GEN cross msg=0x0200 gen=1 click=0     ← MOVE 跨代，未置脏
		//       （没有任何 swallow 行）
		//       LBUTTONDOWN hit name=diandan_fooditem          ← 透传发生
		//   教训：**不能靠"配对里有几条消息"来设计**——系统给几条是它的事，
		//   判据必须对"条数"免疫。
		//
		// 【第三版 · 现在】把语义从"代数落后"改成**"作废窗口"**，
		//   对消息条数完全免疫：
		//     · 只要出现**任意一条跨代**的提升鼠标消息（MOVE 也算）⇒ 打开作废窗口；
		//     · 窗口开着期间，**所有点击类**提升鼠标消息一律吞（MOVE 仍放行，
		//       因为 MOVE 不产生点击，且需要它维持重绘/光标）；
		//     · 窗口在"吞到一条抬起类消息（UP/DBLCLK）"后关闭 —— 这是纯状态收尾，
		//       不含时间。残留序列无论是一条、两条还是三条，最后必然以抬手结束。
		//     · 真实鼠标（非提升）的点击类消息到达 ⇒ 立即关窗（输入源已切换）。
		//
		//   为什么"跨代 MOVE 也开窗"不再有第一版那个风险：
		//     第一版的风险是"真实鼠标点击关窗"太容易触发（Settle 在 DOWN/UP 都调）。
		//     现在关窗条件收紧为**只认"吞到抬起"和"真实点击类消息"**，
		//     且真实鼠标在模态刚关闭的几十毫秒里不会产生 DOWN/UP
		//     （用户的手指还在屏幕上，系统的残留序列先走完）。
		//
		// 参数：bClickLike —— 本条是不是点击类（DOWN/UP/DBLCLK）。
		// 返回 true ⇒ 本条跨代（调用方据此打日志）。
		// 副作用：跨代即"开窗作废"（无论本条是移动还是点击），并记下 extra 指纹。
		bool ConsumeCrossModalPromotedMouse(bool bClickLike, DWORD_PTR dwExtra)
		{
			if (s_nPromotedMouseGeneration == s_nSeenPromotedMouseGeneration)
				return false;
			s_nSeenPromotedMouseGeneration = s_nPromotedMouseGeneration;
			// ★ 跨代 ⇒ 开窗作废。**移动也开**：移动是残留序列的第一条，
			//   它到场就说明"队列里还压着上一次手势"，必须连同后续点击一起作废。
			s_bPromotedMouseGenTainted = true;
			// 记下"这一次残留"的 extra 作为指纹（用于精确界定序列边界）。
			s_dwPromotedMouseTaintExtra = dwExtra;
			s_bPromotedMouseTaintExtraSet = true;
			return true;
		}

		// 本条提升消息是否属于**当前正在作废的那次残留序列**。
		// 判据：窗口开着 && extra 与指纹相同。
		//
		// 为什么加 extra 比对（第四版）：
		//   真机同一次手势的几条提升消息 extra 完全相同，不同手势必不相同。
		//   于是"extra 变了"就等价于"换了一次手势" ⇒ 可以立刻关窗，
		//   不必等 UP 收尾 ⇒ 就算 UP 丢失也不会误吞下一次点击。
		//
		// ⚠️ 指纹未记录时（理论上不会发生，因为开窗必然记指纹）退化为"只看窗口"。
		bool IsCurrentPromotedResidue(DWORD_PTR dwExtra)
		{
			if (!s_bPromotedMouseGenTainted)
				return false;
			if (!s_bPromotedMouseTaintExtraSet)
				return true;
			return s_dwPromotedMouseTaintExtra == dwExtra;
		}

		// 关窗：残留序列收尾，或输入源切换。
		//
		// ⚠️ 这里**同时清掉 extra 指纹**，否则下一条不同 extra 的消息
		//   还会走一次 close-by-extra 分支（无害，但会多打一条日志）。
		void ClearPromotedMouseGenTaint()
		{
			s_bPromotedMouseGenTainted = false;
			s_nSeenPromotedMouseGeneration = s_nPromotedMouseGeneration;
			s_bPromotedMouseTaintExtraSet = false;
			s_dwPromotedMouseTaintExtra = 0;
		}

		// 真实鼠标点击到达 ⇒ 输入源已切换，水位追上并解作废（纯状态，不看时间）。
		void SettlePromotedMouseGeneration()
		{
			ClearPromotedMouseGenTaint();
		}

	// Windows 会把“触摸提升（promoted）出来的合成鼠标消息”打上 MOUSEEVENTF_FROMTOUCH 标记
		// （位于 GetMessageExtraInfo() 的高位）。
		//
		// ★★【掩码错了整整几轮，这里是最关键的一处修正】★★
		//
		// 原判定是 `(extra & 0xFFFFFF80) == 0xFF515700` —— 取自文档里的示例值。
		// 但文档那个 0xFF515700 描述的是**掩码前的整体形状**，不是可与 0xFFFFFF80
		// 相与后的**精确结果**。真机实测（用户日志 touch_trace.log）：
		//     每一条提升消息的 extra 都是 0xFF515782 ~ 0xFF515785
		// 而 0xFF515782 & 0xFFFFFF80 = 0xFF515780 ≠ 0xFF515700
		// ⇒ 旧判定**恒为假**，所有依赖它的逻辑全是哑弹：
		//     · WM_MOUSEMOVE 里“触摸不参与悬浮态”那道闸门从未生效；
		//     · m_bSuppressPromotedMouseForModal 那套配对抑制从未生效；
		//     · 日志里 fromtouch=0 / promoted=0 恒为 0，与 extra 明明带标记自相矛盾。
		//
		// 低 7 位（& 0x7F）是**触摸标识位/光标 ID**，每次手势都会变，必须屏蔽掉；
		// 高 24 位才是稳定的 MOUSEEVENTF_FROMTOUCH 家族值。
		// ⇒ 正确判据：把高 24 位取出来，看是否落在 0xFF5157xx 这个族里。
		inline bool IsPromotedTouchMouseMessage()
		{
			return (DWORD)((DWORD_PTR)::GetMessageExtraInfo() & 0xFFFFFF00) == 0xFF515700;
		}

		// [模态提示音 / 重复点击] 判定 hWnd 是否是"当前模态输入链上的窗口"——
		// 即**模态弹框本身**，或**它的 owner**。
		//
		// 为什么必须同时包含这两个（第一版只判 owner，真机验证漏网）：
		//   · owner：被 DialogBoxIndirectParam 禁用 ⇒ 点它会被系统默认处理
		//     MessageBeep(0) ⇒ **咚**。
		//   · 弹框：手势残留的提升鼠标消息投递时机若晚于弹框创建，系统会按"当前"
		//     状态把它投给**弹框**（弹框已是前台且启用）。若手指原位置恰好压着弹框里
		//     某个按钮（用户实测：正好是"选好了"），就会**自动点击它**
		//     ⇒ **弹框刚出来就被同一次手势关掉**。
		//   两者都是"同一次触摸手势被处理了两遍"的第二次，都必须拦。
		inline bool IsModalInputTarget(HWND hWnd)
		{
			if (hWnd == NULL || !::IsWindow(hWnd)) return false;
			HWND hModal = CPaintManagerUI::GetModalWindow();
			if (hModal == NULL || !::IsWindow(hModal)) return false;
			if (hWnd == hModal) return true;                    // 弹框自身
			return (::GetWindow(hModal, GW_OWNER) == hWnd);      // 弹框的 owner
		}

		// -------------------------------------------------------------------
		// [触摸透传 · 根治] 判定 hWnd 是否是"模态弹框背后的背景窗口"。
		//
		// 与 IsModalInputTarget 是**互补**的两个方向：
		//   IsModalInputTarget(hWnd) == true  ⇒ hWnd 处于模态输入链上（弹框 / 弹框 owner）
		//   本函数(hWnd)            == true  ⇒ hWnd 是"弹框还开着时不该被碰的背景窗口"
		//
		// 为什么必须补这道闸（用户实测 bug：点弹框的「选好了」会透传到主窗口）：
		//
		//   本文件顶部（见 s_hModalWindow 那段注释）**早就写明**了要这么做 ——
		//     「只要当前有模态弹框，任何【非该弹框】的窗口收到 WM_TOUCH 一律忽略，
		//       避免"弹框还开着，手指却把主窗口点动了"的穿透。」
		//   但那段注释描述的闸门**从未被实现**（grep s_hModalWindow 只有 set/get，
		//   没有任何一处用它做过滤）。这就是透传能发生的原因。
		//
		//   缺了它之后的真实链路（Win10 触屏）：
		//     1) 手指点「选好了」→ 系统把 WM_POINTER\* 投给**主窗口**（本机实测：
		//        真模态下 owner 被禁用，部分系统会把触摸手势转投给 owner）；
		//     2) 主窗口的 manager 于是照常走 BeginTouchSlideGesture → TouchUp；
		//     3) `TouchUp` 里的"窗口归属 + 命中点"复核**挡不住**它 ——
		//        因为主窗口是**另一个 manager**，它的 m_pEventClick 是这次手势新记的
		//        （记的就是主窗口自己的命中控件），`GetManager() == this` 恒成立；
		//        而 `FindControl(pt)` 找的是主窗口自己的控件树，根本不知道
		//        屏幕上还盖着一层弹框 ⇒ 复核全过 ⇒ 点击被派发 ⇒ 透传。
		//     ⇒ 结论：**必须在入口就按"模态会话"过滤，事后的命中点复核无济于事。**
		//
		// 判定（四条件，全部为"状态"判据、无时间戳）：
		//   (a) 当前确实有活着的模态弹框；
		//   (b) 本窗口**不是**那个弹框本身；
		//   (c) 本窗口也不是**该弹框的 owner**（owner 同样是背景，被系统禁用，
		//       点它只会咚一声 + 透传，必须一起拦）；
		//   (d) 本窗口**不是那个弹框正在使用的 manager 窗口**（等价于弹框自己，
		//       必须放行 —— 否则把弹框自己也拦死，弹框彻底点不动）。
		//
		// ⚠️ 为什么 (c) 也要拦：真模态下 owner 被 `EnableWindow(FALSE)` 禁用，
		//   系统会把手势"转投"给它（这正是本机 Win10 的现象）。owner 上的 manager
		//   与主窗口是同一个对象，拦掉它 == 拦掉主窗口，语义正确。
		//
		// ⚠️⚠️ 为什么必须有 (d)（**这是"点选好了仍然透传"的直接原因**）⚠️⚠️
		//   真模态把**同一个 manager**从旧窗口搬到了弹框上（DetachPaintWindow →
		//   AttachPaintWindow）。于是既有可能出现"manager->m_hWndPaint == hModal"
		//   （正常），也有可能在某些时序下"弹框那个 HWND 收到了消息、但消息里带的
		//   窗口句柄不是 hModal"（例如 `::GetWindow(hModal, GW_OWNER)` 在弹框
		//   正在创建/销毁的瞬间返回了一个**陈旧或意外**的值）。
		//   一旦 (c) 被这种意外情况命中，就会把**弹框自己**判成背景窗口 ⇒
		//   弹框里的点击（比如"选好了"）被入口闸吞掉 ⇒ 用户看到"点了没反应"，
		//   随后的手势/提升消息又被主窗口接走 ⇒ 表现为**透传到背后的商品卡**。
		//   所以这里必须再补一道"manager 归属"判据做兜底：只要"当前收到消息的
		//   这个 manager"就是弹框自己的 manager，本窗口就绝不是背景窗口。
		//
		//   注意判据的取法：用 `FindManagerByPaintWindow(hWnd)` 这类**按句柄查
		//   manager** 的方式，而不是依赖 m_hWndPaint —— 因为闸门可能被非本 manager
		//   的调用路径复用。若查不到对应 manager（hWnd 不是任何被管理的绘制窗口），
		//   则退回 (b)(c) 的字面判定。
		// -------------------------------------------------------------------
		inline bool IsModalBackdropWindow(HWND hWnd)
		{
			if (hWnd == NULL || !::IsWindow(hWnd)) return false;
			HWND hModal = CPaintManagerUI::GetModalWindow();
			if (hModal == NULL || !::IsWindow(hModal)) return false;   // (a) 无模态 ⇒ 不是背景
			if (hWnd == hModal) return false;                          // (b) 它就是弹框 ⇒ 不是背景

			// (d) 本句柄是不是"弹框正在使用的那个 manager 窗口"？
			//     真模态下弹框自己也是被 manager 管理的绘制窗口，因此
			//     `FindManagerByPaintWindow(hModal) == FindManagerByPaintWindow(hWnd)`
			//     时二者同属一个 manager ⇒ hWnd 就是弹框窗口（或其别名），
			//     绝不能判成背景 —— 否则连弹框自己的点击都会被这道闸吞掉。
			CPaintManagerUI* pModalMgr = FindManagerByPaintWindow(hModal);
			if (pModalMgr != NULL && FindManagerByPaintWindow(hWnd) == pModalMgr)
				return false;

			if (::GetWindow(hModal, GW_OWNER) == hWnd) return true;    // (c) 它是弹框 owner ⇒ 是背景
			return false;
		}

		// -------------------------------------------------------------------
		// [触摸透传 · 诊断] 只在"有模态、但闸门判否"时打一条全量判据日志。
		//
		// 目的：一次真机运行就能区分两种失败形态 ——
		//   形态 1「闸门没进」：压根没有 MODAL-GATE-CHECK ⇒ 说明这类消息
		//                       走的是我们没挂闸的通道（或该窗口没收到消息）；
		//   形态 2「判据不满足」：打出 modal / owner / self 三个真实句柄，
		//                       直接看出是 (b) 还是 (c) 判错。
		//
		// ⚠️ 只在 `hModal != NULL` 时打 —— 普通（无模态）期间零开销、零噪音。
		// ⚠️ 这是临时诊断，透传闭环后应连同其它 TouchTrace 诊断一起删除。
		// -------------------------------------------------------------------
		inline void TraceModalGateCheck(HWND hWnd, const TCHAR* pszWhere)
		{
			if (hWnd == NULL || !::IsWindow(hWnd)) return;
			HWND hModal = CPaintManagerUI::GetModalWindow();
			if (hModal == NULL || !::IsWindow(hModal)) return;   // 无模态：沉默
			if (hWnd == hModal) return;                          // 弹框自己：沉默（正常）
			HWND hOwner = ::GetWindow(hModal, GW_OWNER);
			DuiLibDiag::Log(_T("MODAL-GATE-CHECK where=%s self=%p modal=%p ownerOfModal=%p selfIsOwner=%d"),
				pszWhere, (void*)hWnd, (void*)hModal, (void*)hOwner,
				(int)(hOwner == hWnd));
		}

		// 把触点收进滚动条自身 rect：垂直滚动条主要收敛 x（y 原样保留，纵向拖拽量完好）。
		inline POINT Touch_SnapIntoScrollBar(const CControlUI* pBar, POINT pt)
		{
			if (pBar == NULL) return pt;
			RECT rc = pBar->GetPos();
			if (pt.x < rc.left)   pt.x = rc.left;
			if (pt.x > rc.right)  pt.x = rc.right;
			if (pt.y < rc.top)    pt.y = rc.top;
			if (pt.y > rc.bottom) pt.y = rc.bottom;
			return pt;
		}

		// 沿“命中控件 → 祖先链”找最近的、满足容差条件的滚动条滑块；找不到返回 NULL。
		inline CControlUI* Touch_ResolveScrollBarThumb(CControlUI* pStart, POINT pt)
		{
			for (CControlUI* p = pStart; p != NULL; p = p->GetParent())
			{
				if (p->GetInterface(DUI_CTR_SCROLLBAR) != NULL) return NULL; // 本身已是滚动条，无需改判
				CContainerUI* pCont = static_cast<CContainerUI*>(p->GetInterface(DUI_CTR_CONTAINER));
				if (pCont == NULL) continue;
				CScrollBarUI* pBars[2] = { pCont->GetVerticalScrollBar(), pCont->GetHorizontalScrollBar() };
				for (int i = 0; i < 2; ++i)
				{
					if (pBars[i] != NULL && pBars[i]->IsThumbHit(pt, kScrollBarTouchSlop))
						return pBars[i];
				}
			}
			return NULL;
		}

		inline CScrollBarUI* Touch_FindScrollBar(CControlUI* pStart, POINT pt)
		{
			for (CControlUI* p = pStart; p != NULL; p = p->GetParent())
			{
				CContainerUI* pContainer = static_cast<CContainerUI*>(p->GetInterface(DUI_CTR_CONTAINER));
				if (pContainer == NULL) continue;

				CScrollBarUI* bars[2] = {
					pContainer->GetVerticalScrollBar(),
					pContainer->GetHorizontalScrollBar()
				};
				for (int i = 0; i < 2; ++i)
				{
					if (bars[i] == NULL || !bars[i]->IsVisible() || !bars[i]->IsEnabled())
						continue;
					RECT rc = bars[i]->GetPos();
					::InflateRect(&rc, kScrollBarTouchSlop, kScrollBarTouchSlop);
					if (::PtInRect(&rc, pt)) return bars[i];
				}
			}
			return NULL;
		}

		inline CContainerUI* Touch_FindScrollContainer(CControlUI* pStart)
		{
			for (CControlUI* p = pStart; p != NULL; p = p->GetParent())
			{
				CContainerUI* pContainer = static_cast<CContainerUI*>(p->GetInterface(DUI_CTR_CONTAINER));
				if (pContainer == NULL) continue;

				CScrollBarUI* pVertical = pContainer->GetVerticalScrollBar();
				CScrollBarUI* pHorizontal = pContainer->GetHorizontalScrollBar();
				if ((pVertical != NULL && pVertical->IsVisible() && pVertical->IsEnabled())
					|| (pHorizontal != NULL && pHorizontal->IsVisible() && pHorizontal->IsEnabled()))
					return pContainer;
			}
			return NULL;
		}
	}

	// ---------------------------------------------------------------------------
	// 当前模态弹框句柄（由 CWindowWnd::ShowModal 进入/退出时设置）。
	// Win8/10 指针栈下，触摸消息(WM_TOUCH / WM_POINTER)并不总是投递给"视觉上在最前面的弹框"：
	// 当弹框的 owner 被 EnableWindow(FALSE) 禁用时，部分系统会把手势转投给 owner。
	// 这里做一道保险：只要当前有模态弹框，任何【非该弹框】的窗口收到 WM_TOUCH 一律忽略，
	// 避免"弹框还开着，手指却把主窗口点动了"的穿透。
	// ---------------------------------------------------------------------------
	static HWND s_hModalWindow = NULL;

	void CPaintManagerUI::SetModalWindow(HWND hWnd)
	{
		s_hModalWindow = hWnd;
		DuiLibDiag::Log(_T("MODAL-WINDOW set hwnd=%p"), (void*)hWnd);
	}

	HWND CPaintManagerUI::GetModalWindow()
	{
		return s_hModalWindow;
	}

	void CPaintManagerUI::InitTouchSupport()
	{
		if (m_hWndPaint == NULL || !::IsWindow(m_hWndPaint)) return;

		TouchApi::PFN_RegisterTouchWindow pfnRegister = TouchApi::GetRegisterTouchWindow();
		BOOL bRegistered = FALSE;
		if (pfnRegister != NULL)
			bRegistered = pfnRegister(m_hWndPaint, 0);
		DuiLibDiag::Log(_T("REGISTER hwnd=%p manager=%p result=%d error=%u style=0x%08X ex=0x%08X"),
			(void*)m_hWndPaint, (void*)this, (int)bRegistered, bRegistered ? 0u : ::GetLastError(),
			(unsigned)::GetWindowLong(m_hWndPaint, GWL_STYLE),
			(unsigned)::GetWindowLong(m_hWndPaint, GWL_EXSTYLE));
	}

	// ===========================================================================
	// [通道无关的滑动状态机] Begin / Update / End
	//
	// 背景（这是本文件里最容易踩坑的一块，先把结论写在前面）：
	//   "滑动"这件事在本库里的实现只有一份 —— 派发 UIEVENT_TOUCHMOVE，由
	//     · CScrollBarUI 消费 → 拖滑块；
	//     · 否则冒泡到 CContainerUI → 1:1 跟手平移；
	//     · 谁都不认时 → 合成 UIEVENT_SCROLLWHEEL（Δy 累加满 120 一次）。
	//   过去这三个函数体是**内联写在 OnTouchInput（WM_TOUCH 通道）里的**。
	//
	//   问题：Win10 上同一次触摸会在两条互相独立的通道上都产生消息
	//   （WM_TOUCH 与 WM_POINTER*），而"谁驱动本次手势"是运行时决定的：
	//     · 主窗口常常是 WM_TOUCH 先到 → 老代码能滑；
	//     · 弹框 / 被指针抢走的手势 ⇒ 只有 WM_POINTER* →
	//       **整段滑动逻辑一条都没执行** ⇒ 「滑不动」；
	//       同时 UP 走指针 → 归一化成 WM_LBUTTONUP → 原生点击路径，
	//       而 tap/drag 判定所需的 m_bTouchMoved 从未被置真 ⇒「滑动反触发点击」。
	//
	//   修法：把滑动逻辑抽成不关心通道的这三个函数，两条通道都调用同一套。
	//   于是"谁驱动手势"不再影响"能不能滑"，只影响消息从哪儿来。
	//
	// 状态机的三个相位：
	//   Begin  : 命中控件 + 找可滚容器 + 记起点/上一包点 + 复位位移标志
	//   Update : Δ=(pt - 上一包点) 去重 → 置 m_bTouchMoved → 派发 TOUCHMOVE → 可能合成滚轮
	//   End    : 派发 TOUCHUP → 返回"是否算轻点"（未越过拖拽阈值）
	//
	// ⚠️ 三条不变量：
	//   1) Begin 必须把 m_bTouchSlideActive 置真；End 必须置假 + 清释放态。
	//   2) Update/End 在 !m_bTouchSlideActive 时必须安全空转（另一条通道可能没走 Begin）。
	//   3) 坐标一律是**客户区坐标**（调用方负责把屏幕坐标转好）。
	// ===========================================================================
	void CPaintManagerUI::BeginTouchSlideGesture(POINT pt)
	{
		DuiLibDiag::Log(_T("SLIDE-BEGIN pt=%d,%d"), pt.x, pt.y);

		m_ptLastTouchPos = pt;
		// 触摸没有"悬浮"语义。新手势开始前先清掉上一次鼠标路径遗留的 HOT 状态，
		// 防止首个触摸 DOWN 恰好发生在合成 WM_MOUSEMOVE 之前。
		ClearTouchHoverState(pt);
		// 先把手势状态复位：即使这一按没命中任何控件，也不能让上一轮的 m_pEventTouch 残留
		// 下去（否则后续 TOUCHMOVE 会发给一个早已松开的手指所对应的控件）。
		m_pEventTouch = NULL;
		m_pTouchScrollContainer = NULL;
		m_bTouchMoved = false;
		m_ptTouchStart = pt;
		m_dwTouchDownTick = ::GetTickCount();   // 供 MessageHandler 做"TOUCHUP 丢失"超时自愈
		// 滑动累加器：nim_duilib 把 TOUCHEVENTF_MOVE 的 Δy 攒够一个 WHEEL_DELTA(120) 就合成
		// WM_MOUSEWHEEL。这里同样复位，避免上一轮手势的余量污染新手势。
		m_nTouchWheelAccum = 0;
		// 本标志是"滑动状态机活着"的唯一判据（End 之前一直为真）。
		m_bTouchSlideActive = true;

		// ★【第二次合成点击 · 根治】触摸通道接手了这次手势 ⇒ 它的提升鼠标副本要作废。
		//
		// 只在这一处置位（连同 EndTouchSlideGesture 里的销账），理由：
		//   · WM_TOUCH 与 WM_POINTER* 两条通道**都经由本函数**开始手势 ⇒ 一处即全覆盖；
		//   · 由"触摸通道确实收到了手势"来驱动，而不是由"模态边界/代数"来猜 ⇒
		//     对"关闭弹框的那一次手势"同样生效（旧判据唯一漏掉的一类）。
		//   · pt 是**本窗口客户区**坐标，提升副本可能落在别的窗口客户区里，
		//     所以这里换算成屏幕坐标存起来，供 MessageHandler 侧比对。
		// 详见文件上方 ArmPromotedMouseDuplicate 那段注释。
		{
			POINT ptScreen = pt;
			::ClientToScreen(m_hWndPaint, &ptScreen);
			ArmPromotedMouseDuplicate(ptScreen);
			// 同一个触点的**屏幕坐标**副本：抑制"抬起后悬浮态复活"的 ±8px 判据必须用它
			// （客户区坐标一换窗口就不可比，见 s_ptLastTouchScreen 的注释）。
			s_ptLastTouchScreen = ptScreen;
		}

		CControlUI* pControl = FindControl(pt);
		if (pControl == NULL)
		{
			DuiLibDiag::Log(_T("SLIDE-BEGIN no control pt=%d,%d"), pt.x, pt.y);
			// 没命中控件也要保持 active：随后的 Update 仍需被安全吸收掉，
			// 由 End 统一收尾（否则 Update 会跑到空指针上）。
			return;
		}
		if (pControl->GetManager() != this)
		{
			DuiLibDiag::Log(_T("SLIDE-BEGIN foreign control=%s manager=%p self=%p"),
				pControl->GetName().GetData(), (void*)pControl->GetManager(), (void*)this);
			return;
		}

		// [触屏] 手指容差改判：直接命中的不是滚动条时，看看是不是"手指离滚动条滑块很近"。
		// 典型场景：列表右侧竖直滚动条仅 16px 宽，用户想拖滑块却按到了旁边的列表项上。
		if (pControl->GetInterface(DUI_CTR_SCROLLBAR) == NULL)
		{
			CControlUI* pBar = Touch_FindScrollBar(pControl, pt);
			if (pBar == NULL)
				pBar = Touch_ResolveScrollBarThumb(pControl, pt);
			if (pBar != NULL)
			{
				DuiLibDiag::Log(_T("SLIDE-BEGIN-FATFINGER hit=%s -> scrollbar=%s pt=%d,%d"),
					pControl->GetName().GetData(), pBar->GetName().GetData(), pt.x, pt.y);
				pControl = pBar;
			}
		}

		const bool bTouchIsScrollBar = (pControl->GetInterface(DUI_CTR_SCROLLBAR) != NULL);
		// 命中滚动条时把触点收进滚动条 rect（横向按偏也能拖滑块）；事件点用收敛后的，
		// 但 m_ptLastTouchPos / m_ptTouchStart 仍记真实坐标（去重与位移判定按真实手指轨迹走）。
		const POINT ptEvent = bTouchIsScrollBar ? Touch_SnapIntoScrollBar(pControl, pt) : pt;

		DuiLibDiag::Log(_T("SLIDE-BEGIN hit=%s cls=%s scrollbar=%d scrollContainer=%p ptEvent=%d,%d"),
			pControl->GetName().GetData(), pControl->GetClass(), (int)bTouchIsScrollBar,
			(void*)Touch_FindScrollContainer(pControl), ptEvent.x, ptEvent.y);

		m_pEventTouch = pControl;
		m_pTouchScrollContainer = bTouchIsScrollBar ? NULL : Touch_FindScrollContainer(pControl);
		if (!bTouchIsScrollBar)
			m_pEventClick = pControl;
		// 触摸没有悬浮语义；整个手势期间以及抬起后的合成鼠标移动都不应重建 HOT。
		s_bSuppressHoverAfterTouch = true;
		pControl->SetFocus();
		SetCapture();                              // mgr 级：m_bMouseCapture=true + ::SetCapture

		// 滚动条：主动发一次 TOUCHDOWN 让它抓滑块。
		// （TouchDOWN 与鼠标 BUTTONDOWN 在 CScrollBarUI::DoEvent 里等价处理。）
		//
		// ⚠️⚠️ 【这一发 TOUCHDOWN 是"触摸能点击"的必要条件，绝不能删】⚠️⚠️
		//
		// 早先的注释写的是"触摸按下只建立候选点击，不立即发送任何按下事件"——那个策略
		// 在**旧架构**下能活，因为旧架构依赖 Windows 为触摸提升出来的
		// WM_LBUTTONDOWN/UP 去驱动点击（原生路径会自己发 UIEVENT_BUTTONDOWN）。
		//
		// 但现在（通道无关改造之后）触摸链已经把原生鼠标路径**有意让开**：
		//   · MessageHandler 的 WM_LBUTTONDOWN 在 m_pEventTouch != NULL 时直接 break；
		//   · OnPointerInput 的 DOWN 也不再调 MessageHandler(WM_LBUTTONDOWN)。
		// ⇒ 唯一能告诉控件"用户按下了"的通道就是这一发 TOUCHDOWN。
		//
		// 而控件侧的点击状态机是**按下/抬起配对**的，例如 CButtonUI::DoEvent：
		//   UIEVENT_TOUCHDOWN → m_uButtonState |= UISTATE_PUSHED | UISTATE_CAPTURED
		//   UIEVENT_TOUCHUP   → 清 PUSHED|CAPTURED
		//   UIEVENT_BUTTONUP  → if ((m_uButtonState & UISTATE_CAPTURED) != 0) { ...; Activate(); }
		// 如果 DOWN 阶段完全不派发，按钮的 CAPTURED 就永远不会置位 ⇒ 抬手时进不了
		// BUTTONUP 分支（或进了也因守卫失败而跳过）⇒ **Activate 根本不被调用**
		// ⇒ 表现为"主窗口触摸点击全灭"。
		//
		// 另外：本函数**只发 TOUCHDOWN，不发 BUTTONDOWN** —— 这是有意为之。
		// 因为整个手势可能演变成拖动（滚动列表），此时不能让控件提前进入"已按下"的业务态；
		// 真正的点击由 UP 阶段依据 tap 判定（EndTouchSlideGesture 的返回值）成对合成
		// BUTTONDOWN/BUTTONUP 来派发。
		// 换句话说：TOUCHDOWN/TOUCHUP 只负责**控件内部视觉与状态记账**，
		// BUTTONDOWN/BUTTONUP 才负责**业务点击**。两者分工明确，不要合并。
		TEventUI event = { 0 };
		event.Type = UIEVENT_TOUCHDOWN;
		event.pSender = pControl;
		event.ptMouse = ptEvent;
		event.dwTimestamp = ::GetTickCount();
		event.wKeyState = MapKeyState();
		pControl->Event(event);

		// ------------------------------------------------------------------
		// ★★【触摸按压态 · 主动冲刷一次绘制】★★
		//
		// 现象（Win7 真机实测）：点商品卡时"很多商品没有按压态显示"。
		// 成因**不是**控件没置状态，而是**没机会把它画出来**：
		//   · WM_PAINT 是**低优先级**消息 —— 只有消息队列空下来，GetMessage 才会合成它；
		//   · 真机上这次手势的 DOWN→UP 只差 0~16ms（同一个时钟滴答）。TOUCHDOWN 这一发
		//     把 pressed 置上并 Invalidate 之后，队列里紧接着就排着 UP，WM_PAINT 一直
		//     轮不上；等 UP 处理完，状态早被复位成 normal 了 ⇒ 画出来的是普通帧。
		//   · 反过来，**滑动时按压态反而看得见** —— 因为手指按住不放，队列有空隙，
		//     WM_PAINT 合成得出来。这与用户此前"滑动起手就显示按压态"的反馈完全吻合，
		//     也反过来证明"置/复位是配对的、只是没机会绘制"这一判断成立。
		//
		// 修法：TOUCHDOWN 派发完，立刻用 ::UpdateWindow 把已经堆起来的脏区**同步**刷一次。
		//   · 与库内既有写法一致：CContainerUI::EndDown / EndRight 就是这么刷的；
		//   · ::UpdateWindow 只在"本窗口已有脏区"时才发 WM_PAINT，不制造多余重绘；
		//   · 不碰任何状态、不派发任何事件，纯显示层。
		//
		// ⚠️ 副作用（已知并接受）：滑动起手那一帧的按压态也会**真的画出来**。
		//    这不是本行引入的新语义 —— 清扫时机是"抬手时才清扫"，用户已明确选择过。
		//    若将来要让它不显示，改的是清扫时机，不是这里。
		// ------------------------------------------------------------------
		if (m_hWndPaint != NULL && ::IsWindow(m_hWndPaint))
		{
			::UpdateWindow(m_hWndPaint);
		}
	}

	void CPaintManagerUI::UpdateTouchSlideGesture(POINT pt)
	{
		// 另一条通道可能没走 Begin（例如 WM_TOUCH 被让路、手势实际由指针驱动）；
		// 此时 Update 必须安全空转，绝不能访问 m_pEventTouch。
		if (!m_bTouchSlideActive) return;

		// 与上一包完全相同的点 -> 去重，避免无谓派发（NIM 同款守卫）
		if (m_ptLastTouchPos.x == pt.x && m_ptLastTouchPos.y == pt.y) return;

		// 本次位移增量（相对上一包），随事件下发，滚动容器据此做 1:1 跟手平移
		const LONG dx = pt.x - m_ptLastTouchPos.x;
		const LONG dy = pt.y - m_ptLastTouchPos.y;
		m_ptLastTouchPos = pt;
		// 相对手势起点的累计位移超过阈值 -> 判定为"手指在滑动"（用于松开时抑制点击）。
		const LONG ox = pt.x - m_ptTouchStart.x;
		const LONG oy = pt.y - m_ptTouchStart.y;
		// ------------------------------------------------------------------
		// 滑动判定阈值（单位：像素，按**累计位移**对起点计算）。
		//
		// 这是"轻点 vs 滑动"的**唯一**判据，需求是：
		//   「不管有没有真的滑动任何显示区域，只要手指是在滑动就不要触发点击动作」
		//   即判定只看手指，不看内容有没有动、更不看有没有滚动条。
		//
		// 阈值取 16px 的理由：
		//   · 太小（如 8px）会把"用户想点击、但指尖按下去时轻微滚动"误判成滑动
		//     ⇒ 该次抬起的点击被抑制 ⇒ 表现为"按钮点不动"。触摸屏上这种抖动很常见。
		//   · 太大（如 32px）则"手指明显划了一下却没被判成滑动"⇒ 抬手时误触发点击
		//     ⇒ 正是用户报的"滑动却点了按钮"。
		//   16px 在两者之间：正常点击抖动（通常 <10px）不误判，而有意滑动
		//   （手指划过屏幕的位移通常数十至数百像素）必然超过。
		//
		// ⚠️ 若要调整，只改这一个常量 —— 两条通道共用本函数，改一处即全局生效。
		//
		// ⚠️⚠️【不要擅自再加"单包位移"判据 —— 已评估后主动放弃】⚠️⚠️
		//   动机看似合理：真机日志里"快速划动"时前两包累计才 11px、
		//   第三包单包突然 55px，若按单包判能提前 ~60ms 判定为滑动。
		//   但必须意识到：`m_bTouchMoved` **不只是**"清扫按压态的时机"，
		//   它同时是**"这次手势算不算点击"的唯一判据**（见 EndTouchSlideGesture
		//   的 `bTapLike = !m_bTouchMoved`）。
		//   ⇒ 放宽它 = 放宽"点击被误判为滑动"的口径 = 有概率让**正常点击点不动**。
		//   而当前真机日志里 13 次手势中**只有 1 次真实点击**（其余全是有意滑动），
		//   **样本不足以评估点击侧风险**。
		//   ⇒ 在没有"点击被误判"的直接证据前，绝不动这个判据。
		//     （历史教训同源：曾为"理论风险"收窄判据，结果真机主路径直接失效。）
		//   清扫时机已经由"抬手"提前到"越过阈值那一帧"（157ms → ~78ms），
		//   这已解决用户可感知的问题；剩余 ~78ms 是"区分点/滑"的**固有代价**，
		//   不可能再压缩 —— DOWN 那一刻本来就不可能知道用户要干什么。
		static const LONG kTouchDragThresholdPx = 16;
		if (ox > kTouchDragThresholdPx || ox < -kTouchDragThresholdPx
			|| oy > kTouchDragThresholdPx || oy < -kTouchDragThresholdPx)
			m_bTouchMoved = true;

		if (m_pEventTouch == NULL) return;

		DuiLibDiag::Log(_T("SLIDE-MOVE touch=%s cls=%s d=%d,%d moved=%d click=%s"),
			m_pEventTouch->GetName().GetData(), m_pEventTouch->GetClass(),
			(int)dx, (int)dy, (int)m_bTouchMoved,
			m_pEventClick != NULL ? m_pEventClick->GetName().GetData() : _T("null"));

		TEventUI event = { 0 };
		event.Type = UIEVENT_TOUCHMOVE;
		CControlUI* pTouchTarget = m_pTouchScrollContainer != NULL
			? static_cast<CControlUI*>(m_pTouchScrollContainer) : m_pEventTouch;
		event.pSender = pTouchTarget;
		// 滚动条：触点同样收进滚动条 rect（与 Begin 保持一致，避免首帧跳变）。
		event.ptMouse = (m_pEventTouch->GetInterface(DUI_CTR_SCROLLBAR) != NULL)
			? Touch_SnapIntoScrollBar(m_pEventTouch, pt) : pt;
		event.dwTimestamp = ::GetTickCount();
		event.wKeyState = MapKeyState();
		event.wParam = (WPARAM)(int)dx;
		event.lParam = (LPARAM)(int)dy;
		pTouchTarget->Event(event);

		// ------------------------------------------------------------------
		// [对标 nim_duilib] 竖向滑动 → 合成 WM_MOUSEWHEEL。
		//
		// 为什么需要它：真实鼠标"滚动"靠 WM_MOUSEWHEEL 驱动，而触摸只有位移增量。
		// 只处理 TOUCHMOVE 的容器虽然能 1:1 跟手平移，但那些只认滚轮的控件
		// （如挂在窗口上的通用滚动、以及部分不认 TOUCHMOVE 的自定义控件）
		// 在触摸下永远滚不动 —— Win7 之所以"感觉正常"，是因为它走的是"把触摸提升成
		// 鼠标"的老栈，系统会自己补 WM_MOUSEWHEEL；Win10 走指针/触摸栈就不会补了。
		//
		// 因此这里补齐：把 Δy 累加，每满一个 WHEEL_DELTA(120) 就投一次 SCROLLWHEEL。
		// 符号按 Windows 惯例取反：手指下滑（Δy>0，内容下移）→ 负增量。
		//
		// 只在没有 1:1 跟手平移（即没有可滚容器接管）时才合成，避免"内容被平移一次、
		// 又被滚轮滚一次"的双倍滚动。命中滚动条时不合成（滑块本身有自己的拖拽语义）。
		// ------------------------------------------------------------------
		if (m_pTouchScrollContainer == NULL
			&& m_pEventTouch->GetInterface(DUI_CTR_SCROLLBAR) == NULL)
		{
			if (dy != 0) m_nTouchWheelAccum -= dy;
			while (m_nTouchWheelAccum >= 120 || m_nTouchWheelAccum <= -120)
			{
				const int nNotches = m_nTouchWheelAccum / 120;
				m_nTouchWheelAccum -= nNotches * 120;
				const int zDelta = nNotches * 120;
				CControlUI* pWheel = (m_pEventTouch != NULL) ? m_pEventTouch : FindControl(pt);
				if (pWheel == NULL) break;
				TEventUI evWheel = { 0 };
				evWheel.Type = UIEVENT_SCROLLWHEEL;
				evWheel.pSender = pWheel;
				evWheel.wParam = MAKEWPARAM(zDelta < 0 ? SB_LINEDOWN : SB_LINEUP, zDelta);
				evWheel.lParam = 0;
				evWheel.ptMouse = pt;
				evWheel.wKeyState = MapKeyState();
				evWheel.dwTimestamp = ::GetTickCount();
				DuiLibDiag::Log(_T("SLIDE-MOVE->WHEEL control=%s zDelta=%d pt=%d,%d"),
					pWheel->GetName().GetData(), zDelta, pt.x, pt.y);
				pWheel->Event(evWheel);
			}
		}
	}

	bool CPaintManagerUI::EndTouchSlideGesture(POINT pt)
	{
		if (!m_bTouchSlideActive) return false;
		m_bTouchSlideActive = false;

		// ⚠️⚠️ 【m_pEventTouch 为空时必须直接判"不算轻点"，且必须在这里就返回】⚠️⚠️
		//
		// 这里曾经是"先打完 SLIDE-END 日志、再在下面才 return false"，看起来等价，
		// 实际上踩过一个真实死锁：只要 m_pEventTouch 被别处（曾经的"状态交叉"纠偏）
		// 提前清成 NULL，本函数就会带着 m_bTouchSlideActive 已置假、但对外仍报
		// "这是一次滑动"的结论返回 —— 调用方于是走 `!bTapLike` 的"consumed as slide"
		// 分支，把点击**静默吞掉**，同时也不会把手势交还给原生鼠标路径。
		// 结果：点击完全失灵（真机日志：`SLIDE-END touch=null moved=0` 紧跟
		// `POINTER-MSG UP consumed as slide (no click)`，每一个按钮都点不动）。
		//
		// 因此把这条早退路提到最前面：没有命中控件 ⇒ 语义上"没点到东西"，
		// 既不是滑动也不是点击，直接给出明确结论，绝不拖到后面再决策。
		if (m_pEventTouch == NULL)
		{
			m_ptLastTouchPos = pt;
			SetLastTouchScreenPoint(pt);
			m_pTouchScrollContainer = NULL;
			m_bTouchMoved = false;
			m_nTouchWheelAccum = 0;
			s_bSuppressHoverAfterTouch = true;
			m_bMouseTracking = false;
			// [NIM 风格] 这里不需要"解除让路"——让路已改由 m_pEventTouch 这个**标记**表达。
			// ⚠️ 可变参数必须在 _T 宏的括号**之外**：_T 是单参数宏，
			//   若把格式化参数一起写进它的括号里，会触发 C4002「类函数宏的调用参数过多」。
			DuiLibDiag::Log(_T("SLIDE-END no-control pt=%d,%d (not a tap)"), pt.x, pt.y);
			return false;
		}
		DuiLibDiag::Log(_T("SLIDE-END pt=%d,%d touch=%s moved=%d"),
			pt.x, pt.y,
			m_pEventTouch->GetName().GetData(),
			(int)m_bTouchMoved);

		m_ptLastTouchPos = pt;
		SetLastTouchScreenPoint(pt);

		// 注：`m_pEventTouch == NULL` 的早退路已提到本函数最开头（见上），
		//     到这里 m_pEventTouch 必然非空，可以安全解引用。

		ClearTouchHoverState(pt);

		// ⚠️⚠️ 【顺序是死线：先派发 TOUCHUP，再 ReleaseCapture】⚠️⚠️
		//
		// CPaintManagerUI::ReleaseCapture() 不只是调 Win32 那句 ::ReleaseCapture()，
		// 它同时把 m_bMouseCapture 置假、并把 m_bDragMode 置假（见本函数定义处）。
		// 而 CControlUI::Activate()（CButtonUI::Activate 的第一步就是调它）里有捕获保护：
		//     if (!m_pManager->IsCaptured() && !(m_uButtonState & UISTATE_CAPTURED)) return false;
		//   （IsCaptured() 返回的就是 m_bMouseCapture）
		//
		// 于是原来的「先 ReleaseCapture 再 TOUCHUP」会出现这样的连锁：
		//   · Begin 时只发了 UIEVENT_TOUCHDOWN，没给按钮发 BUTTONDOWN
		//     ⇒ 按钮的 m_uButtonState 里从来没有 UISTATE_CAPTURED；
		//   · End 时先 ReleaseCapture ⇒ m_bMouseCapture 已假 ⇒ 随后调用方合成
		//     UIEVENT_BUTTONUP、按钮的 `if ((m_uButtonState & UISTATE_CAPTURED) != 0)`
		//     分支因没有 CAPTURED 而不进 ⇒ Activate() 根本不会被调用；
		//   · 即便被调用，CControlUI::Activate 的捕获保护也会因为两个条件都为假而 return false。
		//   ⇒ **按钮的 click 通知永远发不出来**（按下有高亮、抬手没反应）。
		//
		// 把 ReleaseCapture 挪到 TOUCHUP 之后：按钮在收到 TOUCHUP 时仍处于"管理器认为有捕获"
		// 的状态；等控件侧处理完再由这里收尾释放，语义上也更正确（手势真正结束了）。
		//
		// 注意：这里移的是 **TOUCHUP 与 ReleaseCapture 的相对顺序**，
		// 不能把 ReleaseCapture 整个删掉（否则 m_bMouseCapture 与 Win32 捕获都会泄漏）。
		TEventUI event = { 0 };
		event.Type = UIEVENT_TOUCHUP;
		event.pSender = m_pEventTouch;
		// 与 Begin/Update 一致：滚动条用收敛点，保证 ptMouse 轨迹连续、位移计算不失真。
		event.ptMouse = (m_pEventTouch->GetInterface(DUI_CTR_SCROLLBAR) != NULL)
			? Touch_SnapIntoScrollBar(m_pEventTouch, pt) : pt;
		event.dwTimestamp = ::GetTickCount();
		event.wKeyState = MapKeyState();
		m_pEventTouch->Event(event);

		// TOUCHUP 已派发完毕 ⇒ 现在才释放捕获（手势真正结束）。
		ReleaseCapture();

		// [NIM 风格] 让路无需任何"时间戳清理" —— 它现在由 m_pEventTouch 这个标记表达，
		// 下面的 `m_pEventTouch = NULL` 就是"本次 WM_TOUCH 手势结束"的全部收尾动作。
		//
		// 历史教训（保留备查，勿再引入同类写法）：
		//   曾经用一个"让路时间戳"同时表示"让路中"和"指针手势计时"，
		//   导致 (GetTickCount() - 该值) < 3000 恒成立 ⇒ 指针通道自己驱动的手势被自己判定成
		//   "让路中" ⇒ UP 走进"只清状态、不合成点击"的早退路 ⇒ 两条点击路径同时断掉。
		//   改用标记后，判据是"m_pEventTouch 是否非空"，与"WM_TOUCH 是否真的接管了手势"
		//   严格一致，不存在跨手势残留，也不需要 3 秒超时兜底。

		// 关键：手指抬起后禁止"悬浮态复活"。
		// Windows 会为触摸补发合成的 WM_MOUSEMOVE；且真实 WM_MOUSELEAVE 在 m_bMouseTracking
		// 为真时会自己给自己重发 WM_MOUSEMOVE（见 WM_MOUSELEAVE 分支）→ 刚清掉的悬浮态立刻
		// 被重新点亮。这里置抑制位 + 主动撤下鼠标跟踪，直到用户真的移动鼠标才恢复。
		s_bSuppressHoverAfterTouch = true;
		m_bMouseTracking = false;

		// ------------------------------------------------------------------
		// ★【滑动起手的按压态】手指"划着走"时，按下瞬间命中的那个控件不能留按压态。
		//
		// 现象（用户实测）：手指触屏滑动，起手碰到的控件虽然不会触发点击，
		//   但会留下按压态背景（滑完才被别的东西擦掉，或一直留着）。
		//
		// 成因：BeginTouchSlideGesture 在 DOWN 时**无条件**派发 UIEVENT_TOUCHDOWN，
		//   控件（如 CButtonUI::DoEvent）据此置 UISTATE_PUSHED|UISTATE_CAPTURED 并
		//   Invalidate ⇒ 手指还没滑出控件之前，按压态已经画出来了。
		//   而 UP 时这里派发的 UIEVENT_TOUCHUP 只清"抬手点所在控件"的状态：
		//     · CButtonUI 的 TOUCHUP 分支虽然清 PUSHED|CAPTURED，但它**不判 PtInRect**，
		//       看似能清掉 —— 问题在于它只发给 m_pEventTouch（起手命中的控件），
		//       而滚动场景下 UpdateTouchSlideGesture 把 TOUCHMOVE 改发给了
		//       m_pTouchScrollContainer，TOUCHUP 与 TOUCHMOVE 的收件人不一致，
		//       一旦两个标记不指向同一对象，起手控件就**收不到 TOUCHUP**
		//       ⇒ PUSHED|CAPTURED 永久残留 ⇒ 按压态背景不消失。
		//
		// 修法：判定为滑动时，把起手控件（以及滚动容器）的按压视觉清扫掉，
		//   走 ClearPushedStateAt 的窄路径（只清视觉、不发通知）。
		//
		// ⚠️ 顺序是死线：必须在 TOUCHUP 派发**之前**清。
		//   `ClearPushedStateAt` 会清 CButtonUI 的 UISTATE_CAPTURED，而那正是
		//   `UIEVENT_BUTTONUP` 分支的守卫（`if ((m_uButtonState & UISTATE_CAPTURED) != 0)`）。
		//   放在 TOUCHUP 之后清，会连带把"轻点合成点击"必需的 CAPTURED 一起清掉
		//   ⇒ 按钮 Activate 不触发。但本分支只在 m_bTouchMoved（已判为滑动、不会合成点击）
		//   时才进入，所以是安全的。
		//
		// ⚠️ 必须在下面 `m_pEventTouch = NULL` **之前**调用 —— 要用到起手控件。
		// ------------------------------------------------------------------
		if (m_bTouchMoved)
		{
			CControlUI* pSlideOrigin = m_pEventTouch;
			CControlUI* pSlideScroll = m_pTouchScrollContainer;
			ClearPushedStateAt(pSlideOrigin, pt);
			if (pSlideScroll != NULL && pSlideScroll != pSlideOrigin)
				ClearPushedStateAt(pSlideScroll, pt);
			DuiLibDiag::Log(_T("SLIDE-END clear-pushed origin=%s scroll=%s pt=%d,%d"),
				pSlideOrigin != NULL ? pSlideOrigin->GetName().GetData() : _T("null"),
				pSlideScroll != NULL ? pSlideScroll->GetName().GetData() : _T("null"),
				pt.x, pt.y);
		}

		// ⚠️⚠️ 【必须在返回之前清掉 m_pEventTouch】—— 这是"主窗口触摸点击全灭"的元凶之一。⚠️⚠️
		//
		// 死锁链条（每一步都真实存在）：
		//   1) 本函数被调用时 m_pEventTouch 已经不再需要 —— TOUCHUP 已派发、捕获已释放、
		//      悬浮态已清。它的语义是"本次触摸进行中命中的控件"，手势结束就该失效。
		//   2) 但 `WM_LBUTTONUP` 的原生分支开头是：
		//        if (m_pEventTouch != NULL || m_bSuppressPromotedTouchMouse) { ...; break; }
		//      这个 break **把 ReleaseCapture() 一起跳过了**。
		//   3) 于是只要 m_pEventTouch 残留非 NULL，系统随后提升出来的那条 WM_LBUTTONUP
		//      就会"只清抑制位、不释放捕获"地溜过去 ⇒ 窗口持有 capture 不放。
		//   4) 持有 capture 期间，鼠标/指针消息被强制路由到本窗口，**别处一律点不动**；
		//      且 m_bSuppressPromotedTouchMouse 被反复清成 0，WM_LBUTTONDOWN 的守卫
		//      `if (m_pEventTouch != NULL ...) break;` 又继续拦 → 本窗口也点不动。
		//   ⇒ 整个应用触摸点击全灭，且不会自愈（capture 没有超时机制）。
		//
		//   注意这与"轻点分支里也清了 m_pEventTouch"不冲突：那条路走的是"已合成点击"，
		//   这里是手势收尾的公共清理。**两条路径都必须清**，缺一条就留下上面那个死锁。
		//
		// 清理顺序要求：必须在下面读 m_pEventClick 的 tap 判定**之前**完成 ——
		//   Begin 里给滚动条命中的分支会特意不设 m_pEventClick（滚动条不做点击），
		//   所以 bTapLike 的计算只依赖 m_pEventTouch 的 rect 语义已落地（TOUCHUP 已派发），
		//   与本指针无关；但为便于阅读，统一挪到 tap 判定之前一次清干净。
		m_pEventTouch = NULL;

		// 是否按"点击"处理。默认要求本次手势没有位移，但触摸屏上手指按下时的轻微抖动
		// 超过 8px 阈值非常常见（弹框里的小按钮尤其如此）——一旦判成拖拽，这里不合成点击，
		// 而提升的 WM_LBUTTONDOWN 早已在 DOWN 阶段被拦掉，于是两条点击路径同时断掉，
		// 表现为"弹框里怎么点都没反应"。
		// 因此补一条与鼠标语义一致的判定：位移虽大，但抬起时手指仍落在【按下时命中的同一个
		// 控件】上，且该控件不在可滚动容器内（即这次位移不可能是"滚动"），同样按点击处理。
		//
		// ⚠️ 这里的 pt **必须**与 Begin 用同一个收敛规则，否则命中判定会失真：
		//   命中滚动条时 Begin 把事件点收进滚动条 rect（Touch_SnapIntoScrollBar）。
		//   如果本函数拿原始 pt 去 FindControl，一根在滚动条上但横向偏出几像素的手指
		// ------------------------------------------------------------------
		// tap / drag 判定：【唯一判据是"手指有没有真的滑动"】
		//
		// 需求原文：「不管有没有真的滑动任何显示区域，只要手指是在滑动就不要触发点击动作」。
		// 即：判定只看向**手指本身**，不看向"内容有没有动"。
		//   · 手指位移越过 8px 阈值 ⇒ 一律算滑动 ⇒ 绝不触发点击
		//   · 位移在阈值内 ⇒ 算轻点 ⇒ 触发点击
		// 这个语义与"有没有可滚动的对象"完全无关 —— 哪怕按在没有任何滚动条的空白区、
		// 内容纹丝不动，只要手指划出去了，就不该在抬手时变成一次点击。
		//
		// ⚠️⚠️ 历史教训：这里曾经有一条"同控件豁免" ——
		//   if (!bTapLike && m_pTouchScrollContainer == NULL && ... ) {
		//       if (FindControl(ptTap) == m_pEventClick) bTapLike = true;   // 误判！
		//   }
		//   它的本意是"抬手指时还落在同一个控件上、且该控件不可滚，那这次位移不可能
		//   是滚动，用户只是按得抖了一点，就当点击处理"，用来救"按钮点不动"。
		//   但它**恰好违背了上面的需求**：在无可滚区域里滑动时，手指从按下到抬起往往
		//   仍落在同一控件内 ⇒ 被判成轻点 ⇒ 滑动过程中触发了点击（用户实测到的问题）。
		//   而当初真正要救的"按钮点不动"，根因另有其物（释放捕获时序 + 状态被误清），
		//   已在本文件其它位置修复，不需要靠牺牲滑动语义来兜底。
		//   因此本条豁免**整段删除**，判定回归单一的 m_bTouchMoved。
		//
		// 说明：ptTap 仍保留用于日志/后续扩展；此处不再参与 tap 判定。
		const POINT ptTap = (m_pEventTouch != NULL
			&& m_pEventTouch->GetInterface(DUI_CTR_SCROLLBAR) != NULL)
			? Touch_SnapIntoScrollBar(m_pEventTouch, pt) : pt;
		(void)ptTap;

		const bool bTapLike = !m_bTouchMoved;

		// 清空滚轮累加余量，避免串到下一次手势造成"一按就滚"。
		m_nTouchWheelAccum = 0;

		// 返回值 = "本次手势算轻点"。调用方据此决定是否派发点击。
		return (m_pEventClick != NULL && bTapLike
			&& m_pEventClick->GetInterface(DUI_CTR_SCROLLBAR) == NULL);
	}

	void CPaintManagerUI::OnTouchInput(WPARAM wParam, LPARAM lParam)
	{
		// 触屏模型（参考 NIM Duilib 的 Window::HandleMessage case WM_TOUCH，但**不可**照搬它的鼠标守卫，
		// 旧版 DuiLib 的点击状态机强依赖原生 WM_LBUTTONDOWN/UP，照搬会让点击全灭——已实测踩过）：
		//   1) 独立的 m_pEventTouch 追踪"本次触摸命中控件"，DOWN 设定、UP 清空；绝不复用 m_pEventClick。
		//   2) 只向控件派发“原生触摸事件” UIEVENT_TOUCHDOWN / UIEVENT_TOUCHMOVE / UIEVENT_TOUCHUP：
		//      · CContainerUI 认 TOUCHMOVE        → 内容 1:1 跟手平移（对标 NIM ScrollableBox）；
		//      · CScrollBarUI 认 TOUCHDOWN/MOVE/UP → 拖滑块 / 点轨道翻页（不依赖合成鼠标移动）；
		//      · 其余控件忽略触摸事件（未认领的会沿 DoEvent 冒泡给父容器）。
		//   3) 按钮"点击"由本通道的 TOUCHUP 分支依据 EndTouchSlideGesture 的 tap 判定合成
		//      （位移未越阈值才算轻点）—— 见下方 for 循环里的 UP 分支。
		//      ⚠️ 历史注记：更早的版本依赖"Windows 为触摸自动提升的 WM_LBUTTONDOWN/UP"
		//      去驱动点击，但那条路会把**拖动**也当成点击，且指针通道抢走手势时完全失效。
		//      现已统一由 tap 判定派发，两条通道行为一致。
		//   4) 不做任何"触摸→鼠标"归一化、不做 NIM 那种 m_pEventTouch!=NULL 通用守卫
		//      （旧版 DuiLib 的点击状态机强依赖原生 WM_LBUTTONDOWN/UP，照搬守卫曾让点击全灭）；
		//      "轻点 vs 拖拽"只用 m_bTouchMoved 在 UP 处抑制误点。
		//   5) 触摸**不参与悬浮态**：WM_MOUSEMOVE 里用 MOUSEEVENTF_FROMTOUCH 标记把"提升出来的鼠标消息"
		//      挡在悬浮 enter/leave 之外（触摸没有"光标停留"语义）——这是"点过的控件一直高亮 /
		//      多个控件同时高亮"的根治手段；此处再叠加 s_bSuppressHoverAfterTouch 抑制抬起后的复活。
		TouchApi::PFN_GetTouchInputInfo pfnGetInfo = TouchApi::GetGetTouchInputInfo();

		// 【已移除】"把 WM_TOUCH 同步转发给模态弹框"的兜底块。
		//
		// 历史背景：假模态时期，系统会把 WM_TOUCH 投给 owner（被禁用的主窗口）而非弹框，
		// 于是这里加了一段"发现弹框存在就 SendMessage 转发过去"的补救。
		//
		// 为什么现在必须删掉：
		//   1. ShowModal 已改为真模态（DialogBoxIndirectParam，参考 nim_duilib）。系统对话框管理器
		//      自己就是触摸目标窗口，弹框直接收到 WM_TOUCH，不需要任何转发 —— 这段代码永远不会
		//      再被触发（owner 已被系统禁用，收不到消息）。
		//   2. 就算被触发也是错的：MSDN 明确 WM_TOUCH 的 lParam(HTOUCHINPUT) 经 SendMessage
		//      转发后立即失效，两边只能有一方解析并 CloseTouchInputHandle，极易造成句柄泄漏或
		//      双重关闭；且真模态期间 m_hWndPaint 属于 owner 的情况下，转发会把 owner 的触摸
		//      塞给弹框，坐标语义错位。
		//   3. 它依赖 s_hModalWindow 这个假模态时代的全局状态，与新架构的 CPaintManagerUI
		//      迁移方案（DetachPaintWindow/AttachPaintWindow）职责重叠、互相干扰。
		//
		// 因此整段删除：触摸一律由"收到消息的那个窗口自己的 manager"处理，链路单一清晰。

		if (pfnGetInfo == NULL) return;

		// 本次手势确认系统走的是 WM_TOUCH 通道 ⇒ 【本次手势内】让指针通道让路。
		// ⚠️ 注意这里是"手势级让路"，不是"永久关闭指针通道"。
		// 永久关闭会害死真模态弹框：本台收银机 WM_TOUCH 的贪婪归属权卡在主窗口，
		// 弹框永远收不到 WM_TOUCH；一旦指针通道被永久关掉，弹框就彻底没有输入源。
		// 所以让路只标记"直到本次手势结束"（由 UP / 3 秒超时自动解禁）。
		//
		// 另外，若本窗口的本次手势**已经**由指针通道驱动（m_bPointerGestureActive），
		// 说明这是同一次触摸的另一条通道送来的一份重复消息 —— 整条忽略，绝不能双份驱动。
		if (m_bPointerGestureActive)
		{
			DuiLibDiag::Log(_T("WM_TOUCH ignored (pointer channel owns this gesture) hwnd=%p inputs=%u"),
				(void*)m_hWndPaint, (unsigned)LOWORD(wParam));
			return;
		}

		// ------------------------------------------------------------------
		// ★★【模态背闸】弹框还开着时，背景窗口的 WM_TOUCH 一律忽略。
		//
		// 这正是本文件 s_hModalWindow 那段注释所承诺、却一直没实现的闸门：
		//   「只要当前有模态弹框，任何【非该弹框】的窗口收到 WM_TOUCH 一律忽略，
		//     避免"弹框还开着，手指却把主窗口点动了"的穿透。」
		//
		// 为什么 WM_TOUCH 通道尤其需要它：本台收银机 WM_TOUCH 的**贪婪归属权**
		// 卡在主窗口（MSDN：收到第一条触摸消息后，所有触摸消息都发给该窗口，
		// 直到另一个窗口获得焦点）。弹框是被程序 SetFocus 出来的、而非触摸点出来的，
		// 所以主窗口可能**持续**收到本该属于弹框的 WM_TOUCH —— 不在这里拦，
		// 主窗口就会替弹框把点击"代劳"掉（用户看到的透传）。
		//
		// 注意 WM_TOUCH 没有"必须放行的 UP"问题：它的手势状态由 m_pEventTouch /
		// m_bTouchSlideActive 表达，且上面的 `m_bPointerGestureActive` 检查
		// 与本闸互不干扰；整条 return 是安全的（不会有标记悬空）。
		// 唯一要注意的是把可能残留的滑动状态收干净。
		// ------------------------------------------------------------------
		if (IsModalBackdropWindow(m_hWndPaint))
		{
			DuiLibDiag::Log(_T("MODAL-BACKDROP swallow WM_TOUCH hwnd=%p modal=%p inputs=%u"),
				(void*)m_hWndPaint, (void*)CPaintManagerUI::GetModalWindow(), (unsigned)LOWORD(wParam));
			// 顺手清掉可能残留的滑动/候选点击（上一次手势若被异常中断）。
			// 不派发 TOUCHUP、不派发点击 —— 背景窗口此刻不该有任何交互反应。
			m_bTouchSlideActive = false;
			m_pTouchScrollContainer = NULL;
			m_bTouchMoved = false;
			m_pEventClick = NULL;
			return;
		}
		TraceModalGateCheck(m_hWndPaint, _T("WM_TOUCH"));

		// 注意：让路时间戳**不在这里**打 —— 必须等确认这是一条有效的手势消息之后再打。
		// 曾经在函数入口就打，结果 `cInputs == 0` / GetTouchInputInfo 失败这类"空消息"
		// 也会把指针通道压住 3 秒（没有任何手势在进行，却拒绝了指针）—— 白白制造"顿一下"。

		// 标记触摸输入句柄是否已在“点击候选”分支里提前关闭（避免函数末尾重复关闭）。
		bool bTouchInputClosed = false;

		UINT cInputs = LOWORD(wParam);
		DuiLibDiag::Log(_T("WM_TOUCH begin inputs=%u handle=%p"), cInputs, (HANDLE)lParam);
		if (cInputs == 0)
		{
			DuiLibDiag::Log(_T("WM_TOUCH ignored: inputs=0"));
			return;
		}
		std::vector<TouchApi::TOUCHINPUT> inputs(cInputs);
		if (!pfnGetInfo((HANDLE)lParam, cInputs, inputs.data(), (int)sizeof(TouchApi::TOUCHINPUT)))
		{
			DuiLibDiag::Log(_T("WM_TOUCH GetTouchInputInfo failed error=%u"), ::GetLastError());
			return;
		}

		// 到这里确认：这是一条**有效**的 WM_TOUCH（能取到触摸点）⇒ 正式开始本次手势。
		//
		// [NIM 风格] 这里**不再**写任何"让路时间戳"。
		// 让路由下面的 DOWN 分支里 m_pEventTouch != NULL 这个**标记**表达：
		// BeginTouchSlideGesture 会置 m_pEventTouch，指针通道看到它非空就退让。
		// 标记的生命周期与"WM_TOUCH 是否真的接管了本次手势"严格一致 ——
		// 这比时间戳可靠（时间戳会因为"指针通道自己也写它"而恒真，已踩过）。
		DuiLibDiag::Log(_T("WM_TOUCH owns this gesture (pointer channel will see m_pEventTouch) hwnd=%p"), (void*)m_hWndPaint);

		for (UINT i = 0; i < cInputs; ++i)
		{
			TouchApi::TOUCHINPUT& ti = inputs[i];
			DuiLibDiag::Log(_T("WM_TOUCH input[%u] id=%u flags=0x%08X screen=%d,%d"),
				i, ti.dwID, ti.dwFlags, TOUCH_COORD_TO_PIXEL(ti.x), TOUCH_COORD_TO_PIXEL(ti.y));

			POINT pt;
			pt.x = TOUCH_COORD_TO_PIXEL(ti.x);
			pt.y = TOUCH_COORD_TO_PIXEL(ti.y);
			::ScreenToClient(m_hWndPaint, &pt);

			if (ti.dwFlags & TouchApi::TOUCHEVTFLAG_DOWN)
			{
				DuiLibDiag::Log(_T("TOUCHDOWN begin id=%u client=%d,%d"), ti.dwID, pt.x, pt.y);
				// 这里【不再】用 `if (m_pEventClick != NULL) break;` 做通用守卫：Windows 会在 WM_TOUCH
				// 前后补发合成的 WM_LBUTTONDOWN（同样设置 m_pEventClick），通用守卫会让 m_pEventTouch
				// 永不设置 → 容器收不到 TOUCHMOVE，列表滚不动。
				//
				// 滚动条也不再“交回原生鼠标”：实测部分触摸收银机在手指拖拽期间【不补发合成的
				// WM_MOUSEMOVE】，导致滑块拖不动。现在改为由 WM_TOUCH 直接驱动——CScrollBarUI 已把
				// TOUCHDOWN/MOVE/UP 与鼠标事件等价处理，这里让滚动条走常规接管流程，
				// 后续 TOUCHMOVE 由它消费（不会冒泡到容器把内容滚走）。

				::SetFocus(m_hWndPaint);
				// [通道无关] 滑动状态机的建立逻辑已抽到 BeginTouchSlideGesture，
				// 指针通道（OnPointerInput）也调用同一个函数，保证两条通道滑动行为一致。
				BeginTouchSlideGesture(pt);
			}
			else if (ti.dwFlags & TouchApi::TOUCHEVTFLAG_MOVE)
			{
				DuiLibDiag::Log(_T("TOUCHMOVE begin id=%u client=%d,%d active=%s scrollContainer=%p"),
					ti.dwID, pt.x, pt.y,
					m_pEventTouch != NULL ? m_pEventTouch->GetName().GetData() : _T("null"),
					(void*)m_pTouchScrollContainer);
				// 【不要】在这里对滚动条让路。滚动条现在完全由触摸事件驱动：Begin 已把 m_pEventTouch
				// 设为"滚动条自身"（不再交回原生鼠标），CScrollBarUI 也已把 TOUCHDOWN/MOVE/UP 与鼠标
				// 事件等价处理。若此处仍 `m_pEventClick->GetInterface("ScrollBar") != NULL` 就 break，
				// TOUCHMOVE 永远到不了滚动条 → 滑块拖不动（历史症状）。滚动条收到 TOUCHMOVE 会自行消费
				// （CScrollBarUI::DoEvent 命中已捕获分支后 return true），不会冒泡到容器把内容滚走。
				//
				// [通道无关] 去重 / Δ 计算 / 派发 TOUCHMOVE / 合成滚轮 已全部抽到
				// UpdateTouchSlideGesture，指针通道也调用同一个函数。
				UpdateTouchSlideGesture(pt);
			}
			else if (ti.dwFlags & TouchApi::TOUCHEVTFLAG_UP)
			{
				DuiLibDiag::Log(_T("TOUCHUP begin id=%u client=%d,%d active=%s moved=%d"),
					ti.dwID, pt.x, pt.y,
					m_pEventTouch != NULL ? m_pEventTouch->GetName().GetData() : _T("null"),
					(int)m_bTouchMoved);

				// [通道无关] 收尾逻辑（派发 TOUCHUP、清悬浮态、让路解禁、tap 判定）已抽到
				// EndTouchSlideGesture；指针通道也调用同一个函数。
				//
				// 返回值 = "本次手势算一次轻点"（未越过拖拽阈值，或抬起时仍落在同一控件上）。
				const bool bTapLike = EndTouchSlideGesture(pt);

				// [语义] 点击与否**只由手指是否滑动决定**（见 EndTouchSlideGesture 的说明）。
				// 这里不再有"无可滑动对象就强行当点击"的兜底 —— 那条兜底会让
				// "在没有滚动条的区域滑动"错误地触发点击。
				const bool bTapLikeFinal = bTapLike;

				// ------------------------------------------------------------------
				// [顺序修复] 这里**不再合成** UIEVENT_BUTTONDOWN / UIEVENT_BUTTONUP。
				//
				// 交给 TouchUp() 做两件事：
				//   1) 轻点时先把"本次按下的视觉态"收干净（按压态不该被带进业务回调）；
				//   2) 放行**配对的那条原生 WM_LBUTTONDOWN / WM_LBUTTONUP**，让触摸与
				//      鼠标走同一条代码路径、同一个顺序。
				//
				// 旧写法的问题：合成的 BUTTONDOWN 与 BUTTONUP 之间夹着业务回调
				// （SendNotify(CLICK) → ShowModal()），于是弹框弹出时控件还顶着按下态。
				// 完整因果见 UIManager.h 里 TouchUp 的注释。
				// ------------------------------------------------------------------
				TouchUp(pt, bTapLikeFinal);

				DuiLibDiag::Log(_T("TOUCHUP end synthesized=%d suppress=%d"),
					(int)bTapLikeFinal, (int)m_bSuppressPromotedTouchMouse);
			}
		}

		// 收尾：若上面“点击候选”分支已经把句柄消费掉了（bTouchInputClosed），这里不能再关一次。
		TouchApi::PFN_CloseTouchInputHandle pfnClose = TouchApi::GetCloseTouchInputHandle();
		if (!bTouchInputClosed && pfnClose != NULL)
			pfnClose((HANDLE)lParam);
	}

	// ---------------------------------------------------------------------------
	// WM_POINTER* 处理 —— Win8+ 的另一条触摸/笔输入通道。
	//
	// 参考 nim_duilib NativeWindow_Windows::OnPointerMsgs()。
	//
	// 策略与 nim_duilib 一致：**归一化成鼠标消息**，直接喂给现有的鼠标处理链，
	// 从而不必维护"原生鼠标 / 触摸提升鼠标 / 指针"三套并行的点击状态机。
	// 具体：
	//   WM_POINTERDOWN   → WM_LBUTTONDOWN
	//   WM_POINTERUPDATE → WM_MOUSEMOVE
	//   WM_POINTERUP     → WM_LBUTTONUP
	//   WM_POINTERWHEEL  → 滚轮
	//
	// 只处理主指针（IS_POINTER_PRIMARY_WPARAM）：多指时其余手指一律忽略，
	// 避免多点同时驱动同一个点击状态机导致互相打断。
	//
	// ⚠️ 但 **UP 例外**：实测本台收银机上 WM_POINTERUP 的 wParam 高位不是真正的
	// POINTER_INFO 位域（HIWORD=0x6000，primary 位读到 0），照字面判定会把抬起丢掉，
	// 结果"按下有反应、永远不触发点击"，同时让路状态也解不开。
	// 所以 UP 不做 primary 过滤，改用 m_dwActivePointerId 精确配对。
	//
	// 返回值语义：true = 已处理（调用方应 return true 阻止默认处理）。
	//
	// 【不变量】任何路径都**不得**让 m_bPointerGestureActive 悬空为 true：
	//   · 它是"本次手势归指针管"的独占标记，为真期间 OnTouchInput 会忽略 WM_TOUCH；
	//   · 只有 UP / CAPTURECHANGED / 3 秒超时能把它清掉；
	//   · 所以 UP 在这条链路上必须走完全程（可以"只清状态不派发点击"，但不能被 return true 截住）。
	// ---------------------------------------------------------------------------
	bool CPaintManagerUI::OnPointerInput(UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		using namespace PointerMsg;

		const DWORD dwPointerId = (DWORD)LOWORD(wParam);

		// ==================================================================
		// ★★【模态背闸 · 入口第一道】弹框还开着时，背景窗口收不到"驱动点击"的指针消息。
		//
		// 这是用户实测 bug「点弹框的『选好了』会透传到主窗口商品卡」的**根治点**。
		// 完整成因与"为什么事后的命中点复核挡不住"见 IsModalBackdropWindow 的注释。
		//
		// ⚠️ 只压住**驱动点击/滑动**的两个消息（DOWN / UPDATE）：
		//   它们在背景窗口上没有任何正当用途（背景已被系统禁用），
		//   直接吃掉最干净 —— 连 BeginTouchSlideGesture 都不该进，
		//   否则 m_pEventClick / m_pEventTouch 会被建立起来，
		//   给后续的"抬手派发"留下可供透传的种子。
		//
		// ⚠️⚠️ UP 必须【放行到下面的 switch】⚠️⚠️
		//   与上面"通道互斥"的注释同理：UP 是**唯一**能清 m_bPointerGestureActive 的
		//   消息。在这里 return true 会让本次手势的标记永久悬空，
		//   之后该窗口的所有 DOWN 都被当成"重复按下"挡掉 ⇒ 彻底聋掉（已踩过）。
		//   放行后由 UP 分支自己判 `IsModalBackdropWindow` 并走"只清状态、不派发点击"。
		// ==================================================================
		if (uMsg != DUI_WM_POINTERUP && IsModalBackdropWindow(m_hWndPaint))
		{
			DuiLibDiag::Log(_T("MODAL-BACKDROP swallow pointer msg=0x%04X hwnd=%p modal=%p"),
				uMsg, (void*)m_hWndPaint, (void*)CPaintManagerUI::GetModalWindow());
			// 不 return true 之外的任何动作：不建状态、不派发。
			// 同时顺手把可能残留的滑动标记收掉（上一次手势若被异常中断）。
			return true;
		}
		if (uMsg != DUI_WM_POINTERUP) TraceModalGateCheck(m_hWndPaint, _T("POINTER-DOWN/UPDATE"));

		// ---- [NIM 风格] 通道互斥：本次手势已被 WM_TOUCH 接管，指针整段安静 ----
		//
		// 照搬 nim_duilib Window.cpp 的判据（**不看时间戳，只看归属标记**）：
		//
		//   WM_TOUCH   DOWN: if (m_pEventClick != NULL || m_pEventPointer != NULL) break;
		//   WM_POINTER DOWN: if (m_pEventClick != NULL || m_pEventTouch  != NULL) { handled=true; break; }
		//
		// 即"谁先建立了占用标记，另一条通道就退让"，由手势状态天然驱动、无需计时器。
		// 本项目的对应标记：
		//   · m_pEventTouch        ← 触摸链的占用标记（BeginTouchSlideGesture 里置）
		//   · m_bPointerGestureActive ← 指针链的占用标记（下面 DOWN 分支里置）
		//
		// ⚠️⚠️ 【UP 必须放行，绝不能在这里 return true】⚠️⚠️
		// 这是实测踩过的坑，后果极严重（主窗口触摸点击全灭）：
		//   WM_POINTERUP 是**唯一**能把 m_bPointerGestureActive 归零的消息。
		//   早期版本把 DOWN/UPDATE/UP 不加区分地一起吞掉，于是：
		//     1) 用户第一次点击：WM_TOUCH 先到 ⇒ 这里把 UP 吃掉
		//        ⇒ m_bPointerGestureActive 永久停在 true（上一次手势的残留值）；
		//     2) 之后每次触摸的 WM_POINTERDOWN 都被当成"重复按下"挡掉
		//        ⇒ 再也不产生 POINTER-MSG DOWN ⇒ 该窗口彻底聋掉。
		//   正确做法：让路只压住"驱动点击"的两个消息（DOWN/UPDATE），UP 一律放行 ——
		//   放行后**只做状态清理、不派发 WM_LBUTTONUP**（本次点击本来就不归指针管）。
		//
		// ⚠️ 与上一版的关键差异：这里用 `m_pEventTouch != NULL` 而非时间戳。
		//   m_pEventTouch 的语义是"WM_TOUCH 手势进行中命中的控件"，
		//   它在 BeginTouchSlideGesture 里置、在 EndTouchSlideGesture 里清，
		//   生命周期与"WM_TOUCH 是否真的接管了本次手势"严格一致 —— 这正是我们想要的。
		//   用时间戳的旧写法会因"指针通道自己也写它"而恒真，导致点击全灭（已踩过）。
		//
		// ⚠️⚠️ 【两条标记同时为真是**正常**路径，绝不能"清洗"它】⚠️⚠️
		//
		// 曾经在这里写过一段"状态交叉"纠偏：发现 m_pEventTouch != NULL 且
		// m_bPointerGestureActive 为真，就认定异常，把 m_pEventTouch 置回 NULL。
		// 那是个**严重的误判**，直接造成"整个应用什么都点不动"（真机日志可复现）：
		//
		//   指针通道的 DOWN 分支会调 BeginTouchSlideGesture，而该函数**本来就会**
		//   把 m_pEventTouch 置成命中控件 —— 也就是说"指针手势进行中 + m_pEventTouch 非空"
		//   是每一次指针手势的**标准状态**，不是异常。
		//   于是那段"纠偏"在第一条 UPDATE 上就把 m_pEventTouch 抹成 NULL：
		//     · UpdateTouchSlideGesture 里 `if (m_pEventTouch == NULL) return;`
		//       ⇒ 位移信息全丢，永远不产生 TOUCHMOVE ⇒ 滑不动；
		//     · EndTouchSlideGesture 里 `if (m_pEventTouch == NULL)` 走早退路
		//       ⇒ 返回 false = "不算轻点" ⇒ 点击被静默吞掉 ⇒ 什么都点不动。
		//
		// [NIM] 对照：NIM 的两条通道标记（m_pEventTouch / m_pEventPointer）是**并列**的，
		//   互斥只表达在"谁先占、另一方就退让"那一步，NIM 从不事后清洗标记。
		//   本项目的互斥同理：靠下面 bYieldToTouchChannel 的**入口快照**表达即可，
		//   不需要、也不能有任何"把另一个标记清掉"的动作。
		const bool bYieldToTouchChannel = (m_pEventTouch != NULL) && (!m_bPointerGestureActive);
		if (bYieldToTouchChannel
			&& (uMsg == DUI_WM_POINTERDOWN || uMsg == DUI_WM_POINTERUPDATE))
		{
			DuiLibDiag::Log(_T("POINTER-MSG silent (yield to WM_TOUCH) msg=0x%04X w=0x%08X"), uMsg, (unsigned)wParam);
			return true;   // 吃掉，不驱动点击；也不 return false，免得被系统再转成鼠标消息
		}
		if (bYieldToTouchChannel && uMsg == DUI_WM_POINTERUP)
		{
			// 让路期间的 UP：放行到下面的 switch，由 DUI_WM_POINTERUP 分支只清状态、不派发点击。
			DuiLibDiag::Log(_T("POINTER-MSG UP passes through while yielding (state cleanup only) w=0x%08X"), (unsigned)wParam);
		}
		// 下面各分支统一用这个名字（保持旧代码可读性）
		const bool bPointerYieldedThisGesture = bYieldToTouchChannel;

		// ---- [NIM 风格] pointerId 配对：只让"发起本次手势的那根手指"驱动状态机 ----
		//
		// nim_duilib 的 OnPointerMsgs 里对应的写法是：
		//     if (!IS_POINTER_PRIMARY_WPARAM(wParam)) { handled = true; break; }
		// 本项目**不能照抄**这一句 —— 真机实测该位域在这台机器上错位（见 PointerMsg::
		// IsPrimaryPointer 处的大段注释），UPDATE 会被全部误杀，症状是"能点不能滑"。
		//
		// 因此改用**唯一可靠的判据：pointerId**（wParam 低 16 位，日志里形如 0x0CC7=3271）。
		// 语义："只有当初（或在让路解禁后补建时）记下的那根手指，才有资格驱动 UPDATE/UP。"
		//
		// ⚠️ 豁免条件（否则会踩真实死锁）：
		//   (a) UP 必须无条件放行 —— 它是**唯一**能清 m_bPointerGestureActive 的消息，
		//       丢了它手势状态会永久悬空（3 秒超时只是兜底，体验上是"点一下卡三秒"）。
		//   (b) UPDATE 在"没有活跃指针手势"时必须放行 —— 此时没有 id 可比对，
		//       而且它正是"DOWN 被系统丢了、只有 UPDATE 能救回来"的那条自愈路径；
		//       下面的 UPDATE 分支本身有 `if (m_bTouchSlideActive)` 守卫，空转是安全的。
		if (m_bPointerGestureActive && dwPointerId != m_dwActivePointerId
			&& uMsg != DUI_WM_POINTERUP)
		{
			DuiLibDiag::Log(_T("POINTER-MSG foreign-pointer ignored msg=0x%04X id=%u active=%u"),
				uMsg, (unsigned)dwPointerId, (unsigned)m_dwActivePointerId);
			return true;
		}
		// 非坐标类指针消息（没有 pointerId 语义），直接交回系统，绝不吞。
		if (uMsg == DUI_WM_POINTERCAPTURECHANGED || uMsg == DUI_WM_POINTERLEAVE)
			return true;

		// 坐标：WM_POINTER* 的 lParam 是**屏幕坐标**（与 WM_TOUCH 一致），需转客户区。
		POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
		::ScreenToClient(m_hWndPaint, &pt);

		switch (uMsg)
		{
		case DUI_WM_POINTERDOWN:
		{
			DuiLibDiag::Log(_T("POINTER-MSG DOWN hwnd=%p pt=%d,%d id=%u"), (void*)m_hWndPaint, pt.x, pt.y, (unsigned)dwPointerId);
			// 记下"本次手势由指针通道驱动"：随后同一次触摸的 WM_TOUCH 会被 OnTouchInput 忽略。
			m_bPointerGestureActive = true;
			m_dwActivePointerId = dwPointerId;
			// 计时基准（**仅**供 3 秒超时自愈用，不参与任何归属判定）。
			m_dwPointerDownTick = ::GetTickCount();
			// ⚠️⚠️ 【这里绝对不能写"让路时间戳"这类全局归属字段】⚠️⚠️
			//
			// 早先这里写的是"同时刷新让路时间戳，作为指针手势进行中的计时基准" ——
			// 那是个语义污染，直接造成"主窗口触摸点击全灭"（真机日志可复现）：
			//   指针通道自己 DOWN 时把时间戳写成当前时刻 ⇒ 之后同一手势内
			//   `(GetTickCount() - 该值) < 3000` 恒成立 ⇒ 让路判定恒真
			//   ⇒ UP 走"只清状态、绝不合成点击"的早退路 ⇒ 点击两条路全断。
			//   （日志特征：yield=1 active=1 slide=1 moved=0 + 没有 click-candidate）
			//
			// [NIM 风格] 现在归属完全由 m_bPointerGestureActive 这个布尔标记表达，
			// 超时自愈由专门的 m_dwPointerDownTick 计时，两者职责分离、互不干扰。
			// 与 WM_LBUTTONDOWN 分支一致：先把焦点给本窗口，否则输入法/键盘焦点
			// 可能仍停在别的窗口上（真模态下更要注意别把焦点让给 owner）。
			if (!m_bNoActivate) ::SetFocus(m_hWndPaint);

			// ---- [通道无关滑动] 指针通道也要建立滑动状态机 ----
			// 这是"滑不动"的根治点。原先滑动逻辑只写在 WM_TOUCH 通道里，指针通道一旦
			// 抢到手势就完全没有滑动能力，只会在 UP 时把整个手势当一次点击。
			// 现在两条通道共用 BeginTouchSlideGesture：命中控件、找可滚容器、抓滚动条滑块
			// 全部照做，后续 UPDATE 才有 m_pTouchScrollContainer 可用。
			//
			// 该函数内部已完成原 DOWN 分支需要的一切：FindControl、SetFocus、SetCapture、
			// 建立候选点击 m_pEventClick、以及给滚动条派发 UIEVENT_TOUCHDOWN。
			// 所以**不再**调用 MessageHandler(WM_LBUTTONDOWN) ——
			// 那条原生路径会在抬手时直接 Activate 控件（"滑动也触发点击"的元凶），
			// 而点击已改由 UP 分支经 tap 判定统一派发。
			BeginTouchSlideGesture(pt);
			return true;
		}
		case DUI_WM_POINTERUPDATE:
		{
			// [通道无关滑动] 指针的位移同样走共享滑动逻辑：
			// 去重 / 置 m_bTouchMoved / 派发 UIEVENT_TOUCHMOVE 给容器或滚动条 / 合成滚轮。
			// 这样指针通道下的滑动行为与 WM_TOUCH 通道**完全一致**。
			//
			// ⚠️ 这里**不再**额外喂 WM_MOUSEMOVE 给原生鼠标路径。
			//   原因：本次手势已由触摸语义接管（m_bTouchSlideActive 为真），原生鼠标路径
			//   只会带来副作用而没有任何收益 ——
			//     · 它会走 m_bDragMode / 拖放、并重建 HOT 悬浮态（触摸没有悬浮语义）；
			//     · 它还会让"提升出来的鼠标移动"参与 m_bTouchMoved 的二次判定，与
			//       UpdateTouchSlideGesture 的判定重复。
			//   而控件真正需要的移动语义，已被 UIEVENT_TOUCHMOVE（容器/滚动条）覆盖；
			//   其余控件对"拖动中移动"本来就不关心（只认按下与抬起）。
			//   需要鼠标侧更新的场景（真实鼠标）不经这条分支，所以不受影响。
			if (m_bTouchSlideActive)
			{
				UpdateTouchSlideGesture(pt);
				// 手势进行中：这条指针消息由我们完全接管，不再回落。
				return true;
			}

			// 没有活跃的触摸滑动状态（例如 Begin 因 FindControl 落空而空转）：
			// 退化为纯粹的鼠标移动语义，交给原生路径。
			LRESULT lRes = 0;
			if (MessageHandler(WM_MOUSEMOVE, MK_LBUTTON, MAKELPARAM(pt.x, pt.y), lRes))
				return true;
			return false;
		}
		case DUI_WM_POINTERUP:
		{
			DuiLibDiag::Log(_T("POINTER-MSG UP hwnd=%p pt=%d,%d id=%u yield=%d active=%d slide=%d"),
				(void*)m_hWndPaint, pt.x, pt.y, (unsigned)dwPointerId,
				(int)bPointerYieldedThisGesture, (int)m_bPointerGestureActive, (int)m_bTouchSlideActive);
			// 手势结束：立刻解除"指针驱动中"，让下一个手势可以重新选择通道。
			m_bPointerGestureActive = false;
			m_dwActivePointerId = 0;
			m_dwPointerDownTick = 0;

			// ------------------------------------------------------------------
			// ★★【模态背闸 · UP 分支】背景窗口的 UP：只清状态，**绝不派发点击**。
			//
			// 为什么 UP 不能像 DOWN/UPDATE 那样在入口直接 return true：
			//   上面已经把 m_bPointerGestureActive 归零了，所以"解死锁"的职责已完成；
			//   但**不能**走下面正常的收尾链（EndTouchSlideGesture → TouchUp → 派发点击），
			//   否则背景窗口会在弹框还开着的时候把点击派发出去 —— 这正是透传。
			//
			// 要清的状态（都是"上一次手势的痕迹"，不清会污染下一次）：
			//   · 滑动状态机：若本窗口竟有活跃的滑动（DOWN 是在弹框出现前建立、
			//     或者两通道交叉），必须收掉，否则 m_bTouchSlideActive 残留到下次手势。
			//   · 但**不派发** TOUCHUP 给控件 —— 背景控件此刻不该有任何交互反应。
			//
			// 与 DOWN/UPDATE 的差别（为什么不用同一个入口闸）：
			//   入口处若连 UP 一起吞，m_bPointerGestureActive 就永远清不掉 ⇒
			//   该窗口彻底聋掉（历史踩过的坑，见本函数开头注释）。
			// ------------------------------------------------------------------
		if (IsModalBackdropWindow(m_hWndPaint))
		{
			DuiLibDiag::Log(_T("MODAL-BACKDROP UP cleanup-only hwnd=%p modal=%p slide=%d"),
				(void*)m_hWndPaint, (void*)CPaintManagerUI::GetModalWindow(), (int)m_bTouchSlideActive);
			// 清滑动状态机（不发 TOUCHUP、不动控件树）。
			m_bTouchSlideActive = false;
			m_pTouchScrollContainer = NULL;
			m_bTouchMoved = false;
			// 关键：**不派发任何点击**。候选点击就地作废。
			m_pEventClick = NULL;
			// 释放可能残留的捕获（捕获属于背景 HWND，留着会害下一次手势）。
			if (m_bMouseCapture) ReleaseCapture();
			return true;
		}
		TraceModalGateCheck(m_hWndPaint, _T("POINTER-UP"));

			// 让路期间的 UP 只用来"解死锁"：本次点击归 WM_TOUCH 管，指针侧绝不能
			// 再补一个 WM_LBUTTONUP —— 否则会把 WM_TOUCH 路径建立的 m_pEventClick 提前
			// 清掉（产生"按下有反应、点击不触发"），甚至给同一次触摸补出第二个 BUTTONUP。
			if (bPointerYieldedThisGesture)
			{
				// 让路中不应有活跃的滑动状态；万一有（两通道交叉），也要收掉，
				// 否则 m_bTouchSlideActive 会残留到下一次手势，导致 Update 算错 Δ。
				DuiLibDiag::Log(_T("POINTER-MSG UP yielded-path (no click synthesized) pt=%d,%d slide=%d"),
					pt.x, pt.y, (int)m_bTouchSlideActive);
				if (m_bTouchSlideActive) EndTouchSlideGesture(pt);
				return false;
			}

			// [通道无关滑动] 先走共享收尾：派发 TOUCHUP 给滚动条/容器、清悬浮态、让路解禁、
			// 以及最重要的 tap 判定。返回值 = "本次手势算一次轻点"。
			//
			// ⚠️ 为什么这里必须走 TouchUp() 放行原生消息、而不能只交给 MessageHandler：
			//   DOWN 分支调 BeginTouchSlideGesture 后 m_pEventTouch 已被置成命中控件，
			//   这会让原生的 WM_LBUTTONDOWN 在**当时**提前 break、不建立 m_pEventClick。
			//   但 EndTouchSlideGesture（下面第一步）已经把 m_pEventTouch 释放了 ——
			//   ⇒ 这里放行的那条配对 DOWN 会正常建立 m_pEventClick、UP 也会正常点出来。
			//   （这与 WM_TOUCH 通道完全同构，见 TouchUp 的说明。）
			//
			// [语义] 与 WM_TOUCH 通道同构：点击与否**只由手指是否滑动决定**。
			// ⚠️ 这里曾经有一条"没有任何可滑动对象时，仍按点击处理"的兜底，
			//    那会让"在无滚动条区域滑动"错误地触发点击（用户实测到的问题）。
			//    已删除 —— 判定回归 EndTouchSlideGesture 里单一的 m_bTouchMoved。
			const bool bTapLike = EndTouchSlideGesture(pt);
			TouchUp(pt, bTapLike);

			// 已消费：不再回落 MessageHandler，避免同一条 UP 被处理第二次。
			return true;
		}
		case DUI_WM_POINTERWHEEL:
		{
			// wParam 高位是滚轮增量（与 WM_MOUSEWHEEL 一致）
			const short zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
			DuiLibDiag::Log(_T("POINTER-MSG WHEEL hwnd=%p delta=%d"), (void*)m_hWndPaint, (int)zDelta);
			LRESULT lRes = 0;
			if (MessageHandler(WM_MOUSEWHEEL, MAKEWPARAM(0, zDelta), MAKELPARAM(pt.x, pt.y), lRes))
				return true;
			return false;
		}
		case DUI_WM_POINTERLEAVE:
			// 指针离开窗口：清悬浮态（触摸本无悬浮语义，这里只做兜底清理）
			ClearTouchHoverState(pt);
			return true;

		case DUI_WM_POINTERCAPTURECHANGED:
			// 捕获被系统夺走（典型：手势被中断、窗口失活）。
			// nim_duilib 注释：若不设置 bHandled，系统会把它转成 WM_BUTTON 类消息 ——
			// 我们这里明确吃掉并复位状态，避免状态残留导致后续点击全被吞。
			DuiLibDiag::Log(_T("POINTER-MSG CAPTURECHANGED hwnd=%p"), (void*)m_hWndPaint);
			m_bPointerGestureActive = false;
			m_dwActivePointerId = 0;
			m_dwPointerDownTick = 0;
			m_pEventTouch = NULL;
			m_pTouchScrollContainer = NULL;
			m_bTouchMoved = false;
			m_bSuppressPromotedTouchMouse = false;
			m_dwTouchDownTick = 0;
			m_dwSuppressTick = 0;
			m_nTouchWheelAccum = 0;
			// [通道无关滑动] 滑动状态机也必须一起收掉 —— 否则 m_bTouchSlideActive 残留为真，
			// 下一次手势若走 WM_TOUCH，Update 会误用上一次的 m_ptLastTouchPos 算出巨大 Δ，
			// 表现为"一按下内容就猛地跳一段"。
			m_bTouchSlideActive = false;
			return true;

		default:
			break;
		}

		// POINTERENTER / POINTERACTIVATE / POINTERHWHEEL 等：交回默认处理。
		return false;
	}

	// ---------------------------------------------------------------------------
	// [WM_TOUCH 归属权] "补调 DefWindowProc" 钩子。
	//
	// 背景（详见 UIManager.h 里的长注释）：WM_TOUCH 不是被系统直接投递的，
	// 而是由 DefWindowProc 在收到一条"特殊标记的 WM_MOUSEMOVE / WM_INPUT"时
	// 才"翻译"并派发出来。所以只要有一层吞掉了那条标记消息且不回落到
	// DefWindowProc，该窗口后续就再也收不到 WM_TOUCH。
	//
	// 本库的 MessageHandler 为了不让"触摸提升出来的鼠标移动"污染拖拽/悬浮状态机，
	// 会在两个地方吞掉它（均 return true）—— 这正是要补调的原因。
	// 补调只做"副作用"，我们仍然吃掉消息，DuiLib 的状态机不受影响。
	// ---------------------------------------------------------------------------
	void CPaintManagerUI::SetDefProcRelay(PFN_RELAY_DEFPROC pfnRelay, HWND hWndTarget)
	{
		m_pfnDefProcRelay = pfnRelay;
		m_hWndDefProcRelay = hWndTarget;
		DuiLibDiag::Log(_T("DEFPROC-RELAY set manager=%p hwnd=%p pfn=%p enabled=%d"),
			(void*)this, (void*)hWndTarget, (void*)pfnRelay, (int)m_bRelayDefProcForTouchMove);
	}

	void CPaintManagerUI::ClearDefProcRelay(HWND hWndTarget)
	{
		// 只在"绑定的窗口确实是这个"时清，避免嵌套弹框里把新弹框的钩子误清掉。
		if (hWndTarget == NULL || m_hWndDefProcRelay == hWndTarget)
		{
			if (m_pfnDefProcRelay != NULL)
			{
				DuiLibDiag::Log(_T("DEFPROC-RELAY clear manager=%p hwnd=%p pfn=%p relayed=%u"),
					(void*)this, (void*)m_hWndDefProcRelay, (void*)m_pfnDefProcRelay, m_uDefProcRelayCount);
			}
			m_pfnDefProcRelay = NULL;
			m_hWndDefProcRelay = NULL;
		}
	}

	void CPaintManagerUI::RelayDefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam, LPCTSTR pszWhy)
	{
		if (!m_bRelayDefProcForTouchMove) return;
		if (m_pfnDefProcRelay == NULL || m_hWndPaint == NULL) return;
		// 绑定窗口已变（如真模态换 HWND）：钩子失效，别再调用悬垂的函数指针。
		if (m_hWndDefProcRelay != NULL && m_hWndDefProcRelay != m_hWndPaint)
		{
			DuiLibDiag::Log(_T("DEFPROC-RELAY skipped: bound=%p cur=%p why=%s"),
				(void*)m_hWndDefProcRelay, (void*)m_hWndPaint, pszWhy != NULL ? pszWhy : _T("?"));
			return;
		}

		++m_uDefProcRelayCount;
		// 每 20 次打一条，避免日志被刷爆（触摸移动消息很密集）。
		const bool bLog = (m_uDefProcRelayCount <= 5) || (m_uDefProcRelayCount % 20 == 0);
		if (bLog)
		{
			DuiLibDiag::Log(_T("DEFPROC-RELAY call #%u msg=0x%04X hwnd=%p lParam=%d,%d why=%s"),
				m_uDefProcRelayCount, uMsg, (void*)m_hWndPaint,
				(int)GET_X_LPARAM(lParam), (int)GET_Y_LPARAM(lParam),
				pszWhy != NULL ? pszWhy : _T("?"));
		}
		// 只关心副作用（让系统的 WM_TOUCH 翻译链继续跑），返回值丢弃。
		(void)m_pfnDefProcRelay(m_hWndPaint, uMsg, wParam, lParam);
	}

	void CPaintManagerUI::ClearPushedStateAt(CControlUI* pControl, POINT pt)
	{
		// 清"这个控件"的按下/悬浮视觉，**不触发任何业务**。
		//
		// ------------------------------------------------------------------
		// [为什么是这个签名] 参照 NIM_Duilib 的 Control::ButtonUp（关键对照）
		//
		// NIM 的点击收尾是这样的（duilib/Core/Control.cpp:910-939）：
		//     bool Control::ButtonUp(EventArgs& msg) {
		//         if (IsMouseFocused()) {
		//             SetMouseFocused(false); ... Invalidate();
		//             if (IsPointInWithScrollOffset(msg.ptMouse)) {
		//                 if (msg.Type == kEventPointUp) { m_uButtonState = kControlStateNormal; m_nHotAlpha = 0; }
		//                 else                          { m_uButtonState = kControlStateHot;    m_nHotAlpha = 255; }
		//                 Activate();          // ★ 发 CLICK，**在复位状态之后**
		//                 return true;
		//             }
		//             m_uButtonState = kControlStateNormal; m_nHotAlpha = 0;
		//         }
		//         return false;
		//     }
		//
		// ⇒ NIM 把 `Activate()`（触发业务、可能弹模态框）放在**状态复位之后**。
		//   这就是"顺序"的字面答案：复位必须早于业务回调。
		//
		// 本项目的问题在**控件侧**：CDiandanFoodItemUI::DoEvent 写成了
		//     if (UIEVENT_BUTTONUP) { SendNotify(CLICK); SetCardState("normal"); }
		//   —— 先回调、后复位，而 SendNotify 会同步 `ShowModal()` 开嵌套模态循环，
		//   于是复位被推迟到弹框关闭（用户看到的"按压态不消失"）。
		//   根治点在 CDiandanFoodItemUI::DoEvent（已改为先复位再 SendNotify）。
		//
		// 本函数是**兜底**：触摸链在收尾时（尤其"没有候选点击目标"或"滑动不算点击"
		//   两种路径）把命中控件的视觉收干净，避免任何控件遗漏。
		// ------------------------------------------------------------------
		//
		// ⚠️ 只处理传入的那一个控件，**不上溯祖先链**：
		//   会挂按下态的只有被点击的控件本身（BUTTONDOWN 不冒泡），祖先从未被置位。
		//
		// ⚠️ 不碰 PUSHED 以外的状态语义：只清显示位，不发通知、不 Activate。
		//
		// pControl 为 NULL 时按 pt 命中查找（兼容只给坐标的调用方）。
		if (m_pRoot == NULL) return;

		if (pControl == NULL)
		{
			pControl = FindControl(pt);
			if (pControl == NULL) return;
		}
		if (pControl->GetManager() != this) return;

		// --------------------------------------------------------------
		// ◆【滑动起手误按压】优先走"控件自己实现的清接口"。
		//
		// 原先这里只有下面那条 `DUI_CTR_BUTTON` 专用路径 —— 它依赖
		// `GetInterface(DUI_CTR_BUTTON)`，也就是说**只有 CButtonUI 系**能被清到。
		// 而业务侧大量自绘控件（如本项目的 CDiandanFoodItemUI : CVerticalLayoutUI）
		// 的按下态是"换整卡背景图"实现的，压根没有 m_uButtonState，
		// 也就拿不到 DUI_CTR_BUTTON 接口 ⇒ 被那条早退路静默跳过
		// ⇒ 触摸滑动起手时留下按压态背景（用户实测 bug）。
		//
		// 现在改为：先用基类虚函数 `CControlUI::ClearPushedState()`。
		//   · CButtonUI 已把它 override 成"清 PUSHED|CAPTURED|HOT"，
		//     所以按钮的行为与改前**完全一致**；
		//   · 业务自绘控件 override 成"复位自己的卡片样式"；
		//   · 其余控件走基类默认空实现 = 安全 no-op。
		// pControl 本身就是 CControlUI* 或其派生，基类指针即可完成虚分派。
		// --------------------------------------------------------------
		pControl->ClearPushedState();
	}

	bool CPaintManagerUI::TouchUp(const POINT& pt, bool bTapLike)
	{
		// 契约（调用方：OnTouchInput / OnPointerInput 两条通道的 UP 分支）：
		//   进入时 —— 触摸链自己的手势状态（m_pEventTouch / m_pTouchScrollContainer /
		//              捕获）**已经收干净**（见 EndTouchSlideGesture，它已 ReleaseCapture）。
		//   返回 true  —— "这次触摸的 UP 已由本函数处理完"，调用方应吞掉当前消息。
		//
		// ==================================================================
		// ★★【模态背闸 · 最后一道】本窗口是"弹框背后的背景窗口"时，只清状态、绝不派发点击。
		//
		// 这是用户实测 bug「点弹框的『选好了』会透传到主窗口」的**兜底防线**。
		//
		// 主防线在三个入口（OnPointerInput / OnTouchInput / MessageHandler），
		// 它们保证"背景窗口从一开始就不产生候选点击"。但那三道闸都依赖
		// `GetModalWindow()` 在**消息到达那一刻**已经登记了弹框 —— 存在两个缝隙：
		//
		//   缝隙 1：DOWN 到达时模态**还没开始**（手势比弹框早）。
		//           这是"点商品卡 → 回调里 ShowModal()"的正常时序：
		//           该次手势的 DOWN 发生在弹框出现之前，候选点击(m_pEventClick)
		//           是那时建立的；等 UP 到达时弹框已经在上面了。
		//           此时入口闸看到的是"UP 时模态为真"，本来也该拦 ——
		//           但 UP 必须放行（否则 m_bPointerGestureActive 悬空），
		//           所以背景窗口的 UP 会一路走到这里。
		//   缝隙 2：嵌套弹框（A 弹框里开 B 弹框）时 GetModalWindow() 会被覆盖成 B，
		//           而 A 的 UP 可能仍在路上。
		//
		// 语义上这里也必须是零容忍的：
		//   **业务回调已经由"弹框自己的按钮"触发了，背景窗口不该再触发第二次。**
		//   所以本函数在最开头就做这道判定，且**只收视觉、不派发任何通知**。
		//
		// ⚠️ 注意本闸的位置必须在 `if (!bTapLike)` **之前**：
		//   否则"滑动路径"与"轻点路径"会走两套不同的清理代码，
		//   而背景窗口两条路都只需要"清干净、别动控件"。
		// ==================================================================
		if (IsModalBackdropWindow(m_hWndPaint))
		{
			DuiLibDiag::Log(_T("MODAL-BACKDROP TouchUp abort hwnd=%p modal=%p tap=%d pt=%d,%d"),
				(void*)m_hWndPaint, (void*)CPaintManagerUI::GetModalWindow(),
				(int)bTapLike, pt.x, pt.y);
			// 清掉本次手势的痕迹（不发任何通知、不给控件派发 TOUCHUP/BUTTON*）。
			m_pEventClick = NULL;
			m_pTouchScrollContainer = NULL;
			m_bTouchMoved = false;
			m_bTouchSlideActive = false;
			m_bPointerGestureActive = false;
			m_dwActivePointerId = 0;
			m_bSuppressPromotedTouchMouse = false;
			m_dwSuppressTick = 0;
			// 悬浮态也收掉（背景控件不该保持 HOT）。
			{
				POINT ptDummy = { -1, -1 };
				ClearTouchHoverState(ptDummy);
			}
			return true;
		}

		// ------------------------------------------------------------------
		// ⚠️⚠️ 为什么必须**自己派发**点击事件（别再改成"放行原生鼠标消息"）⚠️⚠️
		//
		// 真机日志实测结论（`touch_trace.log`）：
		//   本机 Win10 上触摸**只产生 WM_POINTER\***，
		//   `fromtouch=1` 的 `WM_LBUTTONDOWN` / `WM_LBUTTONUP` 数量是 **0** ——
		//   系统**不会**为触摸提升出鼠标点击消息（老 Win7 触摸栈才会）。
		//
		// ⇒ 曾经有一版实现改成"把配对的原生 DOWN/UP 放行，让鼠标路径去点"，
		//   结果**整机点不动**：那条消息根本不存在，放行等于把整个手势丢掉。
		//   教训已写入 UIManager.h 的 TouchUp 注释，勿再重犯。
		//
		// ------------------------------------------------------------------
		// [本函数要修的真正问题]：**业务回调被夹在两条合成事件中间**
		//
		// 旧的合成顺序：
		//     Event(BUTTONDOWN) → 控件置 PUSHED（商品卡置 "pressed"）
		//     Event(BUTTONUP)   → 控件 DoEvent 里 `SendNotify(CLICK)`
		//                          → 业务层 `ShowModal()` 开**嵌套模态循环**
		//                          → 控件自己的 `SetCardState("normal")` 在 CLICK 之后才跑
		//
		// 关键：`CControlUI::Event → DoEvent` 是**同步调用**（UIControl.cpp:841），
		//   所以业务回调会阻塞在中间，"清按下态"被推迟到**弹框关闭之后** ——
		//   弹框存活的整段时间里卡片都顶着 "pressed"（用户看到的"按压态不消失"），
		//   而且回调返回时前台已经变了 ⇒ 复位动作打在错的对象/时机上。
		//
		// 鼠标路径为什么没这问题：它的清理动作全部在业务回调**之前**：
		//     ClearTouchHoverState / ClearPushedStateAt / s_bSuppressHoverAfterTouch
		//     → 才轮到 `pClick->Event(BUTTONUP)` → `SendNotify(CLICK)` → `ShowModal()`
		//
		// 但**触摸链不能照搬"事前 ClearPushedStateAt"**！
		//   鼠标的 DOWN/UP 是两条独立消息，中间有重绘；触摸链的
		//   BUTTONDOWN/BUTTONUP 是同一次调用里背靠背合成的，中间没有重绘机会
		//   ⇒ 事前清一次等于"先擦、再置 pressed、再复位 normal"三段连跑，
		//     pressed 帧一帧都画不出来（用户实测：所有商品按压态都不显示）。
		//   ⇒ 本函数的做法是：**只收 hover，不碰按下态**，把按下态的置/复
		//     完全交给控件自己的 DoEvent（TOUCHDOWN 置、BUTTONUP 先复位后回调）。
		// ------------------------------------------------------------------
		if (!bTapLike)
		{
			// 手指滑动过 ⇒ 绝不能触发点击。
			//   注意：这里也**不能**靠"放行原生 UP"来清按下态（没有那条消息），
			//   所以自己把命中点的按下态收掉 —— 等价于鼠标路径里
			//   `WM_LBUTTONUP` 那句 `ClearPushedStateAt` + `bTouchDragged` 的
			//   "ptMouse 置 (-1,-1) 只清位不 Activate"效果。
			DuiLibDiag::Log(_T("TOUCHUP consumed as slide pt=%d,%d"), pt.x, pt.y);
			ClearPushedStateAt(NULL, pt);
			m_pEventClick = NULL;
			m_bSuppressPromotedTouchMouse = false;
			m_dwSuppressTick = 0;
			m_bTouchMoved = false;
			return true;
		}

		if (m_pEventClick == NULL)
		{
			// 轻点，但没有候选点击目标（Begin 时 FindControl 落空）。
			//   仍然要把按下视觉收干净（可能与其它路径交叉），然后吞掉。
			DuiLibDiag::Log(_T("TOUCHUP fallback-clear hwnd=%p pt=%d,%d"), (void*)m_hWndPaint, pt.x, pt.y);
			ClearPushedStateAt(NULL, pt);
			m_bSuppressPromotedTouchMouse = false;
			m_dwSuppressTick = 0;
			m_bTouchMoved = false;
			return true;
		}

		CControlUI* pClick = m_pEventClick;

		// 本次触摸已消费：清掉候选点击，避免它残留到下一次手势。
		m_pEventClick = NULL;
		m_pTouchScrollContainer = NULL;
		// 本机触摸不会被提升成鼠标消息，所以这个抑制位在触摸链里意义不大；
		// 保留置假以免历史行污染（真机上没有需要吞的 LBUTTON 消息）。
		m_bSuppressPromotedTouchMouse = false;
		m_dwSuppressTick = 0;
		m_bTouchMoved = false;

		DuiLibDiag::Log(_T("TOUCHUP dispatch click %s cls=%s pt=%d,%d"),
			pClick->GetName().GetData(), pClick->GetClass(), pt.x, pt.y);

		// ==================================================================
		// ★【防透传 · 死线检查】抬起时必须重新校验"抬手那一刻模态是否已经打开"。
		//
		// 这是本函数最贴近透传现场的判据，来自用户实测的**真实时序**：
		//   用户点的"选好了"（`diandan_nature_save`）走的是 `Close(IDOK)`，
		//   弹框由此开始销毁 —— 但 `DialogBoxIndirectParam` 的返回、
		//   以及 `SetModalWindow(hPrevModal)` 的还原，都在**嵌套消息循环退出之后**。
		//
		//   ⇒ 于是存在一个窗口期：**弹框已经在销毁、但 GetModalWindow() 还指向它**。
		//     在这期间到达的输入消息，如果走的是主窗口（背景窗口），
		//     `IsModalBackdropWindow` 会因为 (a) 仍为真、(c) 也成立而把它拦下 ——
		//     这是对的；但另一个方向：**主窗口自己那条手势的 UP 到达时**，
		//     入口闸要等到 UP 分支才判，而 UP 又必须放行（否则 m_bPointerGestureActive
		//     悬空、窗口彻底聋掉）—— 所以必须在这里、在**派发点击之前**再判一次。
		//
		//   判据是**纯状态**的（不看时间戳）：
		//     (a) 该控件仍属于当前 manager；
		//     (b) 抬手点 `FindControl(pt)` 仍命中它（弹框覆盖时命中的会是弹框里的控件）；
		//     (c) **此刻没有"别的"窗口处于模态背闸状态** —— 即本窗口自己
		//         此刻是不是背景窗口。是 ⇒ 说明模态会话仍在新窗口里进行，
		//         这次点击不该由背景窗口派发。
		//   任一不满足 ⇒ 只收尾、绝不 SendNotify。
		//
		// 鼠标路径为什么没这问题：真模态独占鼠标捕获与消息投递，
		//   背后窗口根本收不到那条 WM_LBUTTONUP。触摸链是我们自己按
		//   `m_pEventClick` 派发的，绕过了窗口边界 ⇒ 必须自己补这道复核。
		// ==================================================================
		if (IsModalBackdropWindow(m_hWndPaint))
		{
			DuiLibDiag::Log(_T("TOUCHUP ABORT modal-opened-midway click=%s modal=%p pt=%d,%d"),
				pClick->GetName().GetData(),
				(void*)CPaintManagerUI::GetModalWindow(), pt.x, pt.y);
			// 只收掉按下视觉，**绝不 SendNotify**。
			ClearPushedStateAt(pClick, pt);
			m_bSuppressPromotedTouchMouse = false;
			m_dwSuppressTick = 0;
			return true;
		}

		const bool bStillOwned = (pClick->GetManager() == this);
		if (!bStillOwned)
		{
			DuiLibDiag::Log(_T("TOUCHUP ABORT foreign click=%s mgr=%p self=%p"),
				pClick->GetName().GetData(), (void*)pClick->GetManager(), (void*)this);
			return true;
		}

		CControlUI* pHitNow = FindControl(pt);
		// 命中判定要穿透到"同一张卡"：FindControl 可能返回卡内的子控件
		// （图片/文字），而 m_pEventClick 记的是整张卡。用祖先链做等价判定。
		bool bSameTarget = false;
		for (CControlUI* pWalk = pHitNow; pWalk != NULL; pWalk = pWalk->GetParent())
		{
			if (pWalk == pClick)
			{
				bSameTarget = true;
				break;
			}
		}
		if (!bSameTarget)
		{
			DuiLibDiag::Log(_T("TOUCHUP ABORT covered-by-overlay click=%s hitNow=%s pt=%d,%d"),
				pClick->GetName().GetData(),
				pHitNow != NULL ? pHitNow->GetName().GetData() : _T("null"),
				pt.x, pt.y);
			// 只收掉"按下视觉"，绝不 SendNotify —— 这次点击已经不属于它了。
			ClearPushedStateAt(pClick, pt);
			return true;
		}

		// ==================================================================
		// ★【悬浮态收尾】把 hover 登记收干净 —— 必须在派发点击**之前**。
		//
		// 这段解决的是上一轮的 bug：「弹框里点『选好了』后，屏幕同位置的背后商品
		// 变成悬浮态（hot）」。
		//
		// 为什么不能"像鼠标那样用抬手点重建 hover"：
		//   鼠标路径点完不留悬浮，是因为它的 `WM_LBUTTONUP` 里 `ClearTouchHoverState`
		//   把 `m_pEventHover` 置空了，之后系统补发的 `WM_MOUSEMOVE` 才重新立 hover。
		//   触摸链抬手后**没有** `WM_MOUSEMOVE`（手指已离开），
		//   若照鼠标"重新命中并 ENTER"，`FindControl(pt)` 会返回**刚点的那张卡自己**
		//   （`CContainerUI::FindControl` 末尾 `Proc(this,pData)` 返回容器自身）
		//   ⇒ 卡片刚复位完 pressed 立刻被打成 hot。
		//   语义上也对：**hover = 光标停留，而抬手 ≠ 停留**。
		//   （NIM 的 `HandleMouseEnterLeave` 由移动消息驱动，抬手时不会调用。）
		//
		// ⚠️ 只碰 hover，**不碰按下态** —— 按下态归下面派发链里控件自己的
		//    `BUTTONUP` 分支复位（见 CDiandanFoodItemUI::DoEvent）。
		//    这两件事必须分开，否则又会变成"先擦后置、pressed 帧永远看不到"。
		// ==================================================================
		if (m_pEventHover != NULL)
		{
			TEventUI hoverEvent = { 0 };
			hoverEvent.Type = UIEVENT_MOUSELEAVE;
			hoverEvent.pSender = m_pEventHover;
			hoverEvent.ptMouse = pt;
			hoverEvent.wKeyState = MapKeyState();
			hoverEvent.dwTimestamp = ::GetTickCount();
			m_pEventHover->Event(hoverEvent);
			m_pEventHover = NULL;
			// 连带收掉"需要 MOUSELEAVE 的登记表"（与鼠标路径 ClearTouchHoverState 同构）。
			for (int i = 0; i < m_aNeedMouseLeaveNeeded.GetSize(); ++i)
			{
				CControlUI* pNeed = static_cast<CControlUI*>(m_aNeedMouseLeaveNeeded[i]);
				if (pNeed != NULL && pNeed != hoverEvent.pSender)
				{
					hoverEvent.pSender = pNeed;
					pNeed->Event(hoverEvent);
				}
			}
			m_aNeedMouseLeaveNeeded.Empty();
		}

		// ==================================================================
		// ★【顺序】派发点击。**刻意不在事前清按下态**。
		//
		// ——— 为什么绝对不能"先清 pressed、再派发"———
		//   用户实测 bug：(我上一版在派发前加了 `ClearPushedStateAt(pClick, pt)`，
		//   结果) **所有商品控件的按压态都不显示了**。
		//
		//   因果链：
		//     1) 触摸链在 DOWN 时只发 `UIEVENT_TOUCHDOWN`，`UIEVENT_BUTTONDOWN`
		//        要等到**抬手时**才由下面这几行成对合成；
		//     2) 商品卡的 pressed 视觉来自 `TOUCHDOWN` / `BUTTONDOWN` 分支；
		//     3) 若在派发前先 `ClearPushedStateAt`，等于"先擦、再置"，
		//        紧接着 `BUTTONUP` 又复位成 normal ——
		//        这几个动作**全在同一次调用里背靠背完成，中间没有任何重绘机会**
		//        ⇒ 用户从头到尾看不到 pressed 帧。
		//   鼠标路径能看见 pressed，是因为它的 DOWN/UP 是**两条独立消息**，
		//   中间隔着一次消息循环 + 重绘。
		//
		// ——— 那"弹框弹出时控件还顶着 pressed"怎么办？———
		//   已由**控件侧**按 NIM `Control::ButtonUp` 的正确顺序解决：
		//   `CDiandanFoodItemUI::DoEvent` 的 `UIEVENT_BUTTONUP` 分支现在是
		//       SetCardState("normal");          // 先复位
		//       m_pManager->SendNotify(this, DUI_MSGTYPE_CLICK);   // 后回调（此处才 ShowModal）
		//   而 `EndTouchSlideGesture` 在**调用本函数之前**就已经派发过 `UIEVENT_TOUCHUP`，
		//   卡片在那一刻也已经复位过一次（见卡片 DoEvent 的 TOUCHUP 分支）。
		//   ⇒ "业务回调时控件已是普通态"这个目标由控件自己达成，
		//     不需要（也不应该）由管理端在事前粗暴擦除。
		// ==================================================================
		TEventUI clickEvent = { 0 };
		clickEvent.Type = UIEVENT_BUTTONDOWN;
		clickEvent.pSender = pClick;
		clickEvent.ptMouse = pt;
		clickEvent.dwTimestamp = ::GetTickCount();
		clickEvent.wKeyState = MapKeyState();
		pClick->Event(clickEvent);

		clickEvent.Type = UIEVENT_BUTTONUP;
		clickEvent.ptMouse = pt;
		clickEvent.dwTimestamp = ::GetTickCount();
		pClick->Event(clickEvent);

		// 兜底：只针对"库内按钮"（DUI_CTR_BUTTON）这一窄类。
		// 商品卡那类自定义控件不受影响 —— 它们不吃 UISTATE_*，
		// 复位由自己的 DoEvent（见上）负责。
		ClearPushedStateAt(NULL, pt);

		return true;
	}


	void CPaintManagerUI::ClearTouchHoverState(POINT pt)
	{
		DuiLibDiag::Log(_T("CLEAR-HOVER pt=%d,%d hover=%s leaveCount=%d"),
			pt.x, pt.y,
			m_pEventHover != NULL ? m_pEventHover->GetName().GetData() : _T("null"),
			m_aNeedMouseLeaveNeeded.GetSize());
		TEventUI event = { 0 };
		event.Type = UIEVENT_MOUSELEAVE;
		event.ptMouse = pt;
		event.wKeyState = MapKeyState();
		event.dwTimestamp = ::GetTickCount();

		CStdPtrArray controls(m_aNeedMouseLeaveNeeded.GetSize());
		controls.Resize(m_aNeedMouseLeaveNeeded.GetSize());
		::CopyMemory(controls.GetData(), m_aNeedMouseLeaveNeeded.GetData(),
			m_aNeedMouseLeaveNeeded.GetSize() * sizeof(LPVOID));

		for (int i = 0; i < controls.GetSize(); ++i)
		{
			CControlUI* pControl = static_cast<CControlUI*>(controls[i]);
			if (pControl != NULL)
			{
				event.pSender = pControl;
				pControl->Event(event);
			}
		}

		if (m_pEventHover != NULL)
		{
			event.pSender = m_pEventHover;
			m_pEventHover->Event(event);
			m_pEventHover = NULL;
		}

		m_aNeedMouseLeaveNeeded.Empty();
		if (m_hwndTooltip != NULL)
			::SendMessage(m_hwndTooltip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&m_ToolTip);
	}

	void CPaintManagerUI::DeletePtr(void* ptr)
	{
		if (ptr)
		{
			delete ptr; ptr = NULL;
		}
	}

	HINSTANCE CPaintManagerUI::GetInstance()
	{
		return m_hInstance;
	}

	CDuiString CPaintManagerUI::GetInstancePath()
	{
		if (m_hInstance == NULL) return _T('\0');

		TCHAR tszModule[MAX_PATH + 1] = { 0 };
		::GetModuleFileName(m_hInstance, tszModule, MAX_PATH);
		CDuiString sInstancePath = tszModule;
		int pos = sInstancePath.ReverseFind(_T('\\'));
		if (pos >= 0) sInstancePath = sInstancePath.Left(pos + 1);
		return sInstancePath;
	}

	CDuiString CPaintManagerUI::GetCurrentPath()
	{
		TCHAR tszModule[MAX_PATH + 1] = { 0 };
		::GetCurrentDirectory(MAX_PATH, tszModule);
		return tszModule;
	}

	HINSTANCE CPaintManagerUI::GetResourceDll()
	{
		if (m_hResourceInstance == NULL) return m_hInstance;
		return m_hResourceInstance;
	}

	const CDuiString& CPaintManagerUI::GetResourcePath()
	{
		return m_pStrResourcePath;
	}

	const CDuiString& CPaintManagerUI::GetResourceZip()
	{
		return m_pStrResourceZip;
	}

	const CDuiString& CPaintManagerUI::GetResourceZipPwd()
	{
		return m_pStrResourceZipPwd;
	}

	bool CPaintManagerUI::IsCachedResourceZip()
	{
		return m_bCachedResourceZip;
	}

	HANDLE CPaintManagerUI::GetResourceZipHandle()
	{
		return m_hResourceZip;
	}

	void CPaintManagerUI::SetInstance(HINSTANCE hInst)
	{
		m_hInstance = hInst;
	}

	void CPaintManagerUI::SetCurrentPath(LPCTSTR pStrPath)
	{
		::SetCurrentDirectory(pStrPath);
	}

	void CPaintManagerUI::SetResourceDll(HINSTANCE hInst)
	{
		m_hResourceInstance = hInst;
	}

	void CPaintManagerUI::SetResourcePath(LPCTSTR pStrPath)
	{
		m_pStrResourcePath = pStrPath;
		if (m_pStrResourcePath.IsEmpty()) return;
		TCHAR cEnd = m_pStrResourcePath.GetAt(m_pStrResourcePath.GetLength() - 1);
		if (cEnd != _T('\\') && cEnd != _T('/')) m_pStrResourcePath += _T('\\');
	}

	void CPaintManagerUI::SetResourceZip(LPVOID pVoid, unsigned int len, LPCTSTR password)
	{
		if (m_pStrResourceZip == _T("membuffer")) return;
		if (m_bCachedResourceZip && m_hResourceZip != NULL)
		{
			CloseZip((HZIP)m_hResourceZip);
			m_hResourceZip = NULL;
		}
		m_pStrResourceZip = _T("membuffer");
		if (m_cbZipBuf)
		{
			delete[] m_cbZipBuf;
			m_cbZipBuf = nullptr;
		}
		if (!m_cbZipBuf)
		{
			m_cbZipBuf = new BYTE[len];
			memcpy(m_cbZipBuf, pVoid, len);
		}

		m_bCachedResourceZip = true;
		m_pStrResourceZipPwd = password;  //Garfield 20160325 带密码zip包解密
		if (m_bCachedResourceZip)
		{
#ifdef UNICODE
			char* pwd = w2a((wchar_t*)password);
			m_hResourceZip = (HANDLE)OpenZip(m_cbZipBuf, len, pwd);
			if (pwd)
			{
				delete[] pwd;
				pwd = NULL;
			}
#else
			m_hResourceZip = (HANDLE)OpenZip(m_cbZipBuf, len, password);
#endif
		}
	}

	void CPaintManagerUI::SetResourceZip(LPCTSTR pStrPath, bool bCachedResourceZip, LPCTSTR password)
	{
		if (m_pStrResourceZip == pStrPath && m_bCachedResourceZip == bCachedResourceZip) return;
		if (m_bCachedResourceZip && m_hResourceZip != NULL)
		{
			CloseZip((HZIP)m_hResourceZip);
			m_hResourceZip = NULL;
		}
		m_pStrResourceZip = pStrPath;
		m_bCachedResourceZip = bCachedResourceZip;
		m_pStrResourceZipPwd = password;
		if (m_bCachedResourceZip)
		{
			CDuiString sFile = CPaintManagerUI::GetResourcePath();
			sFile += CPaintManagerUI::GetResourceZip();
#ifdef UNICODE
			char* pwd = w2a((wchar_t*)password);
			m_hResourceZip = (HANDLE)OpenZip(sFile.GetData(), pwd);
			if (pwd)
			{
				delete[] pwd;
				pwd = NULL;
			}
#else
			m_hResourceZip = (HANDLE)OpenZip(sFile.GetData(), password);
#endif
		}
	}

	void CPaintManagerUI::SetResourceType(int nType)
	{
		m_nResType = nType;
	}

	int CPaintManagerUI::GetResourceType()
	{
		return m_nResType;
	}

	bool CPaintManagerUI::GetHSL(short* H, short* S, short* L)
	{
		*H = m_H;
		*S = m_S;
		*L = m_L;
		return m_bUseHSL;
	}

	void CPaintManagerUI::SetHSL(bool bUseHSL, short H, short S, short L)
	{
		if (m_bUseHSL || m_bUseHSL != bUseHSL)
		{
			m_bUseHSL = bUseHSL;
			if (H == m_H && S == m_S && L == m_L) return;
			m_H = CLAMP(H, 0, 360);
			m_S = CLAMP(S, 0, 200);
			m_L = CLAMP(L, 0, 200);
			AdjustSharedImagesHSL();
			for (int i = 0; i < m_aPreMessages.GetSize(); i++)
			{
				CPaintManagerUI* pManager = static_cast<CPaintManagerUI*>(m_aPreMessages[i]);
				if (pManager != NULL) pManager->AdjustImagesHSL();
			}
		}
	}

	void CPaintManagerUI::ReloadSkin()
	{
		ReloadSharedImages();
		for (int i = 0; i < m_aPreMessages.GetSize(); i++)
		{
			CPaintManagerUI* pManager = static_cast<CPaintManagerUI*>(m_aPreMessages[i]);
			pManager->ReloadImages();
		}
	}

	CPaintManagerUI* CPaintManagerUI::GetPaintManager(LPCTSTR pstrName)
	{
		if (pstrName == NULL) return NULL;
		CDuiString sName = pstrName;
		if (sName.IsEmpty()) return NULL;
		for (int i = 0; i < m_aPreMessages.GetSize(); i++)
		{
			CPaintManagerUI* pManager = static_cast<CPaintManagerUI*>(m_aPreMessages[i]);
			if (pManager != NULL && sName == pManager->GetName()) return pManager;
		}
		return NULL;
	}

	CStdPtrArray* CPaintManagerUI::GetPaintManagers()
	{
		return &m_aPreMessages;
	}

	bool CPaintManagerUI::LoadPlugin(LPCTSTR pstrModuleName)
	{
		ASSERT(!::IsBadStringPtr(pstrModuleName, -1) || pstrModuleName == NULL);
		if (pstrModuleName == NULL) return false;
		HMODULE hModule = ::LoadLibrary(pstrModuleName);
		if (hModule != NULL)
		{
			LPCREATECONTROL lpCreateControl = (LPCREATECONTROL)::GetProcAddress(hModule, "CreateControl");
			if (lpCreateControl != NULL)
			{
				if (m_aPlugins.Find(lpCreateControl) >= 0) return true;
				m_aPlugins.Add(lpCreateControl);
				return true;
			}
		}
		return false;
	}

	CStdPtrArray* CPaintManagerUI::GetPlugins()
	{
		return &m_aPlugins;
	}

	HWND CPaintManagerUI::GetPaintWindow() const
	{
		return m_hWndPaint;
	}

	HWND CPaintManagerUI::GetTooltipWindow() const
	{
		return m_hwndTooltip;
	}
	int CPaintManagerUI::GetHoverTime() const
	{
		return m_iHoverTime;
	}

	void CPaintManagerUI::SetHoverTime(int iTime)
	{
		m_iHoverTime = iTime;
	}

	LPCTSTR CPaintManagerUI::GetName() const
	{
		return m_sName;
	}

	HDC CPaintManagerUI::GetPaintDC() const
	{
		return m_hDcPaint;
	}

	POINT CPaintManagerUI::GetMousePos() const
	{
		return m_ptLastMousePos;
	}

	SIZE CPaintManagerUI::GetClientSize() const
	{
		RECT rcClient = { 0 };
		::GetClientRect(m_hWndPaint, &rcClient);
		return CDuiSize(rcClient.right - rcClient.left, rcClient.bottom - rcClient.top);
	}

	SIZE CPaintManagerUI::GetInitSize()
	{
		return m_szInitWindowSize;
	}

	void CPaintManagerUI::SetInitSize(int cx, int cy)
	{
		m_szInitWindowSize.cx = cx;
		m_szInitWindowSize.cy = cy;
		if (m_pRoot == NULL && m_hWndPaint != NULL)
		{
			::SetWindowPos(m_hWndPaint, NULL, 0, 0, cx, cy, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
		}
	}

	RECT CPaintManagerUI::GetSizeBox()
	{
		return GetDPIObj()->Scale(m_rcSizeBox);
	}

	void CPaintManagerUI::SetSizeBox(RECT& rcSizeBox)
	{
		m_rcSizeBox = rcSizeBox;
	}

	RECT CPaintManagerUI::GetCaptionRect()
	{
		return GetDPIObj()->Scale(m_rcCaption);
	}

	void CPaintManagerUI::SetCaptionRect(RECT& rcCaption)
	{
		m_rcCaption = rcCaption;
	}

	SIZE CPaintManagerUI::GetRoundCorner()
	{
		return GetDPIObj()->Scale(m_szRoundCorner);
	}

	void CPaintManagerUI::SetRoundCorner(int cx, int cy)
	{
		m_szRoundCorner.cx = cx;
		m_szRoundCorner.cy = cy;
	}

	SIZE CPaintManagerUI::GetMinInfo()
	{
		return GetDPIObj()->Scale(m_szMinWindow);
	}

	void CPaintManagerUI::SetMinInfo(int cx, int cy)
	{
		ASSERT(cx >= 0 && cy >= 0);
		m_szMinWindow.cx = cx;
		m_szMinWindow.cy = cy;
	}

	SIZE CPaintManagerUI::GetMaxInfo()
	{
		return GetDPIObj()->Scale(m_szMaxWindow);
	}

	void CPaintManagerUI::SetMaxInfo(int cx, int cy)
	{
		ASSERT(cx >= 0 && cy >= 0);
		m_szMaxWindow.cx = cx;
		m_szMaxWindow.cy = cy;
	}

	bool CPaintManagerUI::IsShowUpdateRect()
	{
		return m_bShowUpdateRect;
	}

	void CPaintManagerUI::SetShowUpdateRect(bool show)
	{
		m_bShowUpdateRect = show;
	}

	bool CPaintManagerUI::IsNoActivate()
	{
		return m_bNoActivate;
	}

	void CPaintManagerUI::SetNoActivate(bool bNoActivate)
	{
		m_bNoActivate = bNoActivate;
	}

	BYTE CPaintManagerUI::GetOpacity() const
	{
		return m_nOpacity;
	}

	void CPaintManagerUI::SetOpacity(BYTE nOpacity)
	{
		m_nOpacity = nOpacity;
		if (m_hWndPaint != NULL)
		{
			typedef BOOL(__stdcall* PFUNCSETLAYEREDWINDOWATTR)(HWND, COLORREF, BYTE, DWORD);
			PFUNCSETLAYEREDWINDOWATTR fSetLayeredWindowAttributes = NULL;

			HMODULE hUser32 = ::GetModuleHandle(_T("User32.dll"));
			if (hUser32)
			{
				fSetLayeredWindowAttributes =
					(PFUNCSETLAYEREDWINDOWATTR)::GetProcAddress(hUser32, "SetLayeredWindowAttributes");
				if (fSetLayeredWindowAttributes == NULL) return;
			}

			DWORD dwStyle = ::GetWindowLong(m_hWndPaint, GWL_EXSTYLE);
			DWORD dwNewStyle = dwStyle;
			if (nOpacity >= 0 && nOpacity < 256) dwNewStyle |= WS_EX_LAYERED;
			else dwNewStyle &= ~WS_EX_LAYERED;
			if (dwStyle != dwNewStyle) ::SetWindowLong(m_hWndPaint, GWL_EXSTYLE, dwNewStyle);
			fSetLayeredWindowAttributes(m_hWndPaint, 0, nOpacity, LWA_ALPHA);
		}
	}

	bool CPaintManagerUI::IsLayered()
	{
		return m_bLayered;
	}

	void CPaintManagerUI::SetLayered(bool bLayered)
	{
		if (m_hWndPaint != NULL && bLayered != m_bLayered)
		{
			UINT uStyle = GetWindowStyle(m_hWndPaint);
			if ((uStyle & WS_CHILD) != 0) return;
			if (g_fUpdateLayeredWindow == NULL)
			{
				HMODULE hUser32 = ::GetModuleHandle(_T("User32.dll"));
				if (hUser32)
				{
					g_fUpdateLayeredWindow =
						(PFUNCUPDATELAYEREDWINDOW)::GetProcAddress(hUser32, "UpdateLayeredWindow");
					if (g_fUpdateLayeredWindow == NULL) return;
				}
			}
			m_bLayered = bLayered;
			if (m_pRoot != NULL) m_pRoot->NeedUpdate();
			Invalidate();
		}
	}

	RECT& CPaintManagerUI::GetLayeredInset()
	{
		return m_rcLayeredInset;
	}

	void CPaintManagerUI::SetLayeredInset(RECT& rcLayeredInset)
	{
		m_rcLayeredInset = rcLayeredInset;
		m_bLayeredChanged = true;
		Invalidate();
	}

	BYTE CPaintManagerUI::GetLayeredOpacity()
	{
		return m_nOpacity;
	}

	void CPaintManagerUI::SetLayeredOpacity(BYTE nOpacity)
	{
		m_nOpacity = nOpacity;
		m_bLayeredChanged = true;
		Invalidate();
	}

	LPCTSTR CPaintManagerUI::GetLayeredImage()
	{
		return m_diLayered.sDrawString;
	}

	void CPaintManagerUI::SetLayeredImage(LPCTSTR pstrImage)
	{
		m_diLayered.sDrawString = pstrImage;
		RECT rcNull = { 0 };
		CRenderEngine::DrawImageInfo(NULL, this, rcNull, rcNull, &m_diLayered);
		m_bLayeredChanged = true;
		Invalidate();
	}

	CShadowUI* CPaintManagerUI::GetShadow()
	{
		return &m_shadow;
	}

	void CPaintManagerUI::SetUseGdiplusText(bool bUse)
	{
		m_bUseGdiplusText = bUse;
	}

	bool CPaintManagerUI::IsUseGdiplusText() const
	{
		return m_bUseGdiplusText;
	}

	void CPaintManagerUI::SetGdiplusTextRenderingHint(int trh)
	{
		m_trh = trh;
	}

	int CPaintManagerUI::GetGdiplusTextRenderingHint() const
	{
		return m_trh;
	}

	bool CPaintManagerUI::PreMessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lRes)
	{
		for (int i = 0; i < m_aPreMessageFilters.GetSize(); i++)
		{
			bool bHandled = false;
			LRESULT lResult = static_cast<IMessageFilterUI*>(m_aPreMessageFilters[i])->MessageHandler(uMsg, wParam, lParam, bHandled);
			if (bHandled)
			{
				lRes = lResult;
				return true;
			}
		}
		switch (uMsg)
		{
			case WM_KEYDOWN:
			{
				// Tabbing between controls
				if (wParam == VK_TAB)
				{
					if (m_pFocus && m_pFocus->IsVisible() && m_pFocus->IsEnabled() && _tcsstr(m_pFocus->GetClass(), _T("RichEditUI")) != NULL)
					{
						if (static_cast<CRichEditUI*>(m_pFocus)->IsWantTab()) return false;
					}
					if (m_pFocus && m_pFocus->IsVisible() && m_pFocus->IsEnabled() && _tcsstr(m_pFocus->GetClass(), _T("WkeWebkitUI")) != NULL)
					{
						return false;
					}
					SetNextTabControl(::GetKeyState(VK_SHIFT) >= 0);
					return false;
				}
			}
			break;
			case WM_SYSCHAR:
			{
				// Handle ALT-shortcut key-combinations
				FINDSHORTCUT fs = { 0 };
				fs.ch = toupper((int)wParam);
				CControlUI* pControl = m_pRoot->FindControl(__FindControlFromShortcut, &fs, UIFIND_ENABLED | UIFIND_ME_FIRST | UIFIND_TOP_FIRST);
				if (pControl != NULL)
				{
					pControl->SetFocus();
					pControl->Activate();
					return true;
				}
			}
			break;
			case WM_SYSKEYDOWN:
			{
				if (m_pFocus != NULL)
				{
					TEventUI event = { 0 };
					event.Type = UIEVENT_SYSKEY;
					event.chKey = (TCHAR)wParam;
					event.ptMouse = m_ptLastMousePos;
					event.wKeyState = MapKeyState();
					event.dwTimestamp = ::GetTickCount();
					m_pFocus->Event(event);
				}
			}
			break;
		}
		return false;
	}

	bool CPaintManagerUI::MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lRes)
	{
		if (m_hWndPaint == NULL) return false;

		// ------------------------------------------------------------------
		// [临时诊断] 心跳快照。每 2 秒最多一条，记录三个窗口的触摸注册 / 前台 / 焦点状态。
		//
		// 为什么必须要有它：如果系统压根不给弹框投任何消息（这正是当前症状 ——
		// 弹框只收到 WM_MOUSEMOVE，零 WM_TOUCH），那么"收到消息才打日志"的诊断就永远
		// 触发不了，日志里只会看到一片沉默，无法区分下面两种完全不同的情况：
		//   (a) 弹框的触摸注册丢了 → 系统根本不会给它投 WM_TOUCH；
		//   (b) 注册没丢，但所有权（greedy ownership）还在 owner 手里 → 投给了 owner。
		// 心跳能直接分辨 (a)/(b)，因为它主动去问系统"谁现在注册着触摸"。
		// ------------------------------------------------------------------
		{
			static DWORD s_dwLastHeartbeat = 0;
			const DWORD dwNowHb = ::GetTickCount();
			// 2000ms：常规节奏。调试期曾临时调到 1000ms 以便核对滑动轨迹
			// （每 2 秒一条在快速滑动时样本太少，看不出 Δ 轨迹）；
			// 触摸功能已验证正常（主窗口 / 模态弹框的点击与滑动均可用），故改回 2000ms。
			if ((LONG)(dwNowHb - s_dwLastHeartbeat) >= 2000)
			{
				s_dwLastHeartbeat = dwNowHb;
				// [手势让路] 打点前先取一份本 manager 的输入通道状态：
				//   ptrActive=1  ⇒ 本次手势正由指针通道驱动（WM_TOUCH 会被忽略）
				//   ptrYield=1   ⇒ 本次手势已让给 WM_TOUCH（指针消息会被忽略）
				// 两者都为 0 ⇒ 两条通道都空闲，下一次触摸谁先到谁驱动。
				const int bNewGestureActive = (int)m_bPointerGestureActive;
				const DWORD dwNewActivePointerId = m_dwActivePointerId;
				const int bNewPointerYielded = (m_pEventTouch != NULL) ? 1 : 0;
				HMODULE hU32 = ::GetModuleHandle(_T("user32.dll"));
				typedef BOOL (WINAPI* PFN_IS_TOUCH_WINDOW)(HWND, PULONG);
				PFN_IS_TOUCH_WINDOW pfnIsTouch = (hU32 != NULL)
					? reinterpret_cast<PFN_IS_TOUCH_WINDOW>(::GetProcAddress(hU32, "IsTouchWindow")) : NULL;
				ULONG tfSelf = 0, tfModal = 0;
				const BOOL bSelf = (pfnIsTouch != NULL) ? pfnIsTouch(m_hWndPaint, &tfSelf) : FALSE;
				HWND hModal = s_hModalWindow;
				const BOOL bModal = (pfnIsTouch != NULL && hModal != NULL && ::IsWindow(hModal))
					? pfnIsTouch(hModal, &tfModal) : FALSE;
				DuiLibDiag::Log(_T("HEARTBEAT hb self=%p reg=%d tf=0x%X | modal=%p reg=%d tf=0x%X | ownerofModal=%p | fg=%p focus=%p active=%p | managerMsgs=%u | ptrActive=%d ptrId=%u ptrYield=%d"),
					(void*)m_hWndPaint, (int)bSelf, (unsigned)tfSelf,
					(void*)hModal, (int)bModal, (unsigned)tfModal,
					(hModal != NULL) ? (void*)::GetWindow(hModal, GW_OWNER) : NULL,
					(void*)::GetForegroundWindow(), (void*)::GetFocus(), (void*)::GetActiveWindow(),
					(unsigned)uMsg,
					(int)bNewGestureActive, (unsigned)dwNewActivePointerId, (int)bNewPointerYielded);
			}
		}

		// ------------------------------------------------------------------
		// 触摸状态超时自愈（防“窗口突然完全点不动”）：
		// TOUCHDOWN 会置起 m_pEventTouch，合成点击后会置起 m_bSuppressPromotedTouchMouse；
		// 若对应的 TOUCHUP / 提升的 WM_LBUTTONUP 因故丢失（手势被系统中断、激活或前台被抢、
		// 窗口被遮挡、消息被别处吞掉等），这两个状态会永久残留 → 之后所有提升的鼠标消息都被
		// 当成“触摸重复”吞掉，表现为“点着点着就完全没反应了”。这里粗粒度复位保证能自愈。
		//
		// ⚠️ 计时基准的优先级：m_dwTouchDownTick（本次手势的"按下"时刻）优先，
		// 退化到 m_dwSuppressTick（抑制位被置的时刻）。这是**有意**的设计：
		// 手势一开始 m_pEventTouch 就被置起，用"按下时刻"计时才能真的在 3 秒内自愈；
		// 若只按 m_dwSuppressTick（合成点击后才置），TOUCHUP 丢失时它可能一直是 0，
		// 条件永远不成立 ⇒ 状态永久残留 ⇒【所有窗口点击彻底失效】。这是实测踩过的坑。
		//
		// ⚠️⚠️⚠️【真机 bug 根治点：模态期间绝不自愈】⚠️⚠️⚠️
		//
		// 现象（Win10）：点商品控件弹属性框；3 秒内点"选好了"正常；
		//   超过 3 秒再点"选好了"，弹框关掉的同时会**透点**到背后那个商品控件。
		//   Win7 上对应的现象是"弹框刚出来就被自动点掉 / 咚一声"。
		//
		// 成因：这段超时**只看时间**，不看"当前是不是模态开着"。
		//   · 点商品控件的那个手势在 tap-commit 时置起 m_bSuppressPromotedTouchMouse
		//     （用途：吞掉这次手势随后被系统"提升"出来的重复鼠标消息）；
		//   · 紧接着回调里 ShowModal() 开了**嵌套模态循环**，本次手势的残留提升消息
		//     只能等弹框关闭后才被投递出来；
		//   · 若用户在弹框里停留超过 3 秒，这段超时就会先把抑制位**清掉**；
		//   · 等弹框一关，那条残留的提升消息终于投出来时，抑制位已经没了 ⇒ **放行**
		//     ⇒ 它就是"第二次点击"，于是自动点了弹框里的按钮 / 咚 / 透点到背后控件。
		//
		// 也就是说：模态开启期间，这些状态**本来就是"故意冻结"的**（在等模态循环返回），
		// 不是"卡住了"。用超时去清它，等于亲手拆掉唯一的防线 —— 这正是前两轮没改好的地方。
		//
		// 修法：模态存续期间**跳过**本超时（保留状态），等模态结束后再让超时正常兜底。
		//   判据用 GetModalWindow()：真模态在 __DialogProc 里登记、__DialogWndProc 的
		//   WM_NCDESTROY 里清除，生命周期与"嵌套循环是否还在跑"严格一致。
		//   本窗口自己就是当前模态弹框时同样跳过（它也在等自己的循环结束）。
		//
		// 配套：tap-commit 分支**不应**再清 m_dwTouchDownTick（本函数已不再在模态期间
		//   依赖它），去掉那两处会让基准语义更直白：抑制位从置位起算 3 秒，
		//   而模态期间计时整体暂停。
		// ==================================================================
		// ⚠️⚠️⚠️【已彻底删除：TOUCH-STATE 3000ms 超时自愈】⚠️⚠️⚠️
		//
		// 用户明确要求：「这里为什么要加个3秒的逻辑？能不能删除这个逻辑？
		//                 不要时间戳，完全根据状态来判断。」
		//
		// 这里原本有一段：若 (Now - 基准) > 3000ms，就把 m_pEventTouch /
		//   m_bSuppressPromotedTouchMouse / m_dwTouchDownTick / m_bTouchSlideActive
		//   全部强制清掉，目的是"防 TOUCHUP 丢失导致状态永久悬空"。
		//
		// **它是纯有害的，已整段删除。** 理由（三条，任何一条都足以判它死刑）：
		//
		//   ① 它本身就是"3 秒透点"的成因。
		//      点商品控件 → 手势在 tap-commit 置起 m_bSuppressPromotedTouchMouse
		//      （用途：吞掉这次手势随后被系统"提升"出来的重复鼠标消息）→
		//      紧接着回调里 ShowModal() 开**嵌套模态循环**，残留的提升消息只能等
		//      弹框关闭后才被投递出来。若用户在弹框里停留超过 3 秒，这段超时就会
		//      先把抑制位**清掉** ⇒ 弹框一关，那条残留消息终于投出来时抑制位已经没了
		//      ⇒ **放行** ⇒ 它就是"第二次点击" ⇒ **透点到背后的商品控件**。
		//      这精确解释了用户看到的「3 秒内正常、超过 3 秒就透点」。
		//
		//   ② 它"自愈"的那些状态**根本不需要自愈 —— 泄漏是不可能的**。
		//      逐条核对（这就是"完全根据状态判断"的可行性证明）：
		//        · m_bSuppressPromotedTouchMouse：置真只发生在**已合成点击**的分支
		//          （OnTouchInput / OnPointerInput 的 UP）。合成点击是一次真实的
		//          BUTTONDOWN + BUTTONUP **配对**派发，系统必然随后投递配对的
		//          WM_LBUTTONDOWN/UP；MessageHandler 的拦截块收到 UP 时就会把它清掉
		//          （见 PROMOTED-MOUSE swallowed 那段：`if (uMsg == WM_LBUTTONUP) ... = false;`）。
		//          即便那对提升消息真的丢了，下次手势正常点击时也必然被重置。
		//        · m_pEventTouch：由 UP / CAPTURECHANGED 清，且下次 DOWN 时
		//          BeginTouchSlideGesture 无条件置 NULL 后重建 ⇒ 不可能跨手势残留。
		//        · m_dwTouchDownTick / m_dwSuppressTick：纯时间戳，无功能语义
		//          （唯一的消费者就是这段被删掉的超时）。
		//        · m_bTouchSlideActive：由 EndTouchSlideGesture 置假，且下次 Begin 重建。
		//      ⇒ 当年加它，是因为**真正的泄漏源在别处**（释放捕获时序、
		//        AttachPaintWindow 漏清输入态等，均已单独修复）。
		//        那两处修好之后，这个超时就成了纯粹的"定时炸弹"。
		//
		//   ③ 它是"周期性"触发的 —— 判断块在 MessageHandler 开头，每条窗口消息都会跑。
		//      所以"偶发"其实一点都不偶发：任何一条消息到达且距基准 >3 秒，状态就被清。
		//      这也解释了为什么这个 bug 如此容易复现。
		//
		// 【删除后的依据（全部是状态，没有时间）】
		//   · 手势进行中    → m_pEventTouch != NULL / m_bTouchSlideActive
		//   · 刚合成过点击  → m_bSuppressPromotedTouchMouse（由配对的提升 UP 销账）
		//   · 模态是否存续  → GetModalWindow()（在 __DialogProc 登记、WM_NCDESTROY 清除）
		//   · 抬起/取消/捕获被夺 → TOUCHUP / POINTERUP / CAPTURECHANGED 各自清干净
		//   没有任何一条依赖"过了多久"。
		// ==================================================================

		// 当前是否处于"模态存续中"。保留这个查询仅为下方**指针通道**的手势自愈
		// 提供同样的"模态期间冻结"语义（见下），不再用于清触摸抑制位。
		const HWND hModalNow = CPaintManagerUI::GetModalWindow();
		const bool bModalAlive = (hModalNow != NULL && ::IsWindow(hModalNow));

		// ==================================================================
		// ⚠️⚠️⚠️【已彻底删除：POINTER-GESTURE 3000ms 超时自愈】⚠️⚠️⚠️
		//
		// 与上面被删的 TOUCH-STATE 超时是**同一类错误**，一并删除。
		// 原文：若 (Now - m_dwPointerDownTick) > 3000ms，强制把
		//   m_bPointerGestureActive / m_dwActivePointerId / m_bTouchSlideActive /
		//   m_pEventTouch 全部清掉。
		//
		// 为什么它同样是纯有害的：
		//
		//   ① 【致命】模态存续期间它会把 m_pEventTouch 清成 NULL ——
		//      而 m_pEventTouch 正是"刚合成过点击、必须吞掉随后那条提升鼠标消息"
		//      这个**授权标记**。弹框停留 >3 秒 ⇒ 标记被清 ⇒ 弹框关闭瞬间那条残留的
		//      提升鼠标消息漏网 ⇒ 透点到背后的商品控件（Win10 那个 bug 的另一半成因）。
		//
		//   ② 它自愈的状态同样**不会泄漏**（和上面一样，逐条可查）：
		//        · m_bPointerGestureActive：UP / CAPTURECHANGED 清，且下次 DOWN 时
		//          `if (m_bPointerGestureActive && id 相同) return true;` 只挡**同一 id**
		//          的重复 DOWN，换了 id 会正常重建 ⇒ 不会永久卡死。
		//        · m_dwActivePointerId / m_dwPointerDownTick：纯记账字段，无功能语义。
		//        · m_bTouchSlideActive / m_pEventTouch：由 EndTouchSlideGesture 与
		//          下次 BeginTouchSlideGesture 负责，不依赖时间。
		//
		//   ③ 当年加它的理由是"WM_POINTERUP 可能丢失导致永久点不动"。
		//      那个症状的**真因**已单独修复（见 WM_POINTERUP 让路把 UP 一起吞掉
		//      导致状态永久为真 —— 现在的规则是"UP/UPDATE 一律送到 OnPointerInput，
		//      绝不吞 UP"）。真因修好后，这个超时就成了定时炸弹。
		//
		// 【删除后的依据（全部是状态）】
		//   · 本次指针手势的归属 → m_bPointerGestureActive + m_dwActivePointerId
		//   · 手势是否已结束     → DUI_WM_POINTERUP（无条件走完全程）
		//   · 捕获是否被夺       → DUI_WM_POINTERCAPTURECHANGED（无条件清）
		//   · 是否处于模态       → bModalAlive（模态期间本来就不该有任何手势状态变化）
		// ==================================================================
		// 说明：bModalAlive 保留在作用域内，便于以后需要时按"状态"而不是"时间"做判断。
		(void)bModalAlive;

		// ==================================================================
		// ★★【透传根治 · 跨模态边界的提升鼠标消息必须作废】★★
		//
		// 来源：用户真机日志（touch_trace.log）实测出的**唯一**一条透传链路。
		//   —— 前几轮所有"按 GetModalWindow() 判定"的闸门（MODAL-BACKDROP /
		//      MODAL-GATE-CHECK / TOUCHUP ABORT）在真机日志里出现 **0 次**，
		//      因为透传消息到达时模态**已经结束**，判据根本不成立。
		//
		// 【真实现场】以日志中 270590750 那次为例（w/l/extra 完全相同，
		//   证明它们属于**同一次触摸**被系统提升出来的一对鼠标消息）：
		//
		//     WM_LBUTTONUP   extra=0xFF515782   ← ① 先到，被正常处理
		//     LBUTTONUP moved=0 click=diandan_fooditem
		//     REGISTER hwnd=005B05A8            ← ★ 同步进入 ShowModal() 嵌套循环
		//     ...（模态循环整段：detach/init/attach/resize，弹框完整生命周期）...
		//     MODAL-DLG exit ret=1              ← 用户在弹框里点了「选好了」
		//     WM_LBUTTONDOWN extra=0xFF515782   ← ② 循环一退，卡住的这条立刻被取出
		//     LBUTTONDOWN hit name=diandan_fooditem   ← ★★ 建立候选点击 = 透传
		//     WM_LBUTTONUP   extra=0xFF515782   ← 再配一次抬起
		//     LBUTTONUP click=diandan_fooditem  ← ★★ 商品卡被派发第二遍
		//
		// 【为什么是"一对"】Windows 为一次触摸提升出 DOWN/UP 两条消息，
		//   两条都排在**同一个线程**的消息队列里。① 的 UP 处理过程中同步进入了
		//   模态循环（DialogBoxIndirectParam 是阻塞调用），循环期间消息泵继续抽队列，
		//   但弹框自己持有捕获、且 owner 被 EnableWindow(FALSE) 禁用 —— 队列里属于
		//   主窗口的 ② 抽不出来（消息无法投给禁用窗口，会被 MessageBeep 顶回队列）。
		//   等 ③ 弹框 EndDialog、owner 重新启用、**且** GetModalWindow() 归零之后，
		//   ② 才终于被投递 ⇒ 于是它带着"上一次手势的身份"干了"这一次交互"的活。
		//
		// 【判据为什么必须用"代数"而不是"当前是否模态"】
		//   ② 到达时 modal 已经是 NULL —— 任何看"此刻模态是否开着"的条件都不可能成立。
		//     真机日志里 MODAL-BACKDROP / MODAL-GATE-CHECK / TOUCHUP ABORT 出现 0 次，
		//     正是这个原因（前几轮方向错了）。
		//   能区分 ② 的只有**身份**："它属于模态开启之前的那一次手势"。
		//
		//   而"模态边界"在 MessageHandler 里**无法用边沿检测得到**：
		//     主窗口在整个模态期间收不到任何消息（owner 被 EnableWindow(FALSE)），
		//     所以"上一次看到的 modal"和"这一次看到的 modal"都是 false，
		//     边沿永远不成立 ⇒ 边沿检测方案是无效的（我第一版就是错的）。
		//   ⇒ 边界必须由 ShowModal() **主动**在进入循环前登记，
		//     见 CWindowWnd::ShowModal 里 DuiLib::BumpPromotedMouseGenerationGlobal()。
		//
		//   本块只做一件事：**本条消息的代数水位是否落后于当前代数**。
		//     落后 ⇒ 中间跨过一次模态边界，本条属于边界之前的手势 ⇒ 作废。
		//     持平 ⇒ 同代，正常处理。
		//
		// 【为什么不会误伤】
		//   · 只对 **IsPromotedTouchMouseMessage()** 为真的消息作废 ——
		//     真实鼠标点击不带 MOUSEEVENTF_FROMTOUCH，天然豁免。
		//   · 作废是"整代"的：水位一追上，弹框关闭后用户的下一次触摸就属于
		//     当前代，正常处理。
		//   · 代数/水位是**线程级全局**的（不是 manager 成员）——
		//     因为弹框与主窗口是**两个不同的 manager**，而泄漏是线程消息队列
		//     现象。写成成员时，在弹框 manager 上 +gen、主窗口 manager 看不见，
		//     水位永远持平 ⇒ 拦不住（第一版实测踩过，见 s_nPromotedMouseGeneration
		//     处的长注释）。
		//
		// 【真机日志验证过的完整时序】（本块必须能覆盖它）：
		//     WM_MOUSEMOVE  extra=0xFF515782  ← ① 最先到：跨代 → 置脏；移动放行
		//     WM_LBUTTONDOWN extra=0xFF515782 ← ② 已是同代（水位刚追上），但脏为真
		//                                        ⇒ 吞掉 ✅（不建立候选点击）
		//     WM_LBUTTONUP  extra=0xFF515782  ← ③ 脏仍为真 ⇒ 吞掉并解脏 ✅
		//   ② 的关键：不能只靠"代数落后"来判 —— 因为 ① 已经把水位追上了。
		//   所以必须**置脏 + 脏期内连坐**，否则 ② 会漏过去（这正是"只判代数落后"
		//   写法会失败的地方）。
		// ==================================================================
		if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK
			|| uMsg == WM_MOUSEMOVE)
		{
			// ⚠️ 不要写成 ::IsPromotedTouchMouseMessage() —— 它定义在本文件的
			//   匿名 namespace 内，加全局限定符会报 C2039（不是 global namespace 成员）。
			const bool bPromotedNow = IsPromotedTouchMouseMessage();
			if (bPromotedNow)
			{
				// 本条消息的"手势指纹"。真机同一次手势的几条提升消息 extra 完全相同，
				// 不同手势必不同 ⇒ 可精确界定残留序列的边界。
				const DWORD_PTR dwExtra = (DWORD_PTR)::GetMessageExtraInfo();

				const bool bClickLike = (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP
					|| uMsg == WM_LBUTTONDBLCLK);
				const bool bUpLike = (uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK);

				// ==============================================================
				// ★★【第二次合成点击 · 根治】第一道，也是唯一必需的一道闸 ★★
				//
				// 判据：本条提升消息，是不是"触摸通道刚刚处理过的那次手势"的副本。
				//   · 依据只有"触摸通道收到了这次手势"这一个事实 + 屏幕坐标吻合，
				//     **与模态边界 / 代数水位 / extra 指纹全都无关** ⇒ 对"关闭弹框
				//     的那一次手势"同样有效（旧判据在 Win7 上唯一漏掉的就是它）。
				//   · 命中的处理：点击类一律吞（并且不建立候选点击）；抬手类到达即销账。
				//     移动类放行（不产生点击；仍需维持重绘/光标，悬浮态由"提升移动
				//     不参与 hover"的总闸挡掉）。
				//
				// ⚠️ 必须放在下面"代数水位"那套**之前**：那套是按模态边界近似出来的
				//    版本，在 Win7 上（extra 恒定 ⇒ 指纹失效；水位一次手势就追平）
				//    必然漏掉"关闭弹框那一次"。本闸门是它的严格超集。
				//    先不删旧的，等这两台机器都验过再决定去留。
				// ==============================================================
				{
					POINT ptMsg = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
					if (IsPromotedMouseDuplicate(m_hWndPaint, ptMsg) && bClickLike)
					{
						DuiLibDiag::Log(_T("PROMOTED-DUP swallow msg=0x%04X hwnd=%p extra=0x%08X pt=%d,%d"),
							uMsg, (void*)m_hWndPaint, (unsigned)(dwExtra & 0xFFFFFFFF),
							ptMsg.x, ptMsg.y);
						// 从根上不产生候选点击（抬手自然也不会派发）。
						if (uMsg == WM_LBUTTONDOWN)
							m_pEventClick = NULL;
						if (m_bMouseCapture)
							ReleaseCapture();
						// 【悬浮态残留】把"抑制参考点"钉在本条坐标上：残留序列之后
						// 系统还会补投一条 extra=0 的普通 MOVE，参考点不挪的话那条
						// MOVE 会解除抑制并重建 hover。
						s_bSuppressHoverAfterTouch = true;
						m_bMouseTracking = false;
						m_ptLastTouchPos = ptMsg;
						SetLastTouchScreenPoint(ptMsg);
						// 抬手类到达 ⇒ 这次手势的提升副本已配完 ⇒ 销账。
						if (bUpLike)
							DisarmPromotedMouseDuplicate();
						return true;
					}
				}

				// 跨代 ⇒ 打开"作废窗口"并记下 extra 指纹。
				//
				// ⚠️ 第三版：**移动也开窗**。真机残留是三件套 MOVE+DOWN+UP，
				//   MOVE 最先到；若移动不开窗，紧随的 DOWN 就会漏（第二版实证）。
				if (ConsumeCrossModalPromotedMouse(bClickLike, dwExtra))
				{
					DuiLibDiag::Log(_T("PROMOTED-GEN cross msg=0x%04X hwnd=%p gen=%u click=%d extra=0x%08X pt=%d,%d"),
						uMsg, (void*)m_hWndPaint, (unsigned)s_nPromotedMouseGeneration,
						(int)bClickLike, (unsigned)(dwExtra & 0xFFFFFFFF),
						GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
				}

				// ★ 关键分支：本条是否属于"当前作废的那次残留序列"（按 extra 指纹）。
				if (IsCurrentPromotedResidue(dwExtra))
				{
					if (bClickLike)
					{
						// 残留序列的点击类消息 ⇒ 一律吞，绝不建立候选点击。
						DuiLibDiag::Log(_T("PROMOTED-GEN swallow msg=0x%04X hwnd=%p gen=%u extra=0x%08X pt=%d,%d"),
							uMsg, (void*)m_hWndPaint, (unsigned)s_nPromotedMouseGeneration,
							(unsigned)(dwExtra & 0xFFFFFFFF),
							GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
						if (uMsg == WM_LBUTTONDOWN)
							m_pEventClick = NULL;   // 从根上不产生候选点击
						if (m_bMouseCapture)
							ReleaseCapture();
						// ★【悬浮态残留】把"抑制参考点"钉在本条残留消息的坐标上。
						//   原因（真机日志实证）：残留序列 MOVE+DOWN+UP 之后，系统还会
						//   补投一条 extra=0x00000000、fromtouch=0 的普通 WM_MOUSEMOVE
						//   （表示"指针真的停在这"）。它不是提升消息，绕不过悬浮总闸；
						//   而此时 m_ptLastTouchPos 还停在弹框内"选好了"的位置（如 496,561），
						//   与残留点（如 779,645）相距远超 8px ⇒ WM_MOUSEMOVE 里那条
						//   ±8px 判据会**主动解除** s_bSuppressHoverAfterTouch，
						//   于是 FindControl(pt) 命中背后商品并建立 hover（HOVER-ENTER）。
						//   这里先把抑制位重新立起来、并把参考点挪到残留点上，那条补投的
						//   MOVE 坐标与参考点几乎重合 ⇒ 落在 ±8px 内被 break，不建立悬浮态。
						//   纯状态判据，不看时间。
						s_bSuppressHoverAfterTouch = true;
						m_bMouseTracking = false;
						POINT ptResidue = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
						m_ptLastTouchPos = ptResidue;
						SetLastTouchScreenPoint(ptResidue);
						// 抬手类到达 ⇒ 序列收尾 ⇒ 关窗（纯状态，不看时间）。
						if (bUpLike)
							ClearPromotedMouseGenTaint();
						return true;
					}
					// 残留序列的移动消息 ⇒ 放行（不产生点击；仍需维持重绘/光标）。
					// 悬浮态已被"提升移动不参与 hover"的总闸挡掉。
				}
				else if (s_bPromotedMouseGenTainted)
				{
					// ★ extra 变了 ⇒ 换了一次手势 ⇒ 残留序列已经结束（哪怕它的 UP 丢了）。
					//   这是第四版最重要的防御：不再依赖"必须等到 UP 才关窗"。
					DuiLibDiag::Log(_T("PROMOTED-GEN close-by-extra msg=0x%04X hwnd=%p gen=%u oldextra=0x%08X newextra=0x%08X"),
						uMsg, (void*)m_hWndPaint, (unsigned)s_nPromotedMouseGeneration,
						(unsigned)(s_dwPromotedMouseTaintExtra & 0xFFFFFFFF),
						(unsigned)(dwExtra & 0xFFFFFFFF));
					ClearPromotedMouseGenTaint();
					// ★【悬浮态残留】同上：新手势的残留点也要成为抑制参考点，
					//   否则紧跟的 extra=0 补投 MOVE 会解除抑制并建立悬浮态。
					s_bSuppressHoverAfterTouch = true;
					m_bMouseTracking = false;
					POINT ptNewGen = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
					m_ptLastTouchPos = ptNewGen;
					SetLastTouchScreenPoint(ptNewGen);
					// 关窗后本条按正常流程继续处理（它属于新手势，应当放行）。
				}
			}
			else
			{
				// 真实鼠标（非提升）的输入 ⇒ 输入源已切换，立即关窗。
				// 纯状态判据，不看时间。
				if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
					SettlePromotedMouseGeneration();
			}
		}

		if (uMsg == WM_TOUCH || uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP)
		{
			// [临时诊断] 顺带把"本窗口 / 模态弹框 / 前台窗口"三者的触摸注册状态打出来。
			// 关键疑点：弹框在 ShowModal 里 RegisterTouchWindow 过，但初始化时可能又被
			// InitTouchSupport 之外的路径改掉样式（WS_EX_* 变更会隐式注销触摸注册），
			// 一旦注册丢失，系统就绝不会再给弹框投 WM_TOUCH —— 这与"零 WNDPROC-TOUCH"完全吻合。
			// IsTouchWindow(hwnd, &flags)：TRUE 表示该窗口当前确实在触摸注册表里。
			HMODULE hU32 = ::GetModuleHandle(_T("user32.dll"));
			typedef BOOL (WINAPI* PFN_IS_TOUCH_WINDOW)(HWND, PULONG);
			PFN_IS_TOUCH_WINDOW pfnIsTouch = (hU32 != NULL)
				? reinterpret_cast<PFN_IS_TOUCH_WINDOW>(::GetProcAddress(hU32, "IsTouchWindow")) : NULL;
			ULONG tfSelf = 0, tfModal = 0, tfFg = 0;
			const BOOL bSelf = (pfnIsTouch != NULL) ? pfnIsTouch(m_hWndPaint, &tfSelf) : FALSE;
			HWND hModal = s_hModalWindow;
			const BOOL bModal = (pfnIsTouch != NULL && hModal != NULL && ::IsWindow(hModal))
				? pfnIsTouch(hModal, &tfModal) : FALSE;
			HWND hFg = ::GetForegroundWindow();
			const BOOL bFg = (pfnIsTouch != NULL && hFg != NULL) ? pfnIsTouch(hFg, &tfFg) : FALSE;

			DuiLibDiag::Log(_T("MANAGER-MSG hwnd=%p manager=%p msg=0x%04X w=0x%p l=0x%p touch=%p suppress=%d"),
				(void*)m_hWndPaint, (void*)this, uMsg, (void*)wParam, (void*)lParam,
				(void*)m_pEventTouch, (int)m_bSuppressPromotedTouchMouse);
			DuiLibDiag::Log(_T("TOUCHREG self=%p reg=%d tf=0x%X | modal=%p reg=%d tf=0x%X | fg=%p reg=%d tf=0x%X | focus=%p active=%p"),
				(void*)m_hWndPaint, (int)bSelf, (unsigned)tfSelf,
				(void*)hModal, (int)bModal, (unsigned)tfModal,
				(void*)hFg, (int)bFg, (unsigned)tfFg,
				(void*)::GetFocus(), (void*)::GetActiveWindow());
		}

		// ==================================================================
		// [第十一轮诊断] 点击类鼠标消息的完整现场快照。
		//
		// 前两轮的静态推理都被真机证伪（改完仍复现），所以这一轮先把"事实"钉死：
		// 对每一条 WM_LBUTTONDOWN/UP/DBLCLK，无条件打印它与判定相关的**全部**输入：
		//   promoted  = 是否触摸提升（MOUSEEVENTF_FROMTOUCH）
		//   target    = 本条消息落在哪个 HWND（m_hWndPaint）
		//   modal     = 此刻 GetModalWindow() 是谁（NULL 说明模态已结束）
		//   ownerOfM  = 弹框的 owner（用于判断 IsModalInputTarget 的两个分支）
		//   touch/supp/modalbit/pending = 四个状态位
		//   enable    = target 是否处于启用状态（禁用则系统会 MessageBeep）
		//
		// 有了这张表，三个 bug 各自是哪条消息、投给了谁、当时状态如何，一眼可辨，
		// 不必再猜。待问题定位后可整块删除。
		// ==================================================================
		if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
		{
			HWND hModalDbg = CPaintManagerUI::GetModalWindow();
			DuiLibDiag::Log(_T("CLICKTRACE msg=0x%04X target=%p promoted=%d modal=%p ownerOfModal=%p touch=%p supp=%d modalbit=%d pending=%d enable=%d extra=0x%p"),
				uMsg, (void*)m_hWndPaint, (int)IsPromotedTouchMouseMessage(),
				(void*)hModalDbg,
				(hModalDbg != NULL && ::IsWindow(hModalDbg)) ? (void*)::GetWindow(hModalDbg, GW_OWNER) : NULL,
				(void*)m_pEventTouch, (int)m_bSuppressPromotedTouchMouse,
				(int)m_bSuppressPromotedMouseForModal, m_nPromotedMousePending,
				(int)::IsWindowEnabled(m_hWndPaint),
				(void*)::GetMessageExtraInfo());
		}

		// ==================================================================
		// ★★【模态背闸】弹框还开着时，背景窗口不处理任何"点击类"输入。
		//
		// 这是"点弹框的『选好了』→ 透传到主窗口商品卡"的**入口根治**，
		// 覆盖鼠标通道（触摸通道的对应闸门见 OnPointerInput / OnTouchInput）。
		//
		// 为什么必须放在"选中点击目标"之前（即这里）：
		//   一旦放行到下面的原生鼠标分支，`m_pEventClick = FindControl(pt)` 就被建立了。
		//   此后无论如何复核，那个候选点击都已经存在，抬手时就有被派发的机会。
		//   在入口吃掉，等于**从根上不产生候选点击**。
		//
		// ⚠️ 只拦"点击类"（DOWN/UP/DBLCLK），**不拦** WM_MOUSEMOVE：
		//   背景窗口仍需要 MOVE 来维持正常的重绘/光标逻辑；而且
		//   `IsModalInputTarget` 那套提示音抑制还依赖 MOVE 之后的配套消息。
		//   拦 MOVE 会带来其它回归，收益为零。
		//
		// ⚠️ 与下面 `m_bSuppressPromotedMouseForModal` 块的关系（两者互补，不冲突）：
		//   · 那一块管的是"**模态刚开启的那一瞬间**，同一次手势残留的提升消息"
		//     （按 DOWN 记账 / UP 销账的配对计数，几十毫秒内自然失效）；
		//   · 本闸门管的是"**整个模态会话期间**，背景窗口收到的任何点击消息"。
		//   前者是一过性的，后者是持续性的 —— 缺后者正是透传漏网的原因。
		// ==================================================================
		if ((uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
			&& IsModalBackdropWindow(m_hWndPaint))
		{
			DuiLibDiag::Log(_T("MODAL-BACKDROP swallow mouse msg=0x%04X hwnd=%p promoted=%d modal=%p"),
				uMsg, (void*)m_hWndPaint, (int)IsPromotedTouchMouseMessage(),
				(void*)CPaintManagerUI::GetModalWindow());
			// 顺手作废可能残留的候选点击/捕获，避免抬手时被派发。
			m_pEventClick = NULL;
			if (m_bMouseCapture) ReleaseCapture();
			return true;
		}
		if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
			TraceModalGateCheck(m_hWndPaint, _T("MOUSE-CLICK"));

		// 触摸点击优先由 WM_TOUCH 状态机驱动 BUTTONDOWN/BUTTONUP。
		// 只有当前 manager 已经收到本次 WM_TOUCH，或刚刚完成了触摸点击，
		// 才拦截随后提升的鼠标消息。不能仅凭 FROMTOUCH 标记无条件拦截，
		// 因为部分模态窗口只收到 Windows 提升的鼠标消息而没有收到 WM_TOUCH，
		// 无条件拦截会导致模态窗口完全无法触摸点击。
		//
		// ⚠️ 注意这里的 return true 会【吞掉】消息、不让它进控件树。
		// 只有当"确实有一次触摸手势在进行中/刚结束"时才该吞：
		//   · m_pEventTouch != NULL        —— 本次手势已由 WM_TOUCH 接管
		//   · m_bSuppressPromotedTouchMouse —— 刚合成过点击，丢弃重复的提升鼠标
		// 两个条件任一为假，都必须放行 —— 否则真实鼠标点击也会被吞（"主窗口点不动"）。
		if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
		{
			if (m_pEventTouch != NULL || m_bSuppressPromotedTouchMouse)
			{
				// ⚠️ 这就是抑制位的**唯一的正常解除点**（"配对销账"语义）：
				//   抬起类消息到手 ⇒ 本次手势那一对残留提升消息已经配完 ⇒ 授权作废。
				//   从此不再有任何"超时自动清"的路径（那段 3000ms 自愈已整段删除）。
				//   之所以能这么干，是因为"抬起"本身就是确定性的状态信号，
				//   不必用时间去猜它还会不会来。
				if (uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
				{
					m_bSuppressPromotedTouchMouse = false;
					m_dwSuppressTick = 0;
				}
				// [诊断] down/elapsed 只用于看时序，不再参与任何判定。
				DuiLibDiag::Log(_T("PROMOTED-MOUSE swallowed msg=0x%04X touch=%p suppress=%d down=%u elapsed=%u modal=%d"),
					uMsg, (void*)m_pEventTouch, (int)m_bSuppressPromotedTouchMouse,
					(unsigned)m_dwTouchDownTick,
					(m_dwSuppressTick != 0) ? (unsigned)(::GetTickCount() - m_dwSuppressTick) : 0u,
					(int)m_bSuppressPromotedMouseForModal);
				return true;
			}

			// --------------------------------------------------------------
			// [模态提示音 / 重复点击] "点控件 → 回调里 ShowModal() → 咚 / 自动点掉弹框"
			// 的统一拦截点。
			//
			// 详细成因见 UIBase.cpp 文件头；这里说明**判定条件与生命周期**。
			//
			// 三个条件同时成立才丢：
			//   ① m_bSuppressPromotedMouseForModal —— 正在模态开启窗口内（见下）
			//   ② IsPromotedTouchMouseMessage()     —— 是**触摸提升出来的**合成鼠标消息
			//        真实鼠标点击不带 MOUSEEVENTF_FROMTOUCH ⇒ 天然豁免，不受影响
			//   ③ IsModalInputTarget(m_hWndPaint)   —— 目标是"弹框本身"或"弹框的 owner"
			//        两者都是同一次手势被处理两遍的第二次，都必须拦（理由见该函数注释）
			//
			// ⚠️⚠️ 【生命周期：按"手势配对"结束，不按固定时间】⚠️⚠️
			//   第一版写的是"置位后 1 秒自动失效"，真机验证证明两头都不对：
			//     · 太短 ⇒ 手势残留消息若 >1s 才投出来就漏网（咚声 / 自动点弹框）；
			//     · 更糟：超时一清抑制位，残留的提升消息立刻被**放行**，
			//       恰好制造出"弹框关闭后突然透点"这种新 bug。
			//   现在改为**配对计数**：
			//     DOWN 到手 ⇒ AddPromotedMousePending()（欠一条 UP）
			//     UP   到手 ⇒ ReleasePromotedMousePending()（销账，归零即自动解除）
			//   正常手势几十毫秒内就配完对，抑制位随即失效，
			//   因此"弹框已出现后用户重新点空白区"那一声（要求保留的）**照旧**会响：
			//   那一下是新手势、新归属，且此时抑制位早已解除。
			//
			//   m_dwSuppressPromotedMouseForModalTick 保留仅作日志参考（elapsed 字段），
			//   **不再**用于"超时强制清" —— 用户明确要求"不要时间戳，完全根据状态判断"，
			//   而且模态会话可能很长（用户在弹框里慢慢选），任何"过了多久就清"的写法
			//   都会在弹框还开着的时候把防线撤掉 ⇒ 那正是透点/咚的成因。
			//
			//   本抑制位的**解除完全由状态驱动**，共三条路径（没有一条看时间）：
			//     a) DOWN 记账 / UP 销账，配对归零 ⇒ 自动解除（正常路径，几十毫秒内完成）；
			//     b) 模态结束（弹框关闭）⇒ UIBase.cpp 的三个确定性撤防点；
			//     c) manager 搬家/销毁 ⇒ AttachPaintWindow / WM_NCDESTROY 收尾。
			//   ⇒ 不存在"永久残留导致主窗口点不动"的可能：只要弹框一关，(b)/(c) 必到达。
			// --------------------------------------------------------------
			if (m_bSuppressPromotedMouseForModal)
			{
				const DWORD dwElapsed = (DWORD)(::GetTickCount() - m_dwSuppressPromotedMouseForModalTick);
				if (IsPromotedTouchMouseMessage() && IsModalInputTarget(m_hWndPaint))
				{
					if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK)
					{
						// 按下：记账（欠一条 UP）。**不在这里解除抑制** ——
						// 后面的 UP 也是同一次手势的残留，必须一起拦掉，
						// 否则 UP 会把点击真正派发出去（正是"自动点掉弹框"的成因）。
						AddPromotedMousePending();
					}
					else if (uMsg == WM_LBUTTONUP)
					{
						// 抬起：销账。计数归零时 ReleasePromotedMousePending 会自动解除抑制。
						ReleasePromotedMousePending();
					}
					DuiLibDiag::Log(_T("MODAL-BEEP swallowed promoted msg=0x%04X hwnd=%p elapsed=%u pending=%d"),
						uMsg, (void*)m_hWndPaint, (unsigned)dwElapsed, m_nPromotedMousePending);
					return true;
				}
			}
		}

		// [触屏兼容] 不再过滤 Windows 为触摸模拟的鼠标消息（MOUSEEVENTF_FROMTOUCH）。
		// 触摸的“点击”正来自这些模拟的 WM_LBUTTONDOWN/UP，由原生鼠标路径交给 CButtonUI 等控件
		// Activate() 触发——而 DuiLib 的点击状态机依赖 WM_LBUTTONDOWN 设置 m_pEventClick，故绝不能
		// 在鼠标分支吞掉这些模拟消息（之前那样做会导致触摸与鼠标点击全失效）。
		// 为避免“拖拽=滚动”又“误点按钮”，改用 m_bTouchMoved：若本次手势发生位移，在 WM_LBUTTONUP 抑制点击。

		// ------------------------------------------------------------------
		// [对标 nim_duilib] WM_POINTER*（Win8+ 指针栈）归一化成鼠标消息。
		//
		// ⚠️ 这里的核心是【手势级让路】，不是"通道二选一"。改回二选一会立刻坏掉真模态弹框：
		//   本台收银机上 WM_TOUCH 的贪婪归属权卡在主窗口（MSDN：收到第一条触摸消息后
		//   所有触摸消息都发给该窗口，直到另一个窗口获得焦点），弹框被程序 SetFocus
		//   而非触摸点出焦点 ⇒ 弹框永远收不到 WM_TOUCH，只能收到按命中投递的 WM_POINTER*。
		//   所以指针通道必须始终开着，弹框才有输入源。
		//
		// 那怎么避免"两条通道产生两套 WM_LBUTTONDOWN/UP 把点击状态机打乱"（曾经导致
		// 所有窗口点击全失效）？答案是：**同一时刻只让一条通道驱动**。
		//   · 指针先 DOWN ⇒ m_bPointerGestureActive=true，本次手势内 OnTouchInput 直接忽略 WM_TOUCH；
		//   · WM_TOUCH 先 DOWN ⇒ m_pEventTouch 置位，本次手势内这里拒绝指针；
		//   · 手势一结束（UP / 超时 / 捕获被夺）立刻解禁，下一个手势可以换通道。
		//   让路只加在 UP 的"驱动点击"上：同一手势里两条通道的**按下**才是一对重复；
		//   UP/MOVE 一侧不加让路，避免某一侧的 UP 被误丢导致状态永久悬空。
		//   ⚠️ 【血的教训】曾经让路连 WM_POINTERUP 一起吞 —— UP 是唯一能解除
		//   m_bPointerGestureActive 的消息，吞掉它会让指针手势状态永久为真，
		//   随后的 WM_POINTERDOWN 全被当成"重复按下"挡掉 ⇒ 整个窗口触摸点击全灭。
		//   现在 UP/UPDATE 一律送到 OnPointerInput，由那里自行决定"只清状态"还是"派发点击"。
		//
		// 另外，只处理 DOWN/UP/UPDATE 三个真正驱动点击的消息；
		// ENTER/LEAVE/ACTIVATE/HWHEEL/CAPTURECHANGED 交回系统（返回 false），绝不吞掉。
		//
		// 注意：本项目 _WIN32_WINNT=0x0601，WM_POINTER* 宏在编译期不可见，
		// 只能用字面量常量区间判断（见文件头 PointerMsg 命名空间）。
		// ------------------------------------------------------------------
		if (m_bPointerNormalizeEnabled
			&& (uMsg == PointerMsg::DUI_WM_POINTERDOWN
				|| uMsg == PointerMsg::DUI_WM_POINTERUP
				|| uMsg == PointerMsg::DUI_WM_POINTERUPDATE))
		{
			// [NIM 风格] 这里**不再**做让路判定 —— 让路完全下沉到 OnPointerInput，
			// 由 m_pEventTouch（WM_TOUCH 的占用标记）与 m_bPointerGestureActive 互斥决定。
			// 原先在这里用时间戳预判让路，会导致"UP 被漏放/被多放"两类边界问题，
			// 而 OnPointerInput 内部本就有完整的 UP 放行规则（它才是权威）。
			//
			// 三个消息一律委托，由 OnPointerInput 决定"吃掉"还是"放行"：
			//   · DOWN/UPDATE 且 WM_TOUCH 已占用 ⇒ 返回 true（吃掉）
			//   · UP 永远返回 false（放行给系统收尾），但内部已清干净状态
			if (OnPointerInput(uMsg, wParam, lParam))
			{
				lRes = 0;
				return true;
			}
		}
		else if (uMsg >= PointerMsg::DUI_WM_POINTERUPDATE && uMsg <= PointerMsg::DUI_WM_POINTERHWHEEL)
		{
			// [诊断] 未进入归一化的指针消息（通道关闭、或 ENTER/ACTIVATE/HWHEEL 等），
			// 只记录"系统确实在投指针消息"这一事实，不做任何处理
			// （绝不能 return true —— 交回系统，保住它自己的指针状态机）。
			DuiLibDiag::Log(_T("POINTER-MSG observed-but-passed msg=0x%04X w=0x%08X enabled=%d hwnd=%p"),
				uMsg, (unsigned)wParam, (int)m_bPointerNormalizeEnabled, (void*)m_hWndPaint);
		}

		// Cycle through listeners
		for (int i = 0; i < m_aMessageFilters.GetSize(); i++)
		{
			bool bHandled = false;
			LRESULT lResult = static_cast<IMessageFilterUI*>(m_aMessageFilters[i])->MessageHandler(uMsg, wParam, lParam, bHandled);
			if (bHandled)
			{
				lRes = lResult;
				switch (uMsg)
				{
					case WM_MOUSEMOVE:
					case WM_LBUTTONDOWN:
					case WM_LBUTTONDBLCLK:
					case WM_LBUTTONUP:
					{
						POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
						m_ptLastMousePos = pt;
					}
					break;
					case WM_CONTEXTMENU:
					case WM_MOUSEWHEEL:
					{
						POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
						::ScreenToClient(m_hWndPaint, &pt);
						m_ptLastMousePos = pt;
					}
					break;
				}
				return true;
			}
		}

		if (m_bLayered)
		{
			switch (uMsg)
			{
				case WM_NCACTIVATE:
					if (!::IsIconic(m_hWndPaint))
					{
						lRes = (wParam == 0) ? TRUE : FALSE;
						return true;
					}
					break;
				case WM_NCCALCSIZE:
				case WM_NCPAINT:
					lRes = 0;
					return true;
			}
		}
		// Custom handling of events
		switch (uMsg)
		{
			case WM_APP + 1:
			{
				for (int i = 0; i < m_aDelayedCleanup.GetSize(); i++)
					delete static_cast<CControlUI*>(m_aDelayedCleanup[i]);
				m_aDelayedCleanup.Empty();

				m_bAsyncNotifyPosted = false;

				TNotifyUI* pMsg = NULL;
				while (pMsg = static_cast<TNotifyUI*>(m_aAsyncNotify.GetAt(0)))
				{
					m_aAsyncNotify.Remove(0);
					if (pMsg->pSender != NULL)
					{
						if (pMsg->pSender->OnNotify) pMsg->pSender->OnNotify(pMsg);
					}
					for (int j = 0; j < m_aNotifiers.GetSize(); j++)
					{
						static_cast<INotifyUI*>(m_aNotifiers[j])->Notify(*pMsg);
					}
					delete pMsg;
				}
			}
			break;
			case WM_CLOSE:
			{
				// Make sure all matching "closing" events are sent
				TEventUI event = { 0 };
				event.ptMouse = m_ptLastMousePos;
				event.wKeyState = MapKeyState();
				event.dwTimestamp = ::GetTickCount();
				if (m_pEventHover != NULL)
				{
					event.Type = UIEVENT_MOUSELEAVE;
					event.pSender = m_pEventHover;
					m_pEventHover->Event(event);
				}
				if (m_pEventClick != NULL)
				{
					event.Type = UIEVENT_BUTTONUP;
					event.pSender = m_pEventClick;
					m_pEventClick->Event(event);
				}
				if (m_pEventRClick != NULL)
				{
					event.Type = UIEVENT_RBUTTONUP;
					event.pSender = m_pEventClick;
					m_pEventRClick->Event(event);
				}

				SetFocus(NULL);

				if (::GetActiveWindow() == m_hWndPaint)
				{
					HWND hwndParent = GetWindowOwner(m_hWndPaint);
					if (hwndParent != NULL) ::SetFocus(hwndParent);
				}

				if (m_hwndTooltip != NULL)
				{
					::DestroyWindow(m_hwndTooltip);
					m_hwndTooltip = NULL;
				}
			}
			break;
			case WM_ERASEBKGND:
			{
				// We'll do the painting here...
				lRes = 1;
			}
			return true;
			case WM_PAINT:
			{
				if (m_pRoot == NULL)
				{
					PAINTSTRUCT ps = { 0 };
					::BeginPaint(m_hWndPaint, &ps);
					CRenderEngine::DrawColor(m_hDcPaint, ps.rcPaint, 0xFF000000);
					::EndPaint(m_hWndPaint, &ps);
					return true;
				}

				RECT rcClient = { 0 };
				::GetClientRect(m_hWndPaint, &rcClient);

				RECT rcPaint = { 0 };
				if (!::GetUpdateRect(m_hWndPaint, &rcPaint, FALSE)) return true;

				//if( m_bLayered ) {
				//	m_bOffscreenPaint = true;
				//	rcPaint = m_rcLayeredUpdate;
				//	if( ::IsRectEmpty(&m_rcLayeredUpdate) ) {
				//		PAINTSTRUCT ps = { 0 };
				//		::BeginPaint(m_hWndPaint, &ps);
				//		::EndPaint(m_hWndPaint, &ps);
				//		return true;
				//	}
				//	if( rcPaint.right > rcClient.right ) rcPaint.right = rcClient.right;
				//	if( rcPaint.bottom > rcClient.bottom ) rcPaint.bottom = rcClient.bottom;
				//	::ZeroMemory(&m_rcLayeredUpdate, sizeof(m_rcLayeredUpdate));
				//}
				//else {
				//	if( !::GetUpdateRect(m_hWndPaint, &rcPaint, FALSE) ) return true;
				//}

				// Set focus to first control?
				if (m_bFocusNeeded)
				{
					//修复新窗口自动切换焦点的问题
					//SetNextTabControl();
					m_bFocusNeeded = false;
				}

				SetPainting(true);

				bool bNeedSizeMsg = false;
				DWORD dwWidth = rcClient.right - rcClient.left;
				DWORD dwHeight = rcClient.bottom - rcClient.top;

				SetPainting(true);
				if (m_bUpdateNeeded)
				{
					m_bUpdateNeeded = false;
					if (!::IsRectEmpty(&rcClient) && !::IsIconic(m_hWndPaint))
					{
						if (m_pRoot->IsUpdateNeeded())
						{
							RECT rcRoot = rcClient;
							if (m_hDcOffscreen != NULL) ::DeleteDC(m_hDcOffscreen);
							if (m_hDcBackground != NULL) ::DeleteDC(m_hDcBackground);
							if (m_hbmpOffscreen != NULL) ::DeleteObject(m_hbmpOffscreen);
							if (m_hbmpBackground != NULL) ::DeleteObject(m_hbmpBackground);
							m_hDcOffscreen = NULL;
							m_hDcBackground = NULL;
							m_hbmpOffscreen = NULL;
							m_hbmpBackground = NULL;
							if (m_bLayered)
							{
								rcRoot.left += m_rcLayeredInset.left;
								rcRoot.top += m_rcLayeredInset.top;
								rcRoot.right -= m_rcLayeredInset.right;
								rcRoot.bottom -= m_rcLayeredInset.bottom;
							}
							m_pRoot->SetPos(rcRoot, true);
							bNeedSizeMsg = true;
						}
						else
						{
							CControlUI* pControl = NULL;
							m_aFoundControls.Empty();
							m_pRoot->FindControl(__FindControlsFromUpdate, NULL, UIFIND_VISIBLE | UIFIND_ME_FIRST | UIFIND_UPDATETEST);
							for (int it = 0; it < m_aFoundControls.GetSize(); it++)
							{
								pControl = static_cast<CControlUI*>(m_aFoundControls[it]);
								pControl->SetPos(pControl->GetPos(), true);
							}
							bNeedSizeMsg = true;
						}
						// We'll want to notify the window when it is first initialized
						// with the correct layout. The window form would take the time
						// to submit swipes/animations.
						if (m_bFirstLayout)
						{
							m_bFirstLayout = false;
							SendNotify(m_pRoot, DUI_MSGTYPE_WINDOWINIT, 0, 0, false);
							if (m_bLayered && m_bLayeredChanged)
							{
								Invalidate();
								SetPainting(false);
								return true;
							}
							// 更新阴影窗口显示
							m_shadow.Update(m_hWndPaint);
						}
					}
				}
				else if (m_bLayered && m_bLayeredChanged)
				{
					RECT rcRoot = rcClient;
					if (m_pOffscreenBits) ::ZeroMemory(m_pOffscreenBits, (rcRoot.right - rcRoot.left)
						* (rcRoot.bottom - rcRoot.top) * 4);
					rcRoot.left += m_rcLayeredInset.left;
					rcRoot.top += m_rcLayeredInset.top;
					rcRoot.right -= m_rcLayeredInset.right;
					rcRoot.bottom -= m_rcLayeredInset.bottom;
					m_pRoot->SetPos(rcRoot, true);
				}

				if (m_bLayered)
				{
					DWORD dwExStyle = ::GetWindowLong(m_hWndPaint, GWL_EXSTYLE);
					DWORD dwNewExStyle = dwExStyle | WS_EX_LAYERED;
					if (dwExStyle != dwNewExStyle) ::SetWindowLong(m_hWndPaint, GWL_EXSTYLE, dwNewExStyle);
					m_bOffscreenPaint = true;
					UnionRect(&rcPaint, &rcPaint, &m_rcLayeredUpdate);
					if (rcPaint.right > rcClient.right) rcPaint.right = rcClient.right;
					if (rcPaint.bottom > rcClient.bottom) rcPaint.bottom = rcClient.bottom;
					::ZeroMemory(&m_rcLayeredUpdate, sizeof(m_rcLayeredUpdate));
				}

				//
				// Render screen
				//
				// Prepare offscreen bitmap
				if (m_bOffscreenPaint && m_hbmpOffscreen == NULL)
				{
					m_hDcOffscreen = ::CreateCompatibleDC(m_hDcPaint);
					m_hbmpOffscreen = CRenderEngine::CreateARGB32Bitmap(m_hDcPaint, dwWidth, dwHeight, (LPBYTE*)&m_pOffscreenBits);
					ASSERT(m_hDcOffscreen);
					ASSERT(m_hbmpOffscreen);
				}
				// Begin Windows paint
				PAINTSTRUCT ps = { 0 };
				::BeginPaint(m_hWndPaint, &ps);
				if (m_bOffscreenPaint)
				{
					HBITMAP hOldBitmap = (HBITMAP) ::SelectObject(m_hDcOffscreen, m_hbmpOffscreen);
					int iSaveDC = ::SaveDC(m_hDcOffscreen);
					if (m_bLayered)
					{
						for (LONG y = rcClient.bottom - rcPaint.bottom; y < rcClient.bottom - rcPaint.top; ++y)
						{
							for (LONG x = rcPaint.left; x < rcPaint.right; ++x)
							{
								int i = (y * dwWidth + x) * 4;
								*(DWORD*)(&m_pOffscreenBits[i]) = 0;
							}
						}
					}
					m_pRoot->Paint(m_hDcOffscreen, rcPaint, NULL);

					if (m_bLayered)
					{
						for (int i = 0; i < m_aNativeWindow.GetSize(); )
						{
							HWND hChildWnd = static_cast<HWND>(m_aNativeWindow[i]);
							if (!::IsWindow(hChildWnd))
							{
								m_aNativeWindow.Remove(i);
								m_aNativeWindowControl.Remove(i);
								continue;
							}
							++i;
							if (!::IsWindowVisible(hChildWnd)) continue;
							RECT rcChildWnd = GetNativeWindowRect(hChildWnd);
							RECT rcTemp = { 0 };
							if (!::IntersectRect(&rcTemp, &rcPaint, &rcChildWnd)) continue;

							COLORREF* pChildBitmapBits = NULL;
							HDC hChildMemDC = ::CreateCompatibleDC(m_hDcOffscreen);
							HBITMAP hChildBitmap = CRenderEngine::CreateARGB32Bitmap(hChildMemDC, rcChildWnd.right - rcChildWnd.left, rcChildWnd.bottom - rcChildWnd.top, (BYTE**)&pChildBitmapBits);
							::ZeroMemory(pChildBitmapBits, (rcChildWnd.right - rcChildWnd.left) * (rcChildWnd.bottom - rcChildWnd.top) * 4);
							HBITMAP hOldChildBitmap = (HBITMAP) ::SelectObject(hChildMemDC, hChildBitmap);
							::SendMessage(hChildWnd, WM_PRINT, (WPARAM)hChildMemDC, (LPARAM)(PRF_CHECKVISIBLE | PRF_CHILDREN | PRF_CLIENT | PRF_OWNED));
							COLORREF* pChildBitmapBit;
							for (LONG y = 0; y < rcChildWnd.bottom - rcChildWnd.top; y++)
							{
								for (LONG x = 0; x < rcChildWnd.right - rcChildWnd.left; x++)
								{
									pChildBitmapBit = pChildBitmapBits + y * (rcChildWnd.right - rcChildWnd.left) + x;
									if (*pChildBitmapBit != 0x00000000) *pChildBitmapBit |= 0xff000000;
								}
							}
							::BitBlt(m_hDcOffscreen, rcChildWnd.left, rcChildWnd.top, rcChildWnd.right - rcChildWnd.left,
								rcChildWnd.bottom - rcChildWnd.top, hChildMemDC, 0, 0, SRCCOPY);
							::SelectObject(hChildMemDC, hOldChildBitmap);
							::DeleteObject(hChildBitmap);
							::DeleteDC(hChildMemDC);
						}
					}

					for (int i = 0; i < m_aPostPaintControls.GetSize(); i++)
					{
						CControlUI* pPostPaintControl = static_cast<CControlUI*>(m_aPostPaintControls[i]);
						pPostPaintControl->DoPostPaint(m_hDcOffscreen, rcPaint);
					}

					::RestoreDC(m_hDcOffscreen, iSaveDC);

					if (m_bLayered)
					{
						RECT rcWnd = { 0 };
						::GetWindowRect(m_hWndPaint, &rcWnd);
						if (!m_diLayered.sDrawString.IsEmpty())
						{
							DWORD dwWidth = rcClient.right - rcClient.left;
							DWORD dwHeight = rcClient.bottom - rcClient.top;
							RECT rcLayeredClient = rcClient;
							rcLayeredClient.left += m_rcLayeredInset.left;
							rcLayeredClient.top += m_rcLayeredInset.top;
							rcLayeredClient.right -= m_rcLayeredInset.right;
							rcLayeredClient.bottom -= m_rcLayeredInset.bottom;

							COLORREF* pOffscreenBits = (COLORREF*)m_pOffscreenBits;
							COLORREF* pBackgroundBits = m_pBackgroundBits;
							BYTE A = 0;
							BYTE R = 0;
							BYTE G = 0;
							BYTE B = 0;
							if (!m_diLayered.sDrawString.IsEmpty())
							{
								if (m_hbmpBackground == NULL)
								{
									m_hDcBackground = ::CreateCompatibleDC(m_hDcPaint);
									m_hbmpBackground = CRenderEngine::CreateARGB32Bitmap(m_hDcPaint, dwWidth, dwHeight, (BYTE**)&m_pBackgroundBits);
									::ZeroMemory(m_pBackgroundBits, dwWidth * dwHeight * 4);
									::SelectObject(m_hDcBackground, m_hbmpBackground);
									CRenderClip clip;
									CRenderClip::GenerateClip(m_hDcBackground, rcLayeredClient, clip);
									CRenderEngine::DrawImageInfo(m_hDcBackground, this, rcLayeredClient, rcLayeredClient, &m_diLayered);
								}
								else if (m_bLayeredChanged)
								{
									::ZeroMemory(m_pBackgroundBits, dwWidth * dwHeight * 4);
									CRenderClip clip;
									CRenderClip::GenerateClip(m_hDcBackground, rcLayeredClient, clip);
									CRenderEngine::DrawImageInfo(m_hDcBackground, this, rcLayeredClient, rcLayeredClient, &m_diLayered);
								}
								for (LONG y = rcClient.bottom - rcPaint.bottom; y < rcClient.bottom - rcPaint.top; ++y)
								{
									for (LONG x = rcPaint.left; x < rcPaint.right; ++x)
									{
										pOffscreenBits = (COLORREF*)(m_pOffscreenBits + y * dwWidth + x);
										pBackgroundBits = m_pBackgroundBits + y * dwWidth + x;
										A = (BYTE)((*pBackgroundBits) >> 24);
										R = (BYTE)((*pOffscreenBits) >> 16) * A / 255;
										G = (BYTE)((*pOffscreenBits) >> 8) * A / 255;
										B = (BYTE)(*pOffscreenBits) * A / 255;
										*pOffscreenBits = RGB(B, G, R) + ((DWORD)A << 24);
									}
								}
							}
						}
						else
						{
							for (LONG y = rcClient.bottom - rcPaint.bottom; y < rcClient.bottom - rcPaint.top; ++y)
							{
								for (LONG x = rcPaint.left; x < rcPaint.right; ++x)
								{
									int i = (y * dwWidth + x) * 4;
									if ((m_pOffscreenBits[i + 3] == 0) && (m_pOffscreenBits[i + 0] != 0 || m_pOffscreenBits[i + 1] != 0 || m_pOffscreenBits[i + 2] != 0))
										m_pOffscreenBits[i + 3] = 255;
								}
							}
						}

						BLENDFUNCTION bf = { AC_SRC_OVER, 0, m_nOpacity, AC_SRC_ALPHA };
						POINT ptPos = { rcWnd.left, rcWnd.top };
						SIZE sizeWnd = { dwWidth, dwHeight };
						POINT ptSrc = { 0, 0 };
						g_fUpdateLayeredWindow(m_hWndPaint, m_hDcPaint, &ptPos, &sizeWnd, m_hDcOffscreen, &ptSrc, 0, &bf, ULW_ALPHA);
					}
					else
					{
						::BitBlt(m_hDcPaint, rcPaint.left, rcPaint.top, rcPaint.right - rcPaint.left, rcPaint.bottom - rcPaint.top, m_hDcOffscreen, rcPaint.left, rcPaint.top, SRCCOPY);
					}
					::SelectObject(m_hDcOffscreen, hOldBitmap);

					if (m_bShowUpdateRect && !m_bLayered)
					{
						HPEN hOldPen = (HPEN)::SelectObject(m_hDcPaint, m_hUpdateRectPen);
						::SelectObject(m_hDcPaint, ::GetStockObject(HOLLOW_BRUSH));
						::Rectangle(m_hDcPaint, rcPaint.left, rcPaint.top, rcPaint.right, rcPaint.bottom);
						::SelectObject(m_hDcPaint, hOldPen);
					}
				}
				else
				{
					// A standard paint job
					int iSaveDC = ::SaveDC(m_hDcPaint);
					m_pRoot->Paint(m_hDcPaint, rcPaint, NULL);
					for (int i = 0; i < m_aPostPaintControls.GetSize(); i++)
					{
						CControlUI* pPostPaintControl = static_cast<CControlUI*>(m_aPostPaintControls[i]);
						pPostPaintControl->DoPostPaint(m_hDcPaint, rcPaint);
					}
					::RestoreDC(m_hDcPaint, iSaveDC);
				}
				// All Done!
				::EndPaint(m_hWndPaint, &ps);

				// 绘制结束
				SetPainting(false);
				m_bLayeredChanged = false;
				if (m_bUpdateNeeded) Invalidate();

				// 发送窗口大小改变消息
				if (bNeedSizeMsg)
				{
					this->SendNotify(m_pRoot, DUI_MSGTYPE_WINDOWSIZE, 0, 0, true);
				}
				return true;
			}
			case WM_PRINTCLIENT:
			{
				if (m_pRoot == NULL) break;
				RECT rcClient;
				::GetClientRect(m_hWndPaint, &rcClient);
				HDC hDC = (HDC)wParam;
				int save = ::SaveDC(hDC);
				m_pRoot->Paint(hDC, rcClient, NULL);
				if ((lParam & PRF_CHILDREN) != 0)
				{
					HWND hWndChild = ::GetWindow(m_hWndPaint, GW_CHILD);
					while (hWndChild != NULL)
					{
						RECT rcPos = { 0 };
						::GetWindowRect(hWndChild, &rcPos);
						::MapWindowPoints(HWND_DESKTOP, m_hWndPaint, reinterpret_cast<LPPOINT>(&rcPos), 2);
						::SetWindowOrgEx(hDC, -rcPos.left, -rcPos.top, NULL);
						::SendMessage(hWndChild, WM_PRINT, wParam, lParam | PRF_NONCLIENT);
						hWndChild = ::GetWindow(hWndChild, GW_HWNDNEXT);
					}
				}
				::RestoreDC(hDC, save);
			}
			break;
			case WM_GETMINMAXINFO:
			{
				MONITORINFO Monitor = {};
				Monitor.cbSize = sizeof(Monitor);
				::GetMonitorInfo(::MonitorFromWindow(m_hWndPaint, MONITOR_DEFAULTTOPRIMARY), &Monitor);
				RECT rcWork = Monitor.rcWork;
				if (Monitor.dwFlags != MONITORINFOF_PRIMARY)
				{
					::OffsetRect(&rcWork, -rcWork.left, -rcWork.top);
				}

				LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam;
				if (m_szMinWindow.cx > 0) lpMMI->ptMinTrackSize.x = m_szMinWindow.cx;
				if (m_szMinWindow.cy > 0) lpMMI->ptMinTrackSize.y = m_szMinWindow.cy;
				if (m_szMaxWindow.cx > 0) lpMMI->ptMaxTrackSize.x = m_szMaxWindow.cx;
				if (m_szMaxWindow.cy > 0) lpMMI->ptMaxTrackSize.y = m_szMaxWindow.cy;
				if (m_szMaxWindow.cx > 0) lpMMI->ptMaxSize.x = m_szMaxWindow.cx;
				if (m_szMaxWindow.cy > 0) lpMMI->ptMaxSize.y = m_szMaxWindow.cy;
			}
			break;
			case WM_SIZE:
			{
				if (m_pFocus != NULL)
				{
					TEventUI event = { 0 };
					event.Type = UIEVENT_WINDOWSIZE;
					event.pSender = m_pFocus;
					event.dwTimestamp = ::GetTickCount();
					m_pFocus->Event(event);
				}
				if (m_pRoot != NULL) m_pRoot->NeedUpdate();
			}
			return true;
			case WM_TIMER:
			{
				for (int i = 0; i < m_aTimers.GetSize(); i++)
				{
					const TIMERINFO* pTimer = static_cast<TIMERINFO*>(m_aTimers[i]);
					if (pTimer->hWnd == m_hWndPaint &&
						pTimer->uWinTimer == LOWORD(wParam) &&
						pTimer->bKilled == false)
					{
						TEventUI event = { 0 };
						event.Type = UIEVENT_TIMER;
						event.pSender = pTimer->pSender;
						event.dwTimestamp = ::GetTickCount();
						event.ptMouse = m_ptLastMousePos;
						event.wKeyState = MapKeyState();
						event.wParam = pTimer->nLocalID;
						event.lParam = lParam;
						pTimer->pSender->Event(event);
						break;
					}
				}
			}
			break;
			case WM_MOUSEHOVER:
			{
				if (s_bSuppressHoverAfterTouch) return true;
				m_bMouseTracking = false;
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				CControlUI* pHover = FindControl(pt);
				if (pHover == NULL) break;
				// Generate mouse hover event
				if (m_pEventHover != NULL)
				{
					TEventUI event = { 0 };
					event.Type = UIEVENT_MOUSEHOVER;
					event.pSender = m_pEventHover;
					event.wParam = wParam;
					event.lParam = lParam;
					event.dwTimestamp = ::GetTickCount();
					event.ptMouse = pt;
					event.wKeyState = MapKeyState();
					m_pEventHover->Event(event);
				}
				// Create tooltip information
				CDuiString sToolTip = pHover->GetToolTip();
				if (sToolTip.IsEmpty()) return true;
				::ZeroMemory(&m_ToolTip, sizeof(TOOLINFO));
				m_ToolTip.cbSize = sizeof(TOOLINFO);
				m_ToolTip.uFlags = TTF_IDISHWND;
				m_ToolTip.hwnd = m_hWndPaint;
				m_ToolTip.uId = (UINT_PTR)m_hWndPaint;
				m_ToolTip.hinst = m_hInstance;
				m_ToolTip.lpszText = const_cast<LPTSTR>((LPCTSTR)sToolTip);
				m_ToolTip.rect = pHover->GetPos();
				if (m_hwndTooltip == NULL)
				{
					m_hwndTooltip = ::CreateWindowEx(0, TOOLTIPS_CLASS, NULL, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, m_hWndPaint, NULL, m_hInstance, NULL);
					::SendMessage(m_hwndTooltip, TTM_ADDTOOL, 0, (LPARAM)&m_ToolTip);
					::SendMessage(m_hwndTooltip, TTM_SETMAXTIPWIDTH, 0, pHover->GetToolTipWidth());
				}
				if (!::IsWindowVisible(m_hwndTooltip))
				{
					::SendMessage(m_hwndTooltip, TTM_SETTOOLINFO, 0, (LPARAM)&m_ToolTip);
					::SendMessage(m_hwndTooltip, TTM_TRACKACTIVATE, TRUE, (LPARAM)&m_ToolTip);
				}
			}
			return true;
			case WM_MOUSELEAVE:
			{
				DuiLibDiag::Log(_T("WM_MOUSELEAVE tracking=%d hover=%s leaveArr=%d click=%s"),
					(int)m_bMouseTracking,
					m_pEventHover != NULL ? m_pEventHover->GetName().GetData() : _T("null"),
					m_aNeedMouseLeaveNeeded.GetSize(),
					m_pEventClick != NULL ? m_pEventClick->GetName().GetData() : _T("null"));
				if (m_hwndTooltip != NULL) ::SendMessage(m_hwndTooltip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&m_ToolTip);
				// 触屏抬起刚清过悬浮态时，不要执行下面这段“自回发 WM_MOUSEMOVE”：
				// 光标通常仍在窗口内 → 会立刻重建悬浮态，导致“悬浮态不消失/多控件同时悬浮”。
				if (!s_bSuppressHoverAfterTouch && m_bMouseTracking)
				{
					POINT pt = { 0 };
					RECT rcWnd = { 0 };
					::GetCursorPos(&pt);
					::GetWindowRect(m_hWndPaint, &rcWnd);
					if (!::IsIconic(m_hWndPaint) && ::GetActiveWindow() == m_hWndPaint && ::PtInRect(&rcWnd, pt))
					{
						if (::SendMessage(m_hWndPaint, WM_NCHITTEST, 0, MAKELPARAM(pt.x, pt.y)) == HTCLIENT)
						{
							::ScreenToClient(m_hWndPaint, &pt);
							::SendMessage(m_hWndPaint, WM_MOUSEMOVE, 0, MAKELPARAM(pt.x, pt.y));
						}
						else
							::SendMessage(m_hWndPaint, WM_MOUSEMOVE, 0, (LPARAM)-1);
					}
					else
						::SendMessage(m_hWndPaint, WM_MOUSEMOVE, 0, (LPARAM)-1);
				}
				m_bMouseTracking = false;
			}
			break;
			case WM_MOUSEMOVE:
			{
				const bool bPromotedTouchMove = IsPromotedTouchMouseMessage();
				if (bPromotedTouchMove && m_pEventTouch != NULL)
				{
					POINT ptTouch = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
					const int kTouchSlop = 8;
					const int dxTouch = ptTouch.x - m_ptTouchStart.x;
					const int dyTouch = ptTouch.y - m_ptTouchStart.y;
					if (dxTouch > kTouchSlop || dxTouch < -kTouchSlop
						|| dyTouch > kTouchSlop || dyTouch < -kTouchSlop)
						m_bTouchMoved = true;
					m_ptLastMousePos = ptTouch;
					// [WM_TOUCH 归属权] 这条被吞掉的"触摸提升鼠标移动"其实是系统
					// 用来触发 WM_TOUCH 翻译的信号（见 UIManager.h 的长注释）。
					// 吞掉它没问题，但必须补一次原窗口过程的副作用，
					// 否则本窗口（尤其 #32770 真模态弹框）后续再也收不到 WM_TOUCH。
					RelayDefWindowProc(uMsg, wParam, lParam, _T("promoted-touch-move/tracking"));
					return true;
				}
				if (s_bSuppressHoverAfterTouch)
				{
					// [第十一轮修正] 这里曾经无条件丢弃消息（return true）。
					// 后果：弹框弹出时 AttachPaintWindow 会置起本抑制位（为了让新弹框
					// 上不残留旧窗口的悬浮态），但**新弹框自己的 WM_MOUSEMOVE 也被
					// 一起丢掉了** —— 它的 m_ptLastMousePos 再也得不到更新
					// ⇒ 用户停手 >1 秒后第一次移动时累积位移巨大
					// ⇒ bNeedDrag 为真、且 m_bDragMode 为真时触发意外的 DoDragDrop。
					// 现在改为"只在真的还在同一个触摸点上时丢弃"，其余情况放行 ——
					// 悬浮态保护由下方 3561 行那套 ±8px 判据继续负责（它本来就是
					// 为这个目的写的），这里只是提前把 m_ptLastMousePos 跟住。
					POINT ptSup = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
					POINT ptLast = m_ptLastMousePos;
					m_ptLastMousePos = ptSup;
					const int dxSup = ptSup.x - ptLast.x;
					const int dySup = ptSup.y - ptLast.y;
					if (dxSup <= 8 && dxSup >= -8 && dySup <= 8 && dySup >= -8)
					{
						// [WM_TOUCH 归属权] 同上：抬手后抑制悬浮复活时丢弃的合成移动，
						// 也必须补调一次，否则 WM_TOUCH 翻译链会在这段时间里断掉。
						RelayDefWindowProc(uMsg, wParam, lParam, _T("suppress-hover-after-touch"));
						return true;
					}
					// 明显移动 ⇒ 抑制期结束，落到下面走正常的鼠标移动流程。
				}

				if ((INT_PTR)lParam == -1)
					break;

				POINT ptCheck = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				if (s_bSuppressHoverAfterTouch)
				{
					// 合成消息通常仍停在触摸结束点；只有明显离开该点的鼠标移动
					// 才能重新建立鼠标悬浮语义。
					//
					// ⚠️⚠️ 这里有两个**必须同时成立**的前提，缺一个就会让"点『选好了』
					//   关掉弹框后，背后商品卡保持悬浮态不消失"复现。真机日志两次实证：
					//
					// ① 参考点必须换算到**屏幕坐标**再比 —— lParam 是"**接收窗口**的
					//    客户区坐标"，而触摸可能发生在**另一个窗口**里。
					//    用户点弹框里的「选好了」时，同一物理点在
					//      · 弹框的客户区里是 (496,547)
					//      · 主窗口的客户区里是 (778,630)
					//    若按客户区比较，等于拿两个不同原点的数相减 ⇒ 判据必然失准。
					//
					// ② 抑制位与参考点必须是**线程级**的（见文件头 `s_bSuppressHoverAfterTouch`
					//    那段说明）—— 因为属性弹框**自带独立的 CPaintManagerUI m_pm**，
					//    与主窗口的 manager 不是同一个对象（真机日志：弹框 0A29F5F8 /
					//    主窗口 07DA8C58）。那次触摸记在**弹框**那份状态上；而弹框一销毁，
					//    系统把补投的 `extra=0` WM_MOUSEMOVE 发给**主窗口** ⇒ 落到主窗口的
					//    manager 上。若状态是成员，主窗口那份要么抑制位为假、要么参考点
					//    还停在更早那次触摸（真机日志里是 1225,446，与本次点相距 447px）
					//    ⇒ 判据失败 ⇒ 解除抑制 + FindControl(pt) 命中背后商品卡 ⇒ 悬浮态
					//    点亮且此后永不熄灭（`MODAL-DLG exit` → `HOVER-ENTER diandan_fooditem`）。
					//    所以这两个状态已提升为文件级静态变量，与 manager 无关。
					//
					// 注意那条补投 MOVE 的 extra=0x00000000，它绕不过"提升移动不参与 hover"
					//   的总闸，只能靠**提前把状态改好**来防（此处判据 + 各触摸路径的写入）。
					POINT ptCheckScreen = ptCheck;
					if (m_hWndPaint != NULL && ::IsWindow(m_hWndPaint))
						::ClientToScreen(m_hWndPaint, &ptCheckScreen);
					const int dx = ptCheckScreen.x - s_ptLastTouchScreen.x;
					const int dy = ptCheckScreen.y - s_ptLastTouchScreen.y;
					if (dx <= 8 && dx >= -8 && dy <= 8 && dy >= -8)
						break;
					s_bSuppressHoverAfterTouch = false;
				}

				// Start tracking this entire window again...
				if (!m_bMouseTracking)
				{
					TRACKMOUSEEVENT tme = { 0 };
					tme.cbSize = sizeof(TRACKMOUSEEVENT);
					tme.dwFlags = TME_HOVER | TME_LEAVE;
					tme.hwndTrack = m_hWndPaint;
					tme.dwHoverTime = m_hwndTooltip == NULL ? m_iHoverTime : (DWORD) ::SendMessage(m_hwndTooltip, TTM_GETDELAYTIME, TTDT_INITIAL, 0L);
					_TrackMouseEvent(&tme);
					m_bMouseTracking = true;
				}

				// Generate the appropriate mouse messages
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				// 是否移动
				bool bNeedDrag = true;
				if (m_ptLastMousePos.x == pt.x && m_ptLastMousePos.y == pt.y)
				{
					bNeedDrag = false;
				}
				// 记录鼠标位置
				m_ptLastMousePos = pt;
				CControlUI* pNewHover = FindControl(pt);
				if (pNewHover != NULL && pNewHover->GetManager() != this) break;

				// 拖拽事件
				if (bNeedDrag && m_bDragMode && wParam == MK_LBUTTON)
				{
					// 释放Capture
					::ReleaseCapture();
					// 接口
					if (m_pDragDrop != NULL && m_pDragDrop->OnDragDrop(m_pEventClick))
					{

						m_bDragMode = false;
						break;
					}

					CIDropSource* pdsrc = new CIDropSource;
					if (pdsrc == NULL) return 0;
					pdsrc->AddRef();

					CIDataObject* pdobj = new CIDataObject(pdsrc);
					if (pdobj == NULL) return 0;
					pdobj->AddRef();

					FORMATETC fmtetc = { 0 };
					STGMEDIUM medium = { 0 };
					fmtetc.dwAspect = DVASPECT_CONTENT;
					fmtetc.lindex = -1;
					fmtetc.cfFormat = CF_BITMAP;
					fmtetc.tymed = TYMED_GDI;

					//////////////////////////////////////
					HBITMAP hBitmap = (HBITMAP)OleDuplicateData(m_hDragBitmap, fmtetc.cfFormat, NULL);
					medium.hBitmap = hBitmap;
					pdobj->SetData(&fmtetc, &medium, FALSE);

					//////////////////////////////////////
					BITMAP bmap;
					GetObject(hBitmap, sizeof(BITMAP), &bmap);
					RECT rc = { 0, 0, bmap.bmWidth, bmap.bmHeight };
					fmtetc.cfFormat = CF_ENHMETAFILE;
					fmtetc.tymed = TYMED_ENHMF;
					HDC hMetaDC = CreateEnhMetaFile(m_hDcPaint, NULL, NULL, NULL);
					HDC hdcMem = CreateCompatibleDC(m_hDcPaint);
					HGDIOBJ hOldBmp = ::SelectObject(hdcMem, hBitmap);
					::BitBlt(hMetaDC, 0, 0, rc.right, rc.bottom, hdcMem, 0, 0, SRCCOPY);
					::SelectObject(hdcMem, hOldBmp);
					medium.hEnhMetaFile = CloseEnhMetaFile(hMetaDC);
					DeleteDC(hdcMem);
					medium.tymed = TYMED_ENHMF;
					pdobj->SetData(&fmtetc, &medium, TRUE);
					//////////////////////////////////////
					CDragSourceHelper dragSrcHelper;
					POINT ptDrag = { 0 };
					ptDrag.x = bmap.bmWidth / 2;
					ptDrag.y = bmap.bmHeight / 2;
					dragSrcHelper.InitializeFromBitmap(hBitmap, ptDrag, rc, pdobj); //will own the bmp
					DWORD dwEffect;
					HRESULT hr = ::DoDragDrop(pdobj, pdsrc, DROPEFFECT_COPY | DROPEFFECT_MOVE, &dwEffect);
					if (dwEffect) pdsrc->Release();
					else delete pdsrc;
					pdobj->Release();
					m_bDragMode = false;
					break;
				}

				TEventUI event = { 0 };
				event.ptMouse = pt;
				event.wParam = wParam;
				event.lParam = lParam;
				event.dwTimestamp = ::GetTickCount();
				event.wKeyState = MapKeyState();
				// 悬浮态总闸：触摸提升出来的合成鼠标消息（MOUSEEVENTF_FROMTOUCH）不参与
				// 悬浮 enter/leave。触摸没有“光标停留”语义，一旦让它参与，就会出现
				// “点过的控件一直高亮 / 连点几个控件后多个同时高亮、怎么点都清不掉”的顽疾
				// （按钮的 UISTATE_HOT、列表项的 UISTATE_HOT 全靠 MOUSEENTER/MOUSELEAVE 维护）。
				// 该判断只影响悬浮段，消息依旧往下走 → 点击/拖拽状态机不受影响。
				//
				// [第十一轮诊断] 悬浮态不消失时，这里能看出是被哪一道闸门挡住的。
				if (!IsCaptured() && !bPromotedTouchMove)
				{
					pNewHover = FindControl(pt);
					if (pNewHover != NULL && pNewHover->GetManager() != this) break;
					if (pNewHover != m_pEventHover && m_pEventHover != NULL)
					{
						event.Type = UIEVENT_MOUSELEAVE;
						event.pSender = m_pEventHover;

						CStdPtrArray aNeedMouseLeaveNeeded(m_aNeedMouseLeaveNeeded.GetSize());
						aNeedMouseLeaveNeeded.Resize(m_aNeedMouseLeaveNeeded.GetSize());
						::CopyMemory(aNeedMouseLeaveNeeded.GetData(), m_aNeedMouseLeaveNeeded.GetData(), m_aNeedMouseLeaveNeeded.GetSize() * sizeof(LPVOID));
						for (int i = 0; i < aNeedMouseLeaveNeeded.GetSize(); i++)
						{
							static_cast<CControlUI*>(aNeedMouseLeaveNeeded[i])->Event(event);
						}

						DuiLibDiag::Log(_T("MOUSEMOVE-LEAVE old=%s leaveArr=%d new=%s pt=%d,%d"),
							m_pEventHover->GetName().GetData(), m_aNeedMouseLeaveNeeded.GetSize(),
							pNewHover != NULL ? pNewHover->GetName().GetData() : _T("null"), pt.x, pt.y);
						m_pEventHover->Event(event);
						m_pEventHover = NULL;
						if (m_hwndTooltip != NULL) ::SendMessage(m_hwndTooltip, TTM_TRACKACTIVATE, FALSE, (LPARAM)&m_ToolTip);
					}
					if (pNewHover != m_pEventHover && pNewHover != NULL)
					{
						event.Type = UIEVENT_MOUSEENTER;
						event.pSender = pNewHover;
						pNewHover->Event(event);
						m_pEventHover = pNewHover;
						DuiLibDiag::Log(_T("HOVER-ENTER %s cls=%s pt=%d,%d"),
							pNewHover->GetName().GetData(), pNewHover->GetClass(), pt.x, pt.y);
					}
				}
				else
				{
					// [第十一轮诊断] 被闸门挡住时明确记录，否则"悬浮态为何没更新"无从判断。
					DuiLibDiag::Log(_T("HOVER-GATE-BLOCKED captured=%d promotedMove=%d curHover=%s pt=%d,%d"),
						(int)IsCaptured(), (int)bPromotedTouchMove,
						m_pEventHover != NULL ? m_pEventHover->GetName().GetData() : _T("null"),
						pt.x, pt.y);
				}
				if (m_pEventClick != NULL)
				{
					event.Type = UIEVENT_MOUSEMOVE;
					event.pSender = m_pEventClick;
					m_pEventClick->Event(event);
				}
				else if (pNewHover != NULL)
				{
					event.Type = UIEVENT_MOUSEMOVE;
					event.pSender = pNewHover;
					pNewHover->Event(event);
				}
			}
			break;
			case WM_LBUTTONDOWN:
			{
				DuiLibDiag::Log(_T("WM_LBUTTONDOWN promoted=%d pt=%d,%d eventTouch=%s eventClick=%s"),
					(int)IsPromotedTouchMouseMessage(), GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
					m_pEventTouch != NULL ? m_pEventTouch->GetName().GetData() : _T("null"),
					m_pEventClick != NULL ? m_pEventClick->GetName().GetData() : _T("null"));
				// WM_TOUCH 后 Windows 可能补发 WM_LBUTTONDOWN。触摸点击由 TOUCHUP
				// 的 tap 判定统一处理，不能让这条合成消息提前建立鼠标点击状态。
				if (m_pEventTouch != NULL || m_bSuppressPromotedTouchMouse)
					break;
				// We alway set focus back to our app (this helps
				// when Win32 child windows are placed on the dialog
				// and we need to remove them on focus change).
				if (!m_bNoActivate) ::SetFocus(m_hWndPaint);
				if (m_pRoot == NULL) break;
				// 查找控件
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				CControlUI* pControl = FindControl(pt);
				if (pControl == NULL)
				{
					DuiLibDiag::Log(_T("LBUTTONDOWN no control hwnd=%p pt=%d,%d root=%p"),
						(void*)m_hWndPaint, pt.x, pt.y, (void*)m_pRoot);
					break;
				}
				if (pControl->GetManager() != this)
				{
					DuiLibDiag::Log(_T("LBUTTONDOWN foreign control hwnd=%p pt=%d,%d name=%s manager=%p self=%p"),
						(void*)m_hWndPaint, pt.x, pt.y, pControl->GetName().GetData(),
						(void*)pControl->GetManager(), (void*)this);
					break;
				}
				DuiLibDiag::Log(_T("LBUTTONDOWN hit hwnd=%p name=%s class=%s pos=%d,%d,%d,%d enabled=%d visible=%d"),
					(void*)m_hWndPaint, pControl->GetName().GetData(), pControl->GetClass(),
					pControl->GetPos().left, pControl->GetPos().top, pControl->GetPos().right, pControl->GetPos().bottom,
					(int)pControl->IsEnabled(), (int)pControl->IsVisible());

				// 准备拖拽
				if (m_bDragDrop && pControl->IsDragEnabled())
				{
					m_bDragMode = true;
					if (m_hDragBitmap != NULL)
					{
						::DeleteObject(m_hDragBitmap);
						m_hDragBitmap = NULL;
					}
					m_hDragBitmap = CRenderEngine::GenerateBitmap(this, pControl, pControl->GetPos());
				}

				// 开启捕获
				SetCapture();
				// 事件处理
				m_pEventClick = pControl;
				pControl->SetFocus();

				TEventUI event = { 0 };
				event.Type = UIEVENT_BUTTONDOWN;
				event.pSender = pControl;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();
				pControl->Event(event);

			}
			break;
			case WM_LBUTTONDBLCLK:
			{
				if (!m_bNoActivate) ::SetFocus(m_hWndPaint);

				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				CControlUI* pControl = FindControl(pt);
				if (pControl == NULL) break;
				if (pControl->GetManager() != this) break;
				//SetCapture();
				TEventUI event = { 0 };
				event.Type = UIEVENT_DBLCLICK;
				event.pSender = pControl;
				event.ptMouse = pt;
				event.wParam = wParam;
				event.lParam = lParam;
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();
				pControl->Event(event);
				m_pEventClick = pControl;
			}
			break;
			case WM_LBUTTONUP:
			{
				DuiLibDiag::Log(_T("WM_LBUTTONUP promoted=%d pt=%d,%d eventTouch=%s eventClick=%s moved=%d"),
					(int)IsPromotedTouchMouseMessage(), GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
					m_pEventTouch != NULL ? m_pEventTouch->GetName().GetData() : _T("null"),
					m_pEventClick != NULL ? m_pEventClick->GetName().GetData() : _T("null"),
					(int)m_bTouchMoved);
				const bool bPromotedTouchUp = IsPromotedTouchMouseMessage();
				// 触摸手势进行中 / 刚由触摸链合成过点击 ⇒ 这条提升出来的鼠标抬起
				// 一律不参与点击判定，直接丢掉（tap/drag 判定只在触摸链里做一次）。
				//
				// ⚠️ 副作用，别忽视：这条 break 也【丢掉了 ReleaseCapture()】。
				//   所以捕获必须由触摸链自己释放 —— BeginTouchSlideGesture 里 SetCapture()，
				//   对应的 ReleaseCapture() 在 EndTouchSlideGesture（命中控件那条路径）里。
				//   若哪天把 End 里的 ReleaseCapture 挪走，这里就会漏捕获（表现为
				//   后续所有鼠标消息都跑到本窗口、点别处不响应）。
				// ==============================================================
				// [触摸抬起的视觉收尾 · 位置是死线]
				//
				// ⚠️⚠️ 必须在下面那条早退路 break **之前**执行。⚠️⚠️
				//
				//   触摸轻点放行的那条配对 WM_LBUTTONUP，正好会走下面
				//   `if (m_pEventTouch != NULL || m_bSuppressPromotedTouchMouse)` 的早退路
				//   （正常情况下 m_pEventTouch 已释放、m_bSuppressPromotedTouchMouse 为假，
				//    于是**不会**早退，会走到最末 pClick->Event(BUTTONUP)）。
				//   但凡早退，这里的收尾就必须已经做完了 —— 写在这条 break 之后
				//   等于"触摸抬起时永远不执行"（历史踩过的坑）。
				//
				// 现象（用户真机，Win10）本块针对的两个：
				//   ① 点商品「古古怪怪」→ 属性弹框弹出 → 「古古怪怪」的**按下态**不消失；
				//   ② 之后在弹框里点「选好了」（弹框内该按钮与背后商品「属性测试」
				//      屏幕位置重合）→ 弹框消失，但「属性测试」成了**悬浮态**。
				//
				// 成因与修法见 UIManager.h 里 TouchUp 的注释（顺序修复）：
				//   · ① 由 TouchUp 在**业务回调之前**清按下态解决；
				//   · ② 由本块 ClearTouchHoverState 收走"没配对的悬浮态"解决 ——
				//     抬起点下方的控件可能从没收到过 MOUSEENTER（触摸无悬浮语义），
				//     却因为光标停在它上面而保留 HOT；这里显式收掉。
				// ==============================================================
				const POINT ptButtonUp = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				if (bPromotedTouchUp)
				{
					// (a) 收悬浮态：给登记表内控件 + m_pEventHover 补发 MOUSELEAVE，
					//     并清掉"抬起点下那个控件"残留的 HOT（触摸从没给它发过 ENTER）。
					ClearTouchHoverState(ptButtonUp);
					// (b) 收输入态：抬起点命中的那个控件。
					//     ⚠️ 这里**不做**"向上遍历祖先链"的通用复位 —— 触摸链合成的
					//        BUTTONDOWN 只发给命中控件本身，祖先从未被置位；真正会顶
					//        按下的自定义控件（如商品卡）是在 TouchUp() 里由控件自己的
					//        DoEvent(BUTTONUP) 复位的。
					ClearPushedStateAt(NULL, ptButtonUp);
					// (c) 抬起后禁止"悬浮态复活"（系统会补发合成的 WM_MOUSEMOVE）。
					s_bSuppressHoverAfterTouch = true;
					m_bMouseTracking = false;
				}

				if (m_pEventTouch != NULL || m_bSuppressPromotedTouchMouse)
				{
					m_bSuppressPromotedTouchMouse = false;
					m_dwSuppressTick = 0;
					break;
				}
				if (!bPromotedTouchUp)
				{
					// 普通鼠标点击也不会天然产生 MOUSELEAVE。
					// 点击后光标仍停留在控件上时，必须主动清除 HOT 状态，
					// 否则直到移动到下一个控件前都会保持悬浮态。
					ClearTouchHoverState(ptButtonUp);
				}

				DuiLibDiag::Log(_T("LBUTTONUP moved=%d click=%s hover=%s leaveArr=%d capture=%d"),
					(int)m_bTouchMoved,
					m_pEventClick != NULL ? m_pEventClick->GetName().GetData() : _T("null"),
					m_pEventHover != NULL ? m_pEventHover->GetName().GetData() : _T("null"),
					m_aNeedMouseLeaveNeeded.GetSize(), (int)m_bMouseCapture);
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				CControlUI* pClick = m_pEventClick;
				const bool bTouchDragged = m_bTouchMoved;
				m_pEventClick = NULL;
				m_bTouchMoved = false;  // 用完即清，绝不影响后续真实鼠标点击
				if (pClick == NULL)
				{
					DuiLibDiag::Log(_T("LBUTTONUP no click hwnd=%p pt=%d,%d"),
						(void*)m_hWndPaint, pt.x, pt.y);
					ReleaseCapture();
					break;
				}

				ReleaseCapture();
				TEventUI event = { 0 };
				event.Type = UIEVENT_BUTTONUP;
				event.pSender = pClick;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				if (bTouchDragged && pClick->GetInterface(DUI_CTR_SCROLLBAR) == NULL)
				{
					// 清除按钮的 PUSHED/CAPTURED 状态，但让 CButtonUI 的命中测试失败，
					// 从而不会在滑动结束时调用 Activate。
					event.ptMouse.x = -1;
					event.ptMouse.y = -1;
				}
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();

				pClick->Event(event);
			}
			break;
			case WM_RBUTTONDOWN:
			{
				if (!m_bNoActivate) ::SetFocus(m_hWndPaint);
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				CControlUI* pControl = FindControl(pt);
				if (pControl == NULL) break;
				if (pControl->GetManager() != this) break;
				pControl->SetFocus();
				SetCapture();
				TEventUI event = { 0 };
				event.Type = UIEVENT_RBUTTONDOWN;
				event.pSender = pControl;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();
				pControl->Event(event);
				m_pEventRClick = pControl;
			}
			break;
			case WM_RBUTTONUP:
			{
				if (m_bMouseCapture) ReleaseCapture();

				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				m_pEventRClick = FindControl(pt);
				if (m_pEventRClick == NULL) break;

				TEventUI event = { 0 };
				event.Type = UIEVENT_RBUTTONUP;
				event.pSender = m_pEventRClick;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();
				m_pEventRClick->Event(event);
			}
			break;
			case WM_MBUTTONDOWN:
			{
				if (!m_bNoActivate) ::SetFocus(m_hWndPaint);
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				CControlUI* pControl = FindControl(pt);
				if (pControl == NULL) break;
				if (pControl->GetManager() != this) break;
				pControl->SetFocus();
				SetCapture();
				TEventUI event = { 0 };
				event.Type = UIEVENT_MBUTTONDOWN;
				event.pSender = pControl;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();
				pControl->Event(event);
				m_pEventClick = pControl;
			}
			break;
			case WM_MBUTTONUP:
			{
				if (m_bMouseCapture) ReleaseCapture();
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				m_ptLastMousePos = pt;
				m_pEventClick = FindControl(pt);
				if (m_pEventClick == NULL) break;

				TEventUI event = { 0 };
				event.Type = UIEVENT_MBUTTONUP;
				event.pSender = m_pEventClick;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = (WORD)wParam;
				event.dwTimestamp = ::GetTickCount();
				m_pEventClick->Event(event);
			}
			break;
			case WM_CONTEXTMENU:
			{
				if (m_pRoot == NULL) break;
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				::ScreenToClient(m_hWndPaint, &pt);
				m_ptLastMousePos = pt;
				if (m_pEventRClick == NULL) break;
				ReleaseCapture();
				TEventUI event = { 0 };
				event.Type = UIEVENT_CONTEXTMENU;
				event.pSender = m_pEventRClick;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = (WORD)wParam;
				event.lParam = (LPARAM)m_pEventRClick;
				event.dwTimestamp = ::GetTickCount();
				m_pEventRClick->Event(event);
				m_pEventRClick = NULL;
			}
			break;
			case WM_TOUCH:
			{
				OnTouchInput(wParam, lParam);
				lRes = 0;
				return true;
			}
			case WM_MOUSEWHEEL:
			{
				if (m_pRoot == NULL) break;
				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
				::ScreenToClient(m_hWndPaint, &pt);
				m_ptLastMousePos = pt;
				CControlUI* pControl = FindControl(pt);
				if (pControl == NULL) break;
				if (pControl->GetManager() != this) break;
				int zDelta = (int)(short)HIWORD(wParam);
				TEventUI event = { 0 };
				event.Type = UIEVENT_SCROLLWHEEL;
				event.pSender = pControl;
				event.wParam = MAKEWPARAM(zDelta < 0 ? SB_LINEDOWN : SB_LINEUP, zDelta);
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = MapKeyState();
				event.dwTimestamp = ::GetTickCount();
				pControl->Event(event);

				// Let's make sure that the scroll item below the cursor is the same as before...
				::SendMessage(m_hWndPaint, WM_MOUSEMOVE, 0, (LPARAM)MAKELPARAM(m_ptLastMousePos.x, m_ptLastMousePos.y));
			}
			break;
			case WM_CHAR:
			{
				if (m_pRoot == NULL) break;
				if (m_pFocus == NULL) break;
				TEventUI event = { 0 };
				event.Type = UIEVENT_CHAR;
				event.pSender = m_pFocus;
				event.wParam = wParam;
				event.lParam = lParam;
				event.chKey = (TCHAR)wParam;
				event.ptMouse = m_ptLastMousePos;
				event.wKeyState = MapKeyState();
				event.dwTimestamp = ::GetTickCount();
				m_pFocus->Event(event);
			}
			break;
			case WM_KEYDOWN:
			{
				if (m_pRoot == NULL) break;
				if (m_pFocus == NULL) break;
				TEventUI event = { 0 };
				event.Type = UIEVENT_KEYDOWN;
				event.pSender = m_pFocus;
				event.wParam = wParam;
				event.lParam = lParam;
				event.chKey = (TCHAR)wParam;
				event.ptMouse = m_ptLastMousePos;
				event.wKeyState = MapKeyState();
				event.dwTimestamp = ::GetTickCount();
				m_pFocus->Event(event);
				m_pEventKey = m_pFocus;
			}
			break;
			case WM_KEYUP:
			{
				if (m_pRoot == NULL) break;
				if (m_pEventKey == NULL) break;
				TEventUI event = { 0 };
				event.Type = UIEVENT_KEYUP;
				event.pSender = m_pEventKey;
				event.wParam = wParam;
				event.lParam = lParam;
				event.chKey = (TCHAR)wParam;
				event.ptMouse = m_ptLastMousePos;
				event.wKeyState = MapKeyState();
				event.dwTimestamp = ::GetTickCount();
				m_pEventKey->Event(event);
				m_pEventKey = NULL;
			}
			break;
			case WM_SETCURSOR:
			{
				if (m_pRoot == NULL) break;
				if (LOWORD(lParam) != HTCLIENT) break;
				if (m_bMouseCapture) return true;

				POINT pt = { 0 };
				::GetCursorPos(&pt);
				::ScreenToClient(m_hWndPaint, &pt);
				CControlUI* pControl = FindControl(pt);
				if (pControl == NULL) break;
				if ((pControl->GetControlFlags() & UIFLAG_SETCURSOR) == 0) break;
				TEventUI event = { 0 };
				event.Type = UIEVENT_SETCURSOR;
				event.pSender = pControl;
				event.wParam = wParam;
				event.lParam = lParam;
				event.ptMouse = pt;
				event.wKeyState = MapKeyState();
				event.dwTimestamp = ::GetTickCount();
				pControl->Event(event);
			}
			return true;
			case WM_SETFOCUS:
			{
				if (m_pFocus != NULL)
				{
					TEventUI event = { 0 };
					event.Type = UIEVENT_SETFOCUS;
					event.wParam = wParam;
					event.lParam = lParam;
					event.pSender = m_pFocus;
					event.dwTimestamp = ::GetTickCount();
					m_pFocus->Event(event);
				}
				break;
			}
			case WM_KILLFOCUS:
			{
				if (IsCaptured()) ReleaseCapture();
				break;
			}
			case WM_NOTIFY:
			{
				if (lParam == 0) break;
				LPNMHDR lpNMHDR = (LPNMHDR)lParam;
				if (lpNMHDR != NULL) lRes = ::SendMessage(lpNMHDR->hwndFrom, OCM__BASE + uMsg, wParam, lParam);
				return true;
			}
			break;
			case WM_COMMAND:
			{
				if (lParam == 0) break;
				HWND hWndChild = (HWND)lParam;
				lRes = ::SendMessage(hWndChild, OCM__BASE + uMsg, wParam, lParam);
				if (lRes != 0) return true;
			}
			break;
			case WM_CTLCOLOREDIT:
			case WM_CTLCOLORSTATIC:
			{
				// Refer To: http://msdn.microsoft.com/en-us/library/bb761691(v=vs.85).aspx
				// Read-only or disabled edit controls do not send the WM_CTLCOLOREDIT message; instead, they send the WM_CTLCOLORSTATIC message.
				if (lParam == 0) break;
				HWND hWndChild = (HWND)lParam;
				lRes = ::SendMessage(hWndChild, OCM__BASE + uMsg, wParam, lParam);
				if (lRes != 0) return true;
			}
			break;
			default:
				break;
		}
		return false;
	}

	bool CPaintManagerUI::IsUpdateNeeded() const
	{
		return m_bUpdateNeeded;
	}

	void CPaintManagerUI::NeedUpdate()
	{
		m_bUpdateNeeded = true;
	}

	void CPaintManagerUI::Invalidate()
	{
		RECT rcClient = { 0 };
		::GetClientRect(m_hWndPaint, &rcClient);
		::UnionRect(&m_rcLayeredUpdate, &m_rcLayeredUpdate, &rcClient);
		::InvalidateRect(m_hWndPaint, NULL, FALSE);
	}

	void CPaintManagerUI::Invalidate(RECT& rcItem)
	{
		if (rcItem.left < 0) rcItem.left = 0;
		if (rcItem.top < 0) rcItem.top = 0;
		if (rcItem.right < rcItem.left) rcItem.right = rcItem.left;
		if (rcItem.bottom < rcItem.top) rcItem.bottom = rcItem.top;
		::UnionRect(&m_rcLayeredUpdate, &m_rcLayeredUpdate, &rcItem);
		::InvalidateRect(m_hWndPaint, &rcItem, FALSE);
	}

	bool CPaintManagerUI::IsValid()
	{
		return m_hWndPaint != NULL && m_pRoot != NULL;
	}

	// ---------------------------------------------------------------------------
	// [第十一轮诊断] 只读快照访问器（声明在 UIManager.h；实现在这里是因为
	// CControlUI 在头文件里只有前向声明，解引用需要完整类型）。
	// 只为日志读值，不改变任何行为；问题定位后可随之删除。
	// ---------------------------------------------------------------------------
	LPCTSTR CPaintManagerUI::DbgHoverName() const
	{
		return (m_pEventHover != NULL) ? m_pEventHover->GetName().GetData() : _T("null");
	}

	LPCTSTR CPaintManagerUI::DbgRClickName() const
	{
		return (m_pEventRClick != NULL) ? m_pEventRClick->GetName().GetData() : _T("null");
	}

	bool CPaintManagerUI::AttachDialog(CControlUI* pControl)
	{
		ASSERT(::IsWindow(m_hWndPaint));
		// 创建阴影窗口
		m_shadow.Create(this);

		// Reset any previous attachment
		SetFocus(NULL);
		m_pEventKey = NULL;
		m_pEventHover = NULL;
		m_pEventClick = NULL;
		m_pEventRClick = NULL;
		// Remove the existing control-tree. We might have gotten inside this function as
		// a result of an event fired or similar, so we cannot just delete the objects and
		// pull the internal memory of the calling code. We'll delay the cleanup.
		if (m_pRoot != NULL)
		{
			m_aPostPaintControls.Empty();
			AddDelayedCleanup(m_pRoot);
		}
		// Set the dialog root element
		m_pRoot = pControl;
		// Go ahead...
		m_bUpdateNeeded = true;
		m_bFirstLayout = true;
		m_bFocusNeeded = true;
		// Initiate all control
		return InitControls(pControl);
	}

	bool CPaintManagerUI::InitControls(CControlUI* pControl, CControlUI* pParent /*= NULL*/)
	{
		ASSERT(pControl);
		if (pControl == NULL) return false;
		pControl->SetManager(this, pParent != NULL ? pParent : pControl->GetParent(), true);
		pControl->FindControl(__FindControlFromNameHash, this, UIFIND_ALL);
		return true;
	}

	void CPaintManagerUI::ReapObjects(CControlUI* pControl)
	{
		if (pControl == m_pEventKey) m_pEventKey = NULL;
		if (pControl == m_pEventHover) m_pEventHover = NULL;
		if (pControl == m_pEventClick) m_pEventClick = NULL;
		if (pControl == m_pEventRClick) m_pEventRClick = NULL;
		if (pControl == m_pFocus) m_pFocus = NULL;
		KillTimer(pControl);
		const CDuiString& sName = pControl->GetName();
		if (!sName.IsEmpty())
		{
			if (pControl == FindControl(sName)) m_mNameHash.Remove(sName);
		}
		for (int i = 0; i < m_aAsyncNotify.GetSize(); i++)
		{
			TNotifyUI* pMsg = static_cast<TNotifyUI*>(m_aAsyncNotify[i]);
			if (pMsg->pSender == pControl) pMsg->pSender = NULL;
		}
	}

	bool CPaintManagerUI::AddOptionGroup(LPCTSTR pStrGroupName, CControlUI* pControl)
	{
		LPVOID lp = m_mOptionGroup.Find(pStrGroupName);
		if (lp)
		{
			CStdPtrArray* aOptionGroup = static_cast<CStdPtrArray*>(lp);
			for (int i = 0; i < aOptionGroup->GetSize(); i++)
			{
				if (static_cast<CControlUI*>(aOptionGroup->GetAt(i)) == pControl)
				{
					return false;
				}
			}
			aOptionGroup->Add(pControl);
		}
		else
		{
			CStdPtrArray* aOptionGroup = new CStdPtrArray(6);
			aOptionGroup->Add(pControl);
			m_mOptionGroup.Insert(pStrGroupName, aOptionGroup);
		}
		return true;
	}

	CStdPtrArray* CPaintManagerUI::GetOptionGroup(LPCTSTR pStrGroupName)
	{
		LPVOID lp = m_mOptionGroup.Find(pStrGroupName);
		if (lp) return static_cast<CStdPtrArray*>(lp);
		return NULL;
	}

	void CPaintManagerUI::RemoveOptionGroup(LPCTSTR pStrGroupName, CControlUI* pControl)
	{
		LPVOID lp = m_mOptionGroup.Find(pStrGroupName);
		if (lp)
		{
			CStdPtrArray* aOptionGroup = static_cast<CStdPtrArray*>(lp);
			if (aOptionGroup == NULL) return;
			for (int i = 0; i < aOptionGroup->GetSize(); i++)
			{
				if (static_cast<CControlUI*>(aOptionGroup->GetAt(i)) == pControl)
				{
					aOptionGroup->Remove(i);
					break;
				}
			}
			if (aOptionGroup->IsEmpty())
			{
				delete aOptionGroup;
				m_mOptionGroup.Remove(pStrGroupName);
			}
		}
	}

	void CPaintManagerUI::RemoveAllOptionGroups()
	{
		CStdPtrArray* aOptionGroup;
		for (int i = 0; i < m_mOptionGroup.GetSize(); i++)
		{
			if (LPCTSTR key = m_mOptionGroup.GetAt(i))
			{
				aOptionGroup = static_cast<CStdPtrArray*>(m_mOptionGroup.Find(key));
				delete aOptionGroup;
			}
		}
		m_mOptionGroup.RemoveAll();
	}

	void CPaintManagerUI::MessageLoop()
	{
		MSG msg = { 0 };
		while (::GetMessage(&msg, NULL, 0, 0))
		{
			if (!CPaintManagerUI::TranslateMessage(&msg))
			{
				::TranslateMessage(&msg);
				try
				{
					::DispatchMessage(&msg);
				}
				catch (...)
				{
					DUITRACE(_T("EXCEPTION: %s(%d)\n"), __FILET__, __LINE__);
#ifdef _DEBUG
					throw "CPaintManagerUI::MessageLoop";
#endif
				}
			}
		}
	}

	void CPaintManagerUI::Term()
	{
		// 销毁资源管理器
		CResourceManager::GetInstance()->Release();
		CControlFactory::GetInstance()->Release();

		// 清理共享资源
		// 图片
		TImageInfo* data;
		for (int i = 0; i < m_SharedResInfo.m_ImageHash.GetSize(); i++)
		{
			if (LPCTSTR key = m_SharedResInfo.m_ImageHash.GetAt(i))
			{
				data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(key, false));
				if (data)
				{
					CRenderEngine::FreeImage(data);
					data = NULL;
				}
			}
		}
		m_SharedResInfo.m_ImageHash.RemoveAll();
		// 字体
		TFontInfo* pFontInfo;
		for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
		{
			if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
			{
				pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key, false));
				if (pFontInfo)
				{
					::DeleteObject(pFontInfo->hFont);
					delete pFontInfo;
					pFontInfo = NULL;
				}
			}
		}
		m_SharedResInfo.m_CustomFonts.RemoveAll();
		// 默认字体
		if (m_SharedResInfo.m_DefaultFontInfo.hFont != NULL)
		{
			::DeleteObject(m_SharedResInfo.m_DefaultFontInfo.hFont);
		}
		// 样式
		CDuiString* pStyle;
		for (int i = 0; i < m_SharedResInfo.m_StyleHash.GetSize(); i++)
		{
			if (LPCTSTR key = m_SharedResInfo.m_StyleHash.GetAt(i))
			{
				pStyle = static_cast<CDuiString*>(m_SharedResInfo.m_StyleHash.Find(key, false));
				if (pStyle)
				{
					delete pStyle;
					pStyle = NULL;
				}
			}
		}
		m_SharedResInfo.m_StyleHash.RemoveAll();

		// 样式
		CDuiString* pAttr;
		for (int i = 0; i < m_SharedResInfo.m_AttrHash.GetSize(); i++)
		{
			if (LPCTSTR key = m_SharedResInfo.m_AttrHash.GetAt(i))
			{
				pAttr = static_cast<CDuiString*>(m_SharedResInfo.m_AttrHash.Find(key, false));
				if (pAttr)
				{
					delete pAttr;
					pAttr = NULL;
				}
			}
		}
		m_SharedResInfo.m_AttrHash.RemoveAll();

		// 关闭ZIP
		if (m_bCachedResourceZip && m_hResourceZip != NULL)
		{
			CloseZip((HZIP)m_hResourceZip);
			m_hResourceZip = NULL;
		}

		if (m_cbZipBuf)
		{
			delete[] m_cbZipBuf;
			m_cbZipBuf = nullptr;
		}
	}

	CDPI* DuiLib::CPaintManagerUI::GetDPIObj()
	{
		if (m_pDPI == NULL)
		{
			m_pDPI = new CDPI;
		}
		return m_pDPI;
	}

	void DuiLib::CPaintManagerUI::SetDPI(int iDPI)
	{
		int scale1 = GetDPIObj()->GetScale();
		GetDPIObj()->SetScale(iDPI);
		int scale2 = GetDPIObj()->GetScale();
		ResetDPIAssets();
		RECT rcWnd = { 0 };
		::GetWindowRect(GetPaintWindow(), &rcWnd);
		RECT* prcNewWindow = &rcWnd;
		if (!::IsZoomed(GetPaintWindow()))
		{
			RECT rc = rcWnd;
			rc.right = rcWnd.left + (rcWnd.right - rcWnd.left) * scale2 / scale1;
			rc.bottom = rcWnd.top + (rcWnd.bottom - rcWnd.top) * scale2 / scale1;
			prcNewWindow = &rc;
		}
		SetWindowPos(GetPaintWindow(), NULL, prcNewWindow->left, prcNewWindow->top, prcNewWindow->right - prcNewWindow->left, prcNewWindow->bottom - prcNewWindow->top, SWP_NOZORDER | SWP_NOACTIVATE);
		if (GetRoot() != NULL) GetRoot()->NeedUpdate();
		::PostMessage(GetPaintWindow(), UIMSG_SET_DPI, 0, 0);
	}

	void DuiLib::CPaintManagerUI::SetAllDPI(int iDPI)
	{
		for (int i = 0; i < m_aPreMessages.GetSize(); i++)
		{
			CPaintManagerUI* pManager = static_cast<CPaintManagerUI*>(m_aPreMessages[i]);
			pManager->SetDPI(iDPI);
		}
	}

	void DuiLib::CPaintManagerUI::ResetDPIAssets()
	{
		RemoveAllDrawInfos();
		RemoveAllImages();;

		for (int it = 0; it < m_ResInfo.m_CustomFonts.GetSize(); it++)
		{
			TFontInfo* pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(m_ResInfo.m_CustomFonts[it]));
			RebuildFont(pFontInfo);
		}
		RebuildFont(&m_ResInfo.m_DefaultFontInfo);

		for (int it = 0; it < m_SharedResInfo.m_CustomFonts.GetSize(); it++)
		{
			TFontInfo* pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(m_SharedResInfo.m_CustomFonts[it]));
			RebuildFont(pFontInfo);
		}
		RebuildFont(&m_SharedResInfo.m_DefaultFontInfo);

		CStdPtrArray* richEditList = FindSubControlsByClass(GetRoot(), _T("RichEditUI"));
		for (int i = 0; i < richEditList->GetSize(); i++)
		{
			CRichEditUI* pT = static_cast<CRichEditUI*>((*richEditList)[i]);
			pT->SetFont(pT->GetFont());

		}
	}

	void DuiLib::CPaintManagerUI::RebuildFont(TFontInfo* pFontInfo)
	{
		::DeleteObject(pFontInfo->hFont);
		LOGFONT lf = { 0 };
		::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
		_tcsncpy(lf.lfFaceName, pFontInfo->sFontName, LF_FACESIZE);
		lf.lfCharSet = DEFAULT_CHARSET;
		lf.lfHeight = -GetDPIObj()->Scale(pFontInfo->iSize);
		lf.lfQuality = CLEARTYPE_QUALITY;
		if (pFontInfo->bBold) lf.lfWeight += FW_BOLD;
		if (pFontInfo->bUnderline) lf.lfUnderline = TRUE;
		if (pFontInfo->bItalic) lf.lfItalic = TRUE;
		HFONT hFont = ::CreateFontIndirect(&lf);
		pFontInfo->hFont = hFont;
		::ZeroMemory(&(pFontInfo->tm), sizeof(pFontInfo->tm));
		if (m_hDcPaint)
		{
			HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, hFont);
			::GetTextMetrics(m_hDcPaint, &pFontInfo->tm);
			::SelectObject(m_hDcPaint, hOldFont);
		}
	}

	CControlUI* CPaintManagerUI::GetFocus() const
	{
		return m_pFocus;
	}

	void CPaintManagerUI::SetFocus(CControlUI* pControl)
	{
		// Paint manager window has focus?
		HWND hFocusWnd = ::GetFocus();
		if (!m_bNoActivate && hFocusWnd != m_hWndPaint && pControl != m_pFocus) ::SetFocus(m_hWndPaint);
		// Already has focus?
		if (pControl == m_pFocus) return;
		// Remove focus from old control
		if (m_pFocus != NULL)
		{
			TEventUI event = { 0 };
			event.Type = UIEVENT_KILLFOCUS;
			event.pSender = pControl;
			event.dwTimestamp = ::GetTickCount();
			m_pFocus->Event(event);
			SendNotify(m_pFocus, DUI_MSGTYPE_KILLFOCUS);
			m_pFocus = NULL;
		}
		if (pControl == NULL) return;
		// Set focus to new control
		if (pControl != NULL
			&& pControl->GetManager() == this
			&& pControl->IsVisible()
			&& pControl->IsEnabled())
		{
			m_pFocus = pControl;
			TEventUI event = { 0 };
			event.Type = UIEVENT_SETFOCUS;
			event.pSender = pControl;
			event.dwTimestamp = ::GetTickCount();
			m_pFocus->Event(event);
			SendNotify(m_pFocus, DUI_MSGTYPE_SETFOCUS);
		}
	}

	void CPaintManagerUI::SetFocusNeeded(CControlUI* pControl)
	{
		if (!m_bNoActivate) ::SetFocus(m_hWndPaint);
		if (pControl == NULL) return;
		if (m_pFocus != NULL)
		{
			TEventUI event = { 0 };
			event.Type = UIEVENT_KILLFOCUS;
			event.pSender = pControl;
			event.dwTimestamp = ::GetTickCount();
			m_pFocus->Event(event);
			SendNotify(m_pFocus, DUI_MSGTYPE_KILLFOCUS);
			m_pFocus = NULL;
		}
		FINDTABINFO info = { 0 };
		info.pFocus = pControl;
		info.bForward = false;
		m_pFocus = m_pRoot->FindControl(__FindControlFromTab, &info, UIFIND_VISIBLE | UIFIND_ENABLED | UIFIND_ME_FIRST);
		m_bFocusNeeded = true;
		if (m_pRoot != NULL) m_pRoot->NeedUpdate();
	}

	bool CPaintManagerUI::SetTimer(CControlUI* pControl, UINT nTimerID, UINT uElapse)
	{
		ASSERT(pControl != NULL);
		ASSERT(uElapse > 0);
		for (int i = 0; i < m_aTimers.GetSize(); i++)
		{
			TIMERINFO* pTimer = static_cast<TIMERINFO*>(m_aTimers[i]);
			if (pTimer->pSender == pControl
				&& pTimer->hWnd == m_hWndPaint
				&& pTimer->nLocalID == nTimerID)
			{
				if (pTimer->bKilled == true)
				{
					if (::SetTimer(m_hWndPaint, pTimer->uWinTimer, uElapse, NULL))
					{
						pTimer->bKilled = false;
						return true;
					}
					return false;
				}
				return false;
			}
		}

		m_uTimerID = (++m_uTimerID) % 0xF0; //0xf1-0xfe特殊用途
		if (!::SetTimer(m_hWndPaint, m_uTimerID, uElapse, NULL)) return FALSE;
		TIMERINFO* pTimer = new TIMERINFO;
		if (pTimer == NULL) return FALSE;
		pTimer->hWnd = m_hWndPaint;
		pTimer->pSender = pControl;
		pTimer->nLocalID = nTimerID;
		pTimer->uWinTimer = m_uTimerID;
		pTimer->bKilled = false;
		return m_aTimers.Add(pTimer);
	}

	bool CPaintManagerUI::KillTimer(CControlUI* pControl, UINT nTimerID)
	{
		ASSERT(pControl != NULL);
		for (int i = 0; i < m_aTimers.GetSize(); i++)
		{
			TIMERINFO* pTimer = static_cast<TIMERINFO*>(m_aTimers[i]);
			if (pTimer->pSender == pControl
				&& pTimer->hWnd == m_hWndPaint
				&& pTimer->nLocalID == nTimerID)
			{
				if (pTimer->bKilled == false)
				{
					if (::IsWindow(m_hWndPaint)) ::KillTimer(pTimer->hWnd, pTimer->uWinTimer);
					pTimer->bKilled = true;
					return true;
				}
			}
		}
		return false;
	}

	void CPaintManagerUI::KillTimer(CControlUI* pControl)
	{
		ASSERT(pControl != NULL);
		int count = m_aTimers.GetSize();
		for (int i = 0, j = 0; i < count; i++)
		{
			TIMERINFO* pTimer = static_cast<TIMERINFO*>(m_aTimers[i - j]);
			if (pTimer->pSender == pControl && pTimer->hWnd == m_hWndPaint)
			{
				if (pTimer->bKilled == false) ::KillTimer(pTimer->hWnd, pTimer->uWinTimer);
				delete pTimer;
				m_aTimers.Remove(i - j);
				j++;
			}
		}
	}

	void CPaintManagerUI::RemoveAllTimers()
	{
		for (int i = 0; i < m_aTimers.GetSize(); i++)
		{
			TIMERINFO* pTimer = static_cast<TIMERINFO*>(m_aTimers[i]);
			if (pTimer->hWnd == m_hWndPaint)
			{
				if (pTimer->bKilled == false)
				{
					if (::IsWindow(m_hWndPaint)) ::KillTimer(m_hWndPaint, pTimer->uWinTimer);
				}
				delete pTimer;
			}
		}

		m_aTimers.Empty();
	}

	void CPaintManagerUI::SetCapture()
	{
		::SetCapture(m_hWndPaint);
		m_bMouseCapture = true;
	}

	void CPaintManagerUI::ReleaseCapture()
	{
		::ReleaseCapture();
		m_bMouseCapture = false;
		m_bDragMode = false;
	}

	bool CPaintManagerUI::IsCaptured()
	{
		return m_bMouseCapture;
	}

	bool CPaintManagerUI::IsPainting()
	{
		return m_bIsPainting;
	}

	void CPaintManagerUI::SetPainting(bool bIsPainting)
	{
		m_bIsPainting = bIsPainting;
	}

	bool CPaintManagerUI::SetNextTabControl(bool bForward)
	{
		// If we're in the process of restructuring the layout we can delay the
		// focus calulation until the next repaint.
		if (m_bUpdateNeeded && bForward)
		{
			m_bFocusNeeded = true;
			::InvalidateRect(m_hWndPaint, NULL, FALSE);
			return true;
		}
		// Find next/previous tabbable control
		FINDTABINFO info1 = { 0 };
		info1.pFocus = m_pFocus;
		info1.bForward = bForward;
		CControlUI* pControl = m_pRoot->FindControl(__FindControlFromTab, &info1, UIFIND_VISIBLE | UIFIND_ENABLED | UIFIND_ME_FIRST);
		if (pControl == NULL)
		{
			if (bForward)
			{
				// Wrap around
				FINDTABINFO info2 = { 0 };
				info2.pFocus = bForward ? NULL : info1.pLast;
				info2.bForward = bForward;
				pControl = m_pRoot->FindControl(__FindControlFromTab, &info2, UIFIND_VISIBLE | UIFIND_ENABLED | UIFIND_ME_FIRST);
			}
			else
			{
				pControl = info1.pLast;
			}
		}
		if (pControl != NULL) SetFocus(pControl);
		m_bFocusNeeded = false;
		return true;
	}

	bool CPaintManagerUI::AddNotifier(INotifyUI* pNotifier)
	{
		ASSERT(m_aNotifiers.Find(pNotifier) < 0);
		return m_aNotifiers.Add(pNotifier);
	}

	bool CPaintManagerUI::RemoveNotifier(INotifyUI* pNotifier)
	{
		for (int i = 0; i < m_aNotifiers.GetSize(); i++)
		{
			if (static_cast<INotifyUI*>(m_aNotifiers[i]) == pNotifier)
			{
				return m_aNotifiers.Remove(i);
			}
		}
		return false;
	}

	bool CPaintManagerUI::AddPreMessageFilter(IMessageFilterUI* pFilter)
	{
		ASSERT(m_aPreMessageFilters.Find(pFilter) < 0);
		return m_aPreMessageFilters.Add(pFilter);
	}

	bool CPaintManagerUI::RemovePreMessageFilter(IMessageFilterUI* pFilter)
	{
		for (int i = 0; i < m_aPreMessageFilters.GetSize(); i++)
		{
			if (static_cast<IMessageFilterUI*>(m_aPreMessageFilters[i]) == pFilter)
			{
				return m_aPreMessageFilters.Remove(i);
			}
		}
		return false;
	}

	bool CPaintManagerUI::AddMessageFilter(IMessageFilterUI* pFilter)
	{
		ASSERT(m_aMessageFilters.Find(pFilter) < 0);
		return m_aMessageFilters.Add(pFilter);
	}

	bool CPaintManagerUI::RemoveMessageFilter(IMessageFilterUI* pFilter)
	{
		for (int i = 0; i < m_aMessageFilters.GetSize(); i++)
		{
			if (static_cast<IMessageFilterUI*>(m_aMessageFilters[i]) == pFilter)
			{
				return m_aMessageFilters.Remove(i);
			}
		}
		return false;
	}

	int CPaintManagerUI::GetPostPaintCount() const
	{
		return m_aPostPaintControls.GetSize();
	}

	bool CPaintManagerUI::IsPostPaint(CControlUI* pControl)
	{
		return m_aPostPaintControls.Find(pControl) >= 0;
	}

	bool CPaintManagerUI::AddPostPaint(CControlUI* pControl)
	{
		ASSERT(m_aPostPaintControls.Find(pControl) < 0);
		return m_aPostPaintControls.Add(pControl);
	}

	bool CPaintManagerUI::RemovePostPaint(CControlUI* pControl)
	{
		for (int i = 0; i < m_aPostPaintControls.GetSize(); i++)
		{
			if (static_cast<CControlUI*>(m_aPostPaintControls[i]) == pControl)
			{
				return m_aPostPaintControls.Remove(i);
			}
		}
		return false;
	}

	bool CPaintManagerUI::SetPostPaintIndex(CControlUI* pControl, int iIndex)
	{
		RemovePostPaint(pControl);
		return m_aPostPaintControls.InsertAt(iIndex, pControl);
	}

	int CPaintManagerUI::GetNativeWindowCount() const
	{
		return m_aNativeWindow.GetSize();
	}

	bool CPaintManagerUI::AddNativeWindow(CControlUI* pControl, HWND hChildWnd)
	{
		if (pControl == NULL || hChildWnd == NULL) return false;

		RECT rcChildWnd = GetNativeWindowRect(hChildWnd);
		Invalidate(rcChildWnd);

		if (m_aNativeWindow.Find(hChildWnd) >= 0) return false;
		if (m_aNativeWindow.Add(hChildWnd))
		{
			m_aNativeWindowControl.Add(pControl);
			return true;
		}
		return false;
	}

	bool CPaintManagerUI::RemoveNativeWindow(HWND hChildWnd)
	{
		for (int i = 0; i < m_aNativeWindow.GetSize(); i++)
		{
			if (static_cast<HWND>(m_aNativeWindow[i]) == hChildWnd)
			{
				if (m_aNativeWindow.Remove(i))
				{
					m_aNativeWindowControl.Remove(i);
					return true;
				}
				return false;
			}
		}
		return false;
	}

	RECT CPaintManagerUI::GetNativeWindowRect(HWND hChildWnd)
	{
		RECT rcChildWnd;
		::GetWindowRect(hChildWnd, &rcChildWnd);
		::ScreenToClient(m_hWndPaint, (LPPOINT)(&rcChildWnd));
		::ScreenToClient(m_hWndPaint, (LPPOINT)(&rcChildWnd) + 1);
		return rcChildWnd;
	}

	void CPaintManagerUI::AddDelayedCleanup(CControlUI* pControl)
	{
		if (pControl == NULL) return;
		pControl->SetManager(this, NULL, false);
		m_aDelayedCleanup.Add(pControl);
		PostAsyncNotify();
	}

	void CPaintManagerUI::AddMouseLeaveNeeded(CControlUI* pControl)
	{
		if (pControl == NULL) return;
		for (int i = 0; i < m_aNeedMouseLeaveNeeded.GetSize(); i++)
		{
			if (static_cast<CControlUI*>(m_aNeedMouseLeaveNeeded[i]) == pControl)
			{
				return;
			}
		}
		m_aNeedMouseLeaveNeeded.Add(pControl);
	}

	bool CPaintManagerUI::RemoveMouseLeaveNeeded(CControlUI* pControl)
	{
		if (pControl == NULL) return false;
		for (int i = 0; i < m_aNeedMouseLeaveNeeded.GetSize(); i++)
		{
			if (static_cast<CControlUI*>(m_aNeedMouseLeaveNeeded[i]) == pControl)
			{
				return m_aNeedMouseLeaveNeeded.Remove(i);
			}
		}
		return false;
	}

	void CPaintManagerUI::SendNotify(CControlUI* pControl, LPCTSTR pstrMessage, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0*/, bool bAsync /*= false*/)
	{
		TNotifyUI Msg;
		Msg.pSender = pControl;
		Msg.sType = pstrMessage;
		Msg.wParam = wParam;
		Msg.lParam = lParam;
		SendNotify(Msg, bAsync);
	}

	void CPaintManagerUI::SendNotify(TNotifyUI& Msg, bool bAsync /*= false*/)
	{
		Msg.ptMouse = m_ptLastMousePos;
		Msg.dwTimestamp = ::GetTickCount();
		if (m_bUsedVirtualWnd)
		{
			Msg.sVirtualWnd = Msg.pSender->GetVirtualWnd();
		}

		if (!bAsync)
		{
			// Send to all listeners
			if (Msg.pSender != NULL)
			{
				if (Msg.pSender->OnNotify) Msg.pSender->OnNotify(&Msg);
			}
			for (int i = 0; i < m_aNotifiers.GetSize(); i++)
			{
				static_cast<INotifyUI*>(m_aNotifiers[i])->Notify(Msg);
			}
		}
		else
		{
			TNotifyUI* pMsg = new TNotifyUI;
			pMsg->sVirtualWnd = Msg.sVirtualWnd;
			pMsg->pSender = Msg.pSender;
			pMsg->sType = Msg.sType;
			pMsg->wParam = Msg.wParam;
			pMsg->lParam = Msg.lParam;
			pMsg->ptMouse = Msg.ptMouse;
			pMsg->dwTimestamp = Msg.dwTimestamp;
			m_aAsyncNotify.Add(pMsg);

			PostAsyncNotify();
		}
	}

	bool CPaintManagerUI::IsForceUseSharedRes() const
	{
		return m_bForceUseSharedRes;
	}

	void CPaintManagerUI::SetForceUseSharedRes(bool bForce)
	{
		m_bForceUseSharedRes = bForce;
	}

	DWORD CPaintManagerUI::GetDefaultDisabledColor() const
	{
		return m_ResInfo.m_dwDefaultDisabledColor;
	}

	void CPaintManagerUI::SetDefaultDisabledColor(DWORD dwColor, bool bShared)
	{
		if (bShared)
		{
			if (m_ResInfo.m_dwDefaultDisabledColor == m_SharedResInfo.m_dwDefaultDisabledColor)
				m_ResInfo.m_dwDefaultDisabledColor = dwColor;
			m_SharedResInfo.m_dwDefaultDisabledColor = dwColor;
		}
		else
		{
			m_ResInfo.m_dwDefaultDisabledColor = dwColor;
		}
	}

	DWORD CPaintManagerUI::GetDefaultFontColor() const
	{
		return m_ResInfo.m_dwDefaultFontColor;
	}

	void CPaintManagerUI::SetDefaultFontColor(DWORD dwColor, bool bShared)
	{
		if (bShared)
		{
			if (m_ResInfo.m_dwDefaultFontColor == m_SharedResInfo.m_dwDefaultFontColor)
				m_ResInfo.m_dwDefaultFontColor = dwColor;
			m_SharedResInfo.m_dwDefaultFontColor = dwColor;
		}
		else
		{
			m_ResInfo.m_dwDefaultFontColor = dwColor;
		}
	}

	DWORD CPaintManagerUI::GetDefaultLinkFontColor() const
	{
		return m_ResInfo.m_dwDefaultLinkFontColor;
	}

	void CPaintManagerUI::SetDefaultLinkFontColor(DWORD dwColor, bool bShared)
	{
		if (bShared)
		{
			if (m_ResInfo.m_dwDefaultLinkFontColor == m_SharedResInfo.m_dwDefaultLinkFontColor)
				m_ResInfo.m_dwDefaultLinkFontColor = dwColor;
			m_SharedResInfo.m_dwDefaultLinkFontColor = dwColor;
		}
		else
		{
			m_ResInfo.m_dwDefaultLinkFontColor = dwColor;
		}
	}

	DWORD CPaintManagerUI::GetDefaultLinkHoverFontColor() const
	{
		return m_ResInfo.m_dwDefaultLinkHoverFontColor;
	}

	void CPaintManagerUI::SetDefaultLinkHoverFontColor(DWORD dwColor, bool bShared)
	{
		if (bShared)
		{
			if (m_ResInfo.m_dwDefaultLinkHoverFontColor == m_SharedResInfo.m_dwDefaultLinkHoverFontColor)
				m_ResInfo.m_dwDefaultLinkHoverFontColor = dwColor;
			m_SharedResInfo.m_dwDefaultLinkHoverFontColor = dwColor;
		}
		else
		{
			m_ResInfo.m_dwDefaultLinkHoverFontColor = dwColor;
		}
	}

	DWORD CPaintManagerUI::GetDefaultSelectedBkColor() const
	{
		return m_ResInfo.m_dwDefaultSelectedBkColor;
	}

	void CPaintManagerUI::SetDefaultSelectedBkColor(DWORD dwColor, bool bShared)
	{
		if (bShared)
		{
			if (m_ResInfo.m_dwDefaultSelectedBkColor == m_SharedResInfo.m_dwDefaultSelectedBkColor)
				m_ResInfo.m_dwDefaultSelectedBkColor = dwColor;
			m_SharedResInfo.m_dwDefaultSelectedBkColor = dwColor;
		}
		else
		{
			m_ResInfo.m_dwDefaultSelectedBkColor = dwColor;
		}
	}

	TFontInfo* CPaintManagerUI::GetDefaultFontInfo()
	{
		if (m_ResInfo.m_DefaultFontInfo.sFontName.IsEmpty())
		{
			if (m_SharedResInfo.m_DefaultFontInfo.tm.tmHeight == 0)
			{
				HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, m_SharedResInfo.m_DefaultFontInfo.hFont);
				::GetTextMetrics(m_hDcPaint, &m_SharedResInfo.m_DefaultFontInfo.tm);
				::SelectObject(m_hDcPaint, hOldFont);
			}
			return &m_SharedResInfo.m_DefaultFontInfo;
		}
		else
		{
			if (m_ResInfo.m_DefaultFontInfo.tm.tmHeight == 0)
			{
				HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, m_ResInfo.m_DefaultFontInfo.hFont);
				::GetTextMetrics(m_hDcPaint, &m_ResInfo.m_DefaultFontInfo.tm);
				::SelectObject(m_hDcPaint, hOldFont);
			}
			return &m_ResInfo.m_DefaultFontInfo;
		}
	}

	void CPaintManagerUI::SetDefaultFont(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bStrikeout, bool bShared)
	{
		LOGFONT lf = { 0 };
		::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
		if (lstrlen(pStrFontName) > 0)
		{
			TCHAR szFaceName[32] = { 0 };//_T("@");
			_tcsncat(szFaceName, pStrFontName, LF_FACESIZE);
			_tcsncpy(lf.lfFaceName, szFaceName, LF_FACESIZE);
		}
		lf.lfCharSet = DEFAULT_CHARSET;
		lf.lfHeight = -GetDPIObj()->Scale(nSize);;
		if (bBold) lf.lfWeight += FW_BOLD;
		if (bUnderline) lf.lfUnderline = TRUE;
		if (bItalic) lf.lfItalic = TRUE;
		if (bStrikeout) lf.lfStrikeOut = TRUE;

		HFONT hFont = ::CreateFontIndirect(&lf);
		if (hFont == NULL) return;

		if (bShared)
		{
			::DeleteObject(m_SharedResInfo.m_DefaultFontInfo.hFont);
			m_SharedResInfo.m_DefaultFontInfo.hFont = hFont;
			m_SharedResInfo.m_DefaultFontInfo.sFontName = lf.lfFaceName;
			m_SharedResInfo.m_DefaultFontInfo.iSize = nSize;
			m_SharedResInfo.m_DefaultFontInfo.bBold = bBold;
			m_SharedResInfo.m_DefaultFontInfo.bUnderline = bUnderline;
			m_SharedResInfo.m_DefaultFontInfo.bItalic = bItalic;
			m_SharedResInfo.m_DefaultFontInfo.bStrikeout = bStrikeout;
			::ZeroMemory(&m_SharedResInfo.m_DefaultFontInfo.tm, sizeof(m_SharedResInfo.m_DefaultFontInfo.tm));
			if (m_hDcPaint)
			{
				HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, hFont);
				::GetTextMetrics(m_hDcPaint, &m_SharedResInfo.m_DefaultFontInfo.tm);
				::SelectObject(m_hDcPaint, hOldFont);
			}
		}
		else
		{
			::DeleteObject(m_ResInfo.m_DefaultFontInfo.hFont);
			m_ResInfo.m_DefaultFontInfo.hFont = hFont;
			m_ResInfo.m_DefaultFontInfo.sFontName = lf.lfFaceName;
			m_ResInfo.m_DefaultFontInfo.iSize = nSize;
			m_ResInfo.m_DefaultFontInfo.bBold = bBold;
			m_ResInfo.m_DefaultFontInfo.bUnderline = bUnderline;
			m_ResInfo.m_DefaultFontInfo.bItalic = bItalic;
			m_ResInfo.m_DefaultFontInfo.bStrikeout = bStrikeout;
			::ZeroMemory(&m_ResInfo.m_DefaultFontInfo.tm, sizeof(m_ResInfo.m_DefaultFontInfo.tm));
			if (m_hDcPaint)
			{
				HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, hFont);
				::GetTextMetrics(m_hDcPaint, &m_ResInfo.m_DefaultFontInfo.tm);
				::SelectObject(m_hDcPaint, hOldFont);
			}
		}
	}

	DWORD CPaintManagerUI::GetCustomFontCount(bool bShared) const
	{
		if (bShared)
			return m_SharedResInfo.m_CustomFonts.GetSize();
		else
			return m_ResInfo.m_CustomFonts.GetSize();
	}

	HFONT CPaintManagerUI::AddFont(int id, LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bStrikeout, bool bShared)
	{
		LOGFONT lf = { 0 };
		::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
		if (lstrlen(pStrFontName) > 0)
		{
			TCHAR szFaceName[32] = { 0 };//_T("@");
			_tcsncat(szFaceName, pStrFontName, LF_FACESIZE);
			_tcsncpy(lf.lfFaceName, szFaceName, LF_FACESIZE);
		}
		lf.lfCharSet = DEFAULT_CHARSET;
		lf.lfHeight = -GetDPIObj()->Scale(nSize);
		if (bBold) lf.lfWeight = FW_BOLD;
		if (bUnderline) lf.lfUnderline = TRUE;
		if (bItalic) lf.lfItalic = TRUE;
		if (bStrikeout) lf.lfStrikeOut = TRUE;
		HFONT hFont = ::CreateFontIndirect(&lf);
		if (hFont == NULL) return NULL;

		TFontInfo* pFontInfo = new TFontInfo;
		if (!pFontInfo) return false;
		::ZeroMemory(pFontInfo, sizeof(TFontInfo));
		pFontInfo->hFont = hFont;
		pFontInfo->sFontName = lf.lfFaceName;
		pFontInfo->iSize = nSize;
		pFontInfo->bBold = bBold;
		pFontInfo->bUnderline = bUnderline;
		pFontInfo->bItalic = bItalic;
		pFontInfo->bStrikeout = bStrikeout;
		if (m_hDcPaint)
		{
			HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, hFont);
			::GetTextMetrics(m_hDcPaint, &pFontInfo->tm);
			::SelectObject(m_hDcPaint, hOldFont);
		}
		TCHAR idBuffer[16];
		::ZeroMemory(idBuffer, sizeof(idBuffer));
		_itot(id, idBuffer, 10);
		if (bShared || m_bForceUseSharedRes)
		{
			TFontInfo* pOldFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(idBuffer));
			if (pOldFontInfo)
			{
				::DeleteObject(pOldFontInfo->hFont);
				delete pOldFontInfo;
				m_SharedResInfo.m_CustomFonts.Remove(idBuffer);
			}

			if (!m_SharedResInfo.m_CustomFonts.Insert(idBuffer, pFontInfo))
			{
				::DeleteObject(hFont);
				delete pFontInfo;
				return NULL;
			}
		}
		else
		{
			TFontInfo* pOldFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(idBuffer));
			if (pOldFontInfo)
			{
				::DeleteObject(pOldFontInfo->hFont);
				delete pOldFontInfo;
				m_ResInfo.m_CustomFonts.Remove(idBuffer);
			}

			if (!m_ResInfo.m_CustomFonts.Insert(idBuffer, pFontInfo))
			{
				::DeleteObject(hFont);
				delete pFontInfo;
				return NULL;
			}
		}

		return hFont;
	}
	void CPaintManagerUI::AddFontArray(LPCTSTR pstrPath)
	{
		LPBYTE pData = NULL;
		DWORD dwSize = 0;
		do
		{
			CDuiString sFile = CPaintManagerUI::GetResourcePath();
			if (CPaintManagerUI::GetResourceZip().IsEmpty())
			{
				sFile += pstrPath;
				HANDLE hFile = ::CreateFile(sFile.GetData(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, \
					FILE_ATTRIBUTE_NORMAL, NULL);
				if (hFile == INVALID_HANDLE_VALUE) break;
				dwSize = ::GetFileSize(hFile, NULL);
				if (dwSize == 0) break;

				DWORD dwRead = 0;
				pData = new BYTE[dwSize];
				::ReadFile(hFile, pData, dwSize, &dwRead, NULL);
				::CloseHandle(hFile);

				if (dwRead != dwSize)
				{
					delete[] pData;
					pData = NULL;
					break;
				}
			}
			else
			{
				sFile += CPaintManagerUI::GetResourceZip();
				HZIP hz = NULL;
				if (CPaintManagerUI::IsCachedResourceZip()) hz = (HZIP)CPaintManagerUI::GetResourceZipHandle();
				else
				{
					CDuiString sFilePwd = CPaintManagerUI::GetResourceZipPwd();
#ifdef UNICODE
					char* pwd = w2a((wchar_t*)sFilePwd.GetData());
					hz = OpenZip(sFile.GetData(), pwd);
					if (pwd) delete[] pwd;
#else
					hz = OpenZip(sFile.GetData(), sFilePwd.GetData());
#endif
				}
				if (hz == NULL) break;
				ZIPENTRY ze;
				int i = 0;
				CDuiString key = pstrPath;
				key.Replace(_T("\\"), _T("/"));
				if (FindZipItem(hz, key, true, &i, &ze) != 0) break;
				dwSize = ze.unc_size;
				if (dwSize == 0) break;
				pData = new BYTE[dwSize];
				int res = UnzipItem(hz, i, pData, dwSize);
				if (res != 0x00000000 && res != 0x00000600)
				{
					delete[] pData;
					pData = NULL;
					if (!CPaintManagerUI::IsCachedResourceZip()) CloseZip(hz);
					break;
				}
				if (!CPaintManagerUI::IsCachedResourceZip()) CloseZip(hz);
			}

		} while (0);

		while (!pData)
		{
			//读不到图片, 则直接去读取bitmap.m_lpstr指向的路径
			HANDLE hFile = ::CreateFile(pstrPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if (hFile == INVALID_HANDLE_VALUE) break;
			dwSize = ::GetFileSize(hFile, NULL);
			if (dwSize == 0) break;

			DWORD dwRead = 0;
			pData = new BYTE[dwSize];
			::ReadFile(hFile, pData, dwSize, &dwRead, NULL);
			::CloseHandle(hFile);

			if (dwRead != dwSize)
			{
				delete[] pData;
				pData = NULL;
			}
			break;
		}
		DWORD nFonts;
		HANDLE hFont = ::AddFontMemResourceEx(pData, dwSize, NULL, &nFonts);
		delete[] pData;
		pData = NULL;
		m_aFonts.Add(hFont);
	}
	HFONT CPaintManagerUI::GetFont(int id)
	{
		if (id < 0) return GetDefaultFontInfo()->hFont;

		TCHAR idBuffer[16];
		::ZeroMemory(idBuffer, sizeof(idBuffer));
		_itot(id, idBuffer, 10);
		TFontInfo* pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(idBuffer));
		if (!pFontInfo) pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(idBuffer));
		if (!pFontInfo) return GetDefaultFontInfo()->hFont;
		return pFontInfo->hFont;
	}

	HFONT CPaintManagerUI::GetFont(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bStrikeout)
	{
		TFontInfo* pFontInfo = NULL;
		for (int i = 0; i < m_ResInfo.m_CustomFonts.GetSize(); i++)
		{
			if (LPCTSTR key = m_ResInfo.m_CustomFonts.GetAt(i))
			{
				pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(key));
				if (pFontInfo && pFontInfo->sFontName == pStrFontName && pFontInfo->iSize == nSize &&
					pFontInfo->bBold == bBold && pFontInfo->bUnderline == bUnderline && pFontInfo->bItalic == bItalic
					&& pFontInfo->bStrikeout == bStrikeout)
					return pFontInfo->hFont;
			}
		}
		for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
		{
			if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
			{
				pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key));
				if (pFontInfo && pFontInfo->sFontName == pStrFontName && pFontInfo->iSize == nSize &&
					pFontInfo->bBold == bBold && pFontInfo->bUnderline == bUnderline && pFontInfo->bItalic == bItalic
					&& pFontInfo->bStrikeout == bStrikeout)
					return pFontInfo->hFont;
			}
		}

		return NULL;
	}

	int CPaintManagerUI::GetFontIndex(HFONT hFont, bool bShared)
	{
		TFontInfo* pFontInfo = NULL;
		if (bShared)
		{
			for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->hFont == hFont) return _ttoi(key);
				}
			}
		}
		else
		{
			for (int i = 0; i < m_ResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->hFont == hFont) return _ttoi(key);
				}
			}
		}

		return -1;
	}

	int CPaintManagerUI::GetFontIndex(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bStrikeout, bool bShared)
	{
		TFontInfo* pFontInfo = NULL;
		if (bShared)
		{
			for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->sFontName == pStrFontName && pFontInfo->iSize == nSize &&
						pFontInfo->bBold == bBold && pFontInfo->bUnderline == bUnderline && pFontInfo->bItalic == bItalic
						&& pFontInfo->bStrikeout == bStrikeout)
						return _ttoi(key);
				}
			}
		}
		else
		{
			for (int i = 0; i < m_ResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->sFontName == pStrFontName && pFontInfo->iSize == nSize &&
						pFontInfo->bBold == bBold && pFontInfo->bUnderline == bUnderline && pFontInfo->bItalic == bItalic
						&& pFontInfo->bStrikeout == bStrikeout)
						return _ttoi(key);
				}
			}
		}

		return -1;
	}

	void CPaintManagerUI::RemoveFont(HFONT hFont, bool bShared)
	{
		TFontInfo* pFontInfo = NULL;
		if (bShared)
		{
			for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->hFont == hFont)
					{
						::DeleteObject(pFontInfo->hFont);
						delete pFontInfo;
						m_SharedResInfo.m_CustomFonts.Remove(key);
						return;
					}
				}
			}
		}
		else
		{
			for (int i = 0; i < m_ResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->hFont == hFont)
					{
						::DeleteObject(pFontInfo->hFont);
						delete pFontInfo;
						m_ResInfo.m_CustomFonts.Remove(key);
						return;
					}
				}
			}
		}
	}

	void CPaintManagerUI::RemoveFont(int id, bool bShared)
	{
		TCHAR idBuffer[16];
		::ZeroMemory(idBuffer, sizeof(idBuffer));
		_itot(id, idBuffer, 10);

		TFontInfo* pFontInfo = NULL;
		if (bShared)
		{
			pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(idBuffer));
			if (pFontInfo)
			{
				::DeleteObject(pFontInfo->hFont);
				delete pFontInfo;
				m_SharedResInfo.m_CustomFonts.Remove(idBuffer);
			}
		}
		else
		{
			pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(idBuffer));
			if (pFontInfo)
			{
				::DeleteObject(pFontInfo->hFont);
				delete pFontInfo;
				m_ResInfo.m_CustomFonts.Remove(idBuffer);
			}
		}
	}

	void CPaintManagerUI::RemoveAllFonts(bool bShared)
	{
		TFontInfo* pFontInfo;
		if (bShared)
		{
			for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key, false));
					if (pFontInfo)
					{
						::DeleteObject(pFontInfo->hFont);
						delete pFontInfo;
					}
				}
			}
			m_SharedResInfo.m_CustomFonts.RemoveAll();
		}
		else
		{
			for (int i = 0; i < m_ResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(key, false));
					if (pFontInfo)
					{
						::DeleteObject(pFontInfo->hFont);
						delete pFontInfo;
					}
				}
			}
			m_ResInfo.m_CustomFonts.RemoveAll();
		}
	}

	TFontInfo* CPaintManagerUI::GetFontInfo(int id)
	{
		if (id < 0) return GetDefaultFontInfo();

		TCHAR idBuffer[16];
		::ZeroMemory(idBuffer, sizeof(idBuffer));
		_itot(id, idBuffer, 10);
		TFontInfo* pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(idBuffer));
		if (!pFontInfo) pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(idBuffer));
		if (!pFontInfo) pFontInfo = GetDefaultFontInfo();
		if (pFontInfo->tm.tmHeight == 0)
		{
			HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, pFontInfo->hFont);
			::GetTextMetrics(m_hDcPaint, &pFontInfo->tm);
			::SelectObject(m_hDcPaint, hOldFont);
		}
		return pFontInfo;
	}

	TFontInfo* CPaintManagerUI::GetFontInfo(HFONT hFont)
	{
		TFontInfo* pFontInfo = NULL;
		for (int i = 0; i < m_ResInfo.m_CustomFonts.GetSize(); i++)
		{
			if (LPCTSTR key = m_ResInfo.m_CustomFonts.GetAt(i))
			{
				pFontInfo = static_cast<TFontInfo*>(m_ResInfo.m_CustomFonts.Find(key));
				if (pFontInfo && pFontInfo->hFont == hFont) break;
			}
		}
		if (!pFontInfo)
		{
			for (int i = 0; i < m_SharedResInfo.m_CustomFonts.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_CustomFonts.GetAt(i))
				{
					pFontInfo = static_cast<TFontInfo*>(m_SharedResInfo.m_CustomFonts.Find(key));
					if (pFontInfo && pFontInfo->hFont == hFont) break;
				}
			}
		}
		if (!pFontInfo) pFontInfo = GetDefaultFontInfo();
		if (pFontInfo->tm.tmHeight == 0)
		{
			HFONT hOldFont = (HFONT) ::SelectObject(m_hDcPaint, pFontInfo->hFont);
			::GetTextMetrics(m_hDcPaint, &pFontInfo->tm);
			::SelectObject(m_hDcPaint, hOldFont);
		}
		return pFontInfo;
	}

	const TImageInfo* CPaintManagerUI::GetImage(LPCTSTR bitmap)
	{
		TImageInfo* data = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(bitmap));
		if (!data) data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(bitmap));
		return data;
	}

	const TImageInfo* CPaintManagerUI::GetImageEx(LPCTSTR bitmap, LPCTSTR type, DWORD mask, bool bUseHSL, bool bGdiplus, HINSTANCE instance)
	{
		const TImageInfo* data = GetImage(bitmap);
		if (!data)
		{
			if (AddImage(bitmap, type, mask, bUseHSL, bGdiplus, false, instance))
			{
				if (m_bForceUseSharedRes) data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(bitmap));
				else data = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(bitmap));
			}
		}

		return data;
	}

	const TImageInfo* CPaintManagerUI::AddImage(LPCTSTR bitmap, LPCTSTR type, DWORD mask, bool bUseHSL, bool bGdiplus, bool bShared, HINSTANCE instance)
	{
		if (bitmap == NULL || bitmap[0] == _T('\0')) return NULL;

		TImageInfo* data = NULL;
		if (type != NULL && lstrlen(type) > 0)
		{
			if (isdigit(*bitmap))
			{
				LPTSTR pstr = NULL;
				int iIndex = _tcstol(bitmap, &pstr, 10);

				data = bGdiplus ? CRenderEngine::GdiplusLoadImage(iIndex, type, mask, instance) : CRenderEngine::LoadImage(iIndex, type, mask, instance);
			}
		}
		else
		{
			data = bGdiplus ? CRenderEngine::GdiplusLoadImage(bitmap, NULL, mask, instance) : CRenderEngine::LoadImage(bitmap, NULL, mask, instance);
			if (!data)
			{
				CDuiString sImageName = bitmap;
				int iAtIdx = sImageName.ReverseFind(_T('@'));
				int iDotIdx = sImageName.ReverseFind(_T('.'));
				if (iAtIdx != -1 && iDotIdx != -1)
				{
					CDuiString sExe = sImageName.Mid(iDotIdx);
					sImageName = sImageName.Left(iAtIdx) + sExe;
					data = bGdiplus ? CRenderEngine::GdiplusLoadImage(sImageName.GetData(), NULL, mask, instance) : CRenderEngine::LoadImage(sImageName.GetData(), NULL, mask, instance);
				}
			}

		}

		if (data == NULL)
		{
			return NULL;
		}
		data->bUseHSL = bUseHSL;
		if (type != NULL) data->sResType = type;
		data->dwMask = mask;
		if (data->bUseHSL)
		{
			data->pSrcBits = new BYTE[data->nX * data->nY * 4];
			::CopyMemory(data->pSrcBits, data->pBits, data->nX * data->nY * 4);
		}
		else data->pSrcBits = NULL;
		if (m_bUseHSL) CRenderEngine::AdjustImage(true, data, m_H, m_S, m_L);
		if (data)
		{
			if (bShared || m_bForceUseSharedRes)
			{
				TImageInfo* pOldImageInfo = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(bitmap));
				if (pOldImageInfo)
				{
					CRenderEngine::FreeImage(pOldImageInfo);
					m_SharedResInfo.m_ImageHash.Remove(bitmap);
				}

				if (!m_SharedResInfo.m_ImageHash.Insert(bitmap, data))
				{
					CRenderEngine::FreeImage(data);
					data = NULL;
				}
			}
			else
			{
				TImageInfo* pOldImageInfo = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(bitmap));
				if (pOldImageInfo)
				{
					CRenderEngine::FreeImage(pOldImageInfo);
					m_ResInfo.m_ImageHash.Remove(bitmap);
				}

				if (!m_ResInfo.m_ImageHash.Insert(bitmap, data))
				{
					CRenderEngine::FreeImage(data);
					data = NULL;
				}
			}
		}

		return data;
	}

	const TImageInfo* CPaintManagerUI::AddImage(LPCTSTR bitmap, HBITMAP hBitmap, int iWidth, int iHeight, bool bAlpha, bool bShared)
	{
		// 因无法确定外部HBITMAP格式，不能使用hsl调整
		if (bitmap == NULL || bitmap[0] == _T('\0')) return NULL;
		if (hBitmap == NULL || iWidth <= 0 || iHeight <= 0) return NULL;

		TImageInfo* data = new TImageInfo;
		data->pBits = NULL;
		data->pSrcBits = NULL;
		data->hBitmap = hBitmap;
		data->pBits = NULL;
		data->nX = iWidth;
		data->nY = iHeight;
		data->bAlpha = bAlpha;
		data->bUseHSL = false;
		data->pSrcBits = NULL;
		data->dwMask = 0;

		if (bShared || m_bForceUseSharedRes)
		{
			if (!m_SharedResInfo.m_ImageHash.Insert(bitmap, data))
			{
				CRenderEngine::FreeImage(data);
				data = NULL;
			}
		}
		else
		{
			if (!m_ResInfo.m_ImageHash.Insert(bitmap, data))
			{
				CRenderEngine::FreeImage(data);
				data = NULL;
			}
		}

		return data;
	}

	void CPaintManagerUI::RemoveImage(LPCTSTR bitmap, bool bShared)
	{
		TImageInfo* data = NULL;
		if (bShared)
		{
			data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(bitmap));
			if (data)
			{
				CRenderEngine::FreeImage(data);
				m_SharedResInfo.m_ImageHash.Remove(bitmap);
			}
		}
		else
		{
			data = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(bitmap));
			if (data)
			{
				CRenderEngine::FreeImage(data);
				m_ResInfo.m_ImageHash.Remove(bitmap);
			}
		}
	}

	void CPaintManagerUI::RemoveAllImages(bool bShared)
	{
		if (bShared)
		{
			TImageInfo* data;
			for (int i = 0; i < m_SharedResInfo.m_ImageHash.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_ImageHash.GetAt(i))
				{
					data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(key, false));
					if (data)
					{
						CRenderEngine::FreeImage(data);
					}
				}
			}
			m_SharedResInfo.m_ImageHash.RemoveAll();
		}
		else
		{
			TImageInfo* data;
			for (int i = 0; i < m_ResInfo.m_ImageHash.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_ImageHash.GetAt(i))
				{
					data = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(key, false));
					if (data)
					{
						CRenderEngine::FreeImage(data);
					}
				}
			}
			m_ResInfo.m_ImageHash.RemoveAll();
		}
	}

	void CPaintManagerUI::AdjustSharedImagesHSL()
	{
		TImageInfo* data;
		for (int i = 0; i < m_SharedResInfo.m_ImageHash.GetSize(); i++)
		{
			if (LPCTSTR key = m_SharedResInfo.m_ImageHash.GetAt(i))
			{
				data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(key));
				if (data && data->bUseHSL)
				{
					CRenderEngine::AdjustImage(m_bUseHSL, data, m_H, m_S, m_L);
				}
			}
		}
	}

	void CPaintManagerUI::AdjustImagesHSL()
	{
		TImageInfo* data;
		for (int i = 0; i < m_ResInfo.m_ImageHash.GetSize(); i++)
		{
			if (LPCTSTR key = m_ResInfo.m_ImageHash.GetAt(i))
			{
				data = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(key));
				if (data && data->bUseHSL)
				{
					CRenderEngine::AdjustImage(m_bUseHSL, data, m_H, m_S, m_L);
				}
			}
		}
		Invalidate();
	}

	void CPaintManagerUI::PostAsyncNotify()
	{
		if (!m_bAsyncNotifyPosted)
		{
			::PostMessage(m_hWndPaint, WM_APP + 1, 0, 0L);
			m_bAsyncNotifyPosted = true;
		}
	}
	void CPaintManagerUI::ReloadSharedImages()
	{
		TImageInfo* data = NULL;
		TImageInfo* pNewData = NULL;
		for (int i = 0; i < m_SharedResInfo.m_ImageHash.GetSize(); i++)
		{
			if (LPCTSTR bitmap = m_SharedResInfo.m_ImageHash.GetAt(i))
			{
				data = static_cast<TImageInfo*>(m_SharedResInfo.m_ImageHash.Find(bitmap));
				if (data != NULL)
				{
					if (!data->sResType.IsEmpty())
					{
						if (isdigit(*bitmap))
						{
							LPTSTR pstr = NULL;
							int iIndex = _tcstol(bitmap, &pstr, 10);
							pNewData = CRenderEngine::LoadImage(iIndex, data->sResType.GetData(), data->dwMask);
						}
					}
					else
					{
						pNewData = CRenderEngine::LoadImage(bitmap, NULL, data->dwMask);
					}
					if (pNewData == NULL) continue;

					CRenderEngine::FreeImage(data, false);
					data->hBitmap = pNewData->hBitmap;
					data->pImage = pNewData->pImage;
					data->pBits = pNewData->pBits;
					data->nX = pNewData->nX;
					data->nY = pNewData->nY;
					data->bAlpha = pNewData->bAlpha;
					data->pSrcBits = NULL;
					if (data->bUseHSL)
					{
						data->pSrcBits = new BYTE[data->nX * data->nY * 4];
						::CopyMemory(data->pSrcBits, data->pBits, data->nX * data->nY * 4);
					}
					else data->pSrcBits = NULL;
					if (m_bUseHSL) CRenderEngine::AdjustImage(true, data, m_H, m_S, m_L);

					delete pNewData;
				}
			}
		}
	}

	void CPaintManagerUI::ReloadImages()
	{
		RemoveAllDrawInfos();

		TImageInfo* data = NULL;
		TImageInfo* pNewData = NULL;
		for (int i = 0; i < m_ResInfo.m_ImageHash.GetSize(); i++)
		{
			if (LPCTSTR bitmap = m_ResInfo.m_ImageHash.GetAt(i))
			{
				data = static_cast<TImageInfo*>(m_ResInfo.m_ImageHash.Find(bitmap));
				if (data != NULL)
				{
					if (!data->sResType.IsEmpty())
					{
						if (isdigit(*bitmap))
						{
							LPTSTR pstr = NULL;
							int iIndex = _tcstol(bitmap, &pstr, 10);
							pNewData = CRenderEngine::LoadImage(iIndex, data->sResType.GetData(), data->dwMask);
						}
					}
					else
					{
						pNewData = CRenderEngine::LoadImage(bitmap, NULL, data->dwMask);
					}

					CRenderEngine::FreeImage(data, false);
					if (pNewData == NULL)
					{
						m_ResInfo.m_ImageHash.Remove(bitmap);
						continue;
					}
					data->hBitmap = pNewData->hBitmap;
					data->pBits = pNewData->pBits;
					data->nX = pNewData->nX;
					data->nY = pNewData->nY;
					data->bAlpha = pNewData->bAlpha;
					data->pSrcBits = NULL;
					if (data->bUseHSL)
					{
						data->pSrcBits = new BYTE[data->nX * data->nY * 4];
						::CopyMemory(data->pSrcBits, data->pBits, data->nX * data->nY * 4);
					}
					else data->pSrcBits = NULL;
					if (m_bUseHSL) CRenderEngine::AdjustImage(true, data, m_H, m_S, m_L);

					delete pNewData;
				}
			}
		}

		if (m_pRoot) m_pRoot->Invalidate();
	}

	const TDrawInfo* CPaintManagerUI::GetDrawInfo(LPCTSTR pStrImage, LPCTSTR pStrModify)
	{
		CDuiString sKey;
		sKey.Format(_T("%s%s"), pStrImage == NULL ? _T("") : pStrImage, pStrModify == NULL ? _T("") : pStrModify);
		TDrawInfo* pDrawInfo = static_cast<TDrawInfo*>(m_ResInfo.m_DrawInfoHash.Find(sKey));
		if (pDrawInfo == NULL && !sKey.IsEmpty())
		{
			pDrawInfo = new TDrawInfo();
			pDrawInfo->Parse(pStrImage, pStrModify, this);
			m_ResInfo.m_DrawInfoHash.Insert(sKey, pDrawInfo);
		}
		return pDrawInfo;
	}

	void CPaintManagerUI::RemoveDrawInfo(LPCTSTR pStrImage, LPCTSTR pStrModify)
	{
		CDuiString sKey;
		sKey.Format(_T("%s%s"), pStrImage == NULL ? _T("") : pStrImage, pStrModify == NULL ? _T("") : pStrModify);
		TDrawInfo* pDrawInfo = static_cast<TDrawInfo*>(m_ResInfo.m_DrawInfoHash.Find(sKey));
		if (pDrawInfo != NULL)
		{
			m_ResInfo.m_DrawInfoHash.Remove(sKey);
			delete pDrawInfo;
			pDrawInfo = NULL;
		}
	}

	void CPaintManagerUI::RemoveAllDrawInfos()
	{
		TDrawInfo* pDrawInfo = NULL;
		for (int i = 0; i < m_ResInfo.m_DrawInfoHash.GetSize(); i++)
		{
			LPCTSTR key = m_ResInfo.m_DrawInfoHash.GetAt(i);
			if (key != NULL)
			{
				pDrawInfo = static_cast<TDrawInfo*>(m_ResInfo.m_DrawInfoHash.Find(key, false));
				if (pDrawInfo)
				{
					delete pDrawInfo;
					pDrawInfo = NULL;
				}
			}
		}
		m_ResInfo.m_DrawInfoHash.RemoveAll();
	}

	void CPaintManagerUI::AddDefaultAttributeList(LPCTSTR pStrControlName, LPCTSTR pStrControlAttrList, bool bShared)
	{
		if (bShared || m_bForceUseSharedRes)
		{
			CDuiString* pDefaultAttr = new CDuiString(pStrControlAttrList);
			if (pDefaultAttr != NULL)
			{
				CDuiString* pOldDefaultAttr = static_cast<CDuiString*>(m_SharedResInfo.m_AttrHash.Set(pStrControlName, (LPVOID)pDefaultAttr));
				if (pOldDefaultAttr) delete pOldDefaultAttr;
			}
		}
		else
		{
			CDuiString* pDefaultAttr = new CDuiString(pStrControlAttrList);
			if (pDefaultAttr != NULL)
			{
				CDuiString* pOldDefaultAttr = static_cast<CDuiString*>(m_ResInfo.m_AttrHash.Set(pStrControlName, (LPVOID)pDefaultAttr));
				if (pOldDefaultAttr) delete pOldDefaultAttr;
			}
		}
	}

	LPCTSTR CPaintManagerUI::GetDefaultAttributeList(LPCTSTR pStrControlName) const
	{
		CDuiString* pDefaultAttr = static_cast<CDuiString*>(m_ResInfo.m_AttrHash.Find(pStrControlName));
		if (!pDefaultAttr) pDefaultAttr = static_cast<CDuiString*>(m_SharedResInfo.m_AttrHash.Find(pStrControlName));
		if (pDefaultAttr) return pDefaultAttr->GetData();
		return NULL;
	}

	bool CPaintManagerUI::RemoveDefaultAttributeList(LPCTSTR pStrControlName, bool bShared)
	{
		if (bShared)
		{
			CDuiString* pDefaultAttr = static_cast<CDuiString*>(m_SharedResInfo.m_AttrHash.Find(pStrControlName));
			if (!pDefaultAttr) return false;

			delete pDefaultAttr;
			return m_SharedResInfo.m_AttrHash.Remove(pStrControlName);
		}
		else
		{
			CDuiString* pDefaultAttr = static_cast<CDuiString*>(m_ResInfo.m_AttrHash.Find(pStrControlName));
			if (!pDefaultAttr) return false;

			delete pDefaultAttr;
			return m_ResInfo.m_AttrHash.Remove(pStrControlName);
		}
	}

	void CPaintManagerUI::RemoveAllDefaultAttributeList(bool bShared)
	{
		if (bShared)
		{
			CDuiString* pDefaultAttr;
			for (int i = 0; i < m_SharedResInfo.m_AttrHash.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_AttrHash.GetAt(i))
				{
					pDefaultAttr = static_cast<CDuiString*>(m_SharedResInfo.m_AttrHash.Find(key));
					if (pDefaultAttr) delete pDefaultAttr;
				}
			}
			m_SharedResInfo.m_AttrHash.RemoveAll();
		}
		else
		{
			CDuiString* pDefaultAttr;
			for (int i = 0; i < m_ResInfo.m_AttrHash.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_AttrHash.GetAt(i))
				{
					pDefaultAttr = static_cast<CDuiString*>(m_ResInfo.m_AttrHash.Find(key));
					if (pDefaultAttr) delete pDefaultAttr;
				}
			}
			m_ResInfo.m_AttrHash.RemoveAll();
		}
	}

	void CPaintManagerUI::AddWindowCustomAttribute(LPCTSTR pstrName, LPCTSTR pstrAttr)
	{
		if (pstrName == NULL || pstrName[0] == _T('\0') || pstrAttr == NULL || pstrAttr[0] == _T('\0')) return;
		CDuiString* pCostomAttr = new CDuiString(pstrAttr);
		if (pCostomAttr != NULL)
		{
			if (m_mWindowCustomAttrHash.Find(pstrName) == NULL)
				m_mWindowCustomAttrHash.Set(pstrName, (LPVOID)pCostomAttr);
			else
				delete pCostomAttr;
		}
	}

	LPCTSTR CPaintManagerUI::GetWindowCustomAttribute(LPCTSTR pstrName) const
	{
		if (pstrName == NULL || pstrName[0] == _T('\0')) return NULL;
		CDuiString* pCostomAttr = static_cast<CDuiString*>(m_mWindowCustomAttrHash.Find(pstrName));
		if (pCostomAttr) return pCostomAttr->GetData();
		return NULL;
	}

	bool CPaintManagerUI::RemoveWindowCustomAttribute(LPCTSTR pstrName)
	{
		if (pstrName == NULL || pstrName[0] == _T('\0')) return NULL;
		CDuiString* pCostomAttr = static_cast<CDuiString*>(m_mWindowCustomAttrHash.Find(pstrName));
		if (!pCostomAttr) return false;

		delete pCostomAttr;
		return m_mWindowCustomAttrHash.Remove(pstrName);
	}

	void CPaintManagerUI::RemoveAllWindowCustomAttribute()
	{
		CDuiString* pCostomAttr;
		for (int i = 0; i < m_mWindowCustomAttrHash.GetSize(); i++)
		{
			if (LPCTSTR key = m_mWindowCustomAttrHash.GetAt(i))
			{
				pCostomAttr = static_cast<CDuiString*>(m_mWindowCustomAttrHash.Find(key));
				delete pCostomAttr;
			}
		}
		m_mWindowCustomAttrHash.Resize();
	}

	CControlUI* CPaintManagerUI::GetRoot() const
	{
		ASSERT(m_pRoot);
		return m_pRoot;
	}

	CControlUI* CPaintManagerUI::FindControl(POINT pt) const
	{
		ASSERT(m_pRoot);
		return m_pRoot->FindControl(__FindControlFromPoint, &pt, UIFIND_VISIBLE | UIFIND_HITTEST | UIFIND_TOP_FIRST);
	}

	CControlUI* CPaintManagerUI::FindControl(LPCTSTR pstrName) const
	{
		ASSERT(m_pRoot);
		return static_cast<CControlUI*>(m_mNameHash.Find(pstrName));
	}

	CControlUI* CPaintManagerUI::FindSubControlByPoint(CControlUI* pParent, POINT pt) const
	{
		if (pParent == NULL) pParent = GetRoot();
		ASSERT(pParent);
		return pParent->FindControl(__FindControlFromPoint, &pt, UIFIND_VISIBLE | UIFIND_HITTEST | UIFIND_TOP_FIRST);
	}

	CControlUI* CPaintManagerUI::FindSubControlByName(CControlUI* pParent, LPCTSTR pstrName) const
	{
		if (pParent == NULL) pParent = GetRoot();
		ASSERT(pParent);
		return pParent->FindControl(__FindControlFromName, (LPVOID)pstrName, UIFIND_ALL);
	}

	CControlUI* CPaintManagerUI::FindSubControlByClass(CControlUI* pParent, LPCTSTR pstrClass, int iIndex)
	{
		if (pParent == NULL) pParent = GetRoot();
		ASSERT(pParent);
		m_aFoundControls.Resize(iIndex + 1);
		return pParent->FindControl(__FindControlFromClass, (LPVOID)pstrClass, UIFIND_ALL);
	}

	CStdPtrArray* CPaintManagerUI::FindSubControlsByClass(CControlUI* pParent, LPCTSTR pstrClass)
	{
		if (pParent == NULL) pParent = GetRoot();
		ASSERT(pParent);
		m_aFoundControls.Empty();
		pParent->FindControl(__FindControlsFromClass, (LPVOID)pstrClass, UIFIND_ALL);
		return &m_aFoundControls;
	}

	CStdPtrArray* CPaintManagerUI::GetFoundControls()
	{
		return &m_aFoundControls;
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromNameHash(CControlUI* pThis, LPVOID pData)
	{
		CPaintManagerUI* pManager = static_cast<CPaintManagerUI*>(pData);
		const CDuiString& sName = pThis->GetName();
		if (sName.IsEmpty()) return NULL;
		// Add this control to the hash list
		pManager->m_mNameHash.Set(sName, pThis);
		return NULL; // Attempt to add all controls
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromCount(CControlUI* /*pThis*/, LPVOID pData)
	{
		int* pnCount = static_cast<int*>(pData);
		(*pnCount)++;
		return NULL;  // Count all controls
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromPoint(CControlUI* pThis, LPVOID pData)
	{
		LPPOINT pPoint = static_cast<LPPOINT>(pData);
		return ::PtInRect(&pThis->GetPos(), *pPoint) ? pThis : NULL;
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromTab(CControlUI* pThis, LPVOID pData)
	{
		FINDTABINFO* pInfo = static_cast<FINDTABINFO*>(pData);
		if (pInfo->pFocus == pThis)
		{
			if (pInfo->bForward) pInfo->bNextIsIt = true;
			return pInfo->bForward ? NULL : pInfo->pLast;
		}
		if ((pThis->GetControlFlags() & UIFLAG_TABSTOP) == 0) return NULL;
		pInfo->pLast = pThis;
		if (pInfo->bNextIsIt) return pThis;
		if (pInfo->pFocus == NULL) return pThis;
		return NULL;  // Examine all controls
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromShortcut(CControlUI* pThis, LPVOID pData)
	{
		if (!pThis->IsVisible()) return NULL;
		FINDSHORTCUT* pFS = static_cast<FINDSHORTCUT*>(pData);
		if (pFS->ch == toupper(pThis->GetShortcut())) pFS->bPickNext = true;
		if (_tcsstr(pThis->GetClass(), _T("LabelUI")) != NULL) return NULL;   // Labels never get focus!
		return pFS->bPickNext ? pThis : NULL;
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromName(CControlUI* pThis, LPVOID pData)
	{
		LPCTSTR pstrName = static_cast<LPCTSTR>(pData);
		const CDuiString& sName = pThis->GetName();
		if (sName.IsEmpty()) return NULL;
		return (_tcsicmp(sName, pstrName) == 0) ? pThis : NULL;
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlFromClass(CControlUI* pThis, LPVOID pData)
	{
		LPCTSTR pstrType = static_cast<LPCTSTR>(pData);
		LPCTSTR pType = pThis->GetClass();
		CStdPtrArray* pFoundControls = pThis->GetManager()->GetFoundControls();
		if (_tcscmp(pstrType, _T("*")) == 0 || _tcscmp(pstrType, pType) == 0)
		{
			int iIndex = -1;
			while (pFoundControls->GetAt(++iIndex) != NULL);
			if (iIndex < pFoundControls->GetSize()) pFoundControls->SetAt(iIndex, pThis);
		}
		if (pFoundControls->GetAt(pFoundControls->GetSize() - 1) != NULL) return pThis;
		return NULL;
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlsFromClass(CControlUI* pThis, LPVOID pData)
	{
		LPCTSTR pstrType = static_cast<LPCTSTR>(pData);
		LPCTSTR pType = pThis->GetClass();
		if (_tcscmp(pstrType, _T("*")) == 0 || _tcscmp(pstrType, pType) == 0)
			pThis->GetManager()->GetFoundControls()->Add((LPVOID)pThis);
		return NULL;
	}

	CControlUI* CALLBACK CPaintManagerUI::__FindControlsFromUpdate(CControlUI* pThis, LPVOID pData)
	{
		if (pThis->IsUpdateNeeded())
		{
			pThis->GetManager()->GetFoundControls()->Add((LPVOID)pThis);
			return pThis;
		}
		return NULL;
	}

	bool CPaintManagerUI::TranslateAccelerator(LPMSG pMsg)
	{
		for (int i = 0; i < m_aTranslateAccelerator.GetSize(); i++)
		{
			LRESULT lResult = static_cast<ITranslateAccelerator*>(m_aTranslateAccelerator[i])->TranslateAccelerator(pMsg);
			if (lResult == S_OK) return true;
		}
		return false;
	}

	bool CPaintManagerUI::TranslateMessage(const LPMSG pMsg)
	{
		// Pretranslate Message takes care of system-wide messages, such as
		// tabbing and shortcut key-combos. We'll look for all messages for
		// each window and any child control attached.
		UINT uStyle = GetWindowStyle(pMsg->hwnd);
		UINT uChildRes = uStyle & WS_CHILD;
		LRESULT lRes = 0;
		if (uChildRes != 0)
		{
			HWND hWndParent = ::GetParent(pMsg->hwnd);

			for (int i = 0; i < m_aPreMessages.GetSize(); i++)
			{
				CPaintManagerUI* pT = static_cast<CPaintManagerUI*>(m_aPreMessages[i]);
				HWND hTempParent = hWndParent;
				while (hTempParent)
				{
					if (pMsg->hwnd == pT->GetPaintWindow() || hTempParent == pT->GetPaintWindow())
					{
						if (pT->TranslateAccelerator(pMsg))
							return true;

						pT->PreMessageHandler(pMsg->message, pMsg->wParam, pMsg->lParam, lRes);
					}
					hTempParent = GetParent(hTempParent);
				}
			}
		}
		else
		{
			for (int i = 0; i < m_aPreMessages.GetSize(); i++)
			{
				CPaintManagerUI* pT = static_cast<CPaintManagerUI*>(m_aPreMessages[i]);
				if (pMsg->hwnd == pT->GetPaintWindow())
				{
					if (pT->TranslateAccelerator(pMsg))
						return true;

					if (pT->PreMessageHandler(pMsg->message, pMsg->wParam, pMsg->lParam, lRes))
						return true;

					return false;
				}
			}
		}
		return false;
	}

	bool CPaintManagerUI::AddTranslateAccelerator(ITranslateAccelerator* pTranslateAccelerator)
	{
		ASSERT(m_aTranslateAccelerator.Find(pTranslateAccelerator) < 0);
		return m_aTranslateAccelerator.Add(pTranslateAccelerator);
	}

	bool CPaintManagerUI::RemoveTranslateAccelerator(ITranslateAccelerator* pTranslateAccelerator)
	{
		for (int i = 0; i < m_aTranslateAccelerator.GetSize(); i++)
		{
			if (static_cast<ITranslateAccelerator*>(m_aTranslateAccelerator[i]) == pTranslateAccelerator)
			{
				return m_aTranslateAccelerator.Remove(i);
			}
		}
		return false;
	}

	void CPaintManagerUI::UsedVirtualWnd(bool bUsed)
	{
		m_bUsedVirtualWnd = bUsed;
	}

	// 样式管理
	void CPaintManagerUI::AddStyle(LPCTSTR pName, LPCTSTR pDeclarationList, bool bShared)
	{
		CDuiString* pStyle = new CDuiString(pDeclarationList);

		if (bShared || m_bForceUseSharedRes)
		{
			if (!m_SharedResInfo.m_StyleHash.Insert(pName, pStyle))
			{
				delete pStyle;
			}
		}
		else
		{
			if (!m_ResInfo.m_StyleHash.Insert(pName, pStyle))
			{
				delete pStyle;
			}
		}
	}

	LPCTSTR CPaintManagerUI::GetStyle(LPCTSTR pName) const
	{
		CDuiString* pStyle = static_cast<CDuiString*>(m_ResInfo.m_StyleHash.Find(pName));
		if (!pStyle) pStyle = static_cast<CDuiString*>(m_SharedResInfo.m_StyleHash.Find(pName));
		if (pStyle) return pStyle->GetData();
		else return NULL;
	}

	BOOL CPaintManagerUI::RemoveStyle(LPCTSTR pName, bool bShared)
	{
		CDuiString* pStyle = NULL;
		if (bShared)
		{
			pStyle = static_cast<CDuiString*>(m_SharedResInfo.m_StyleHash.Find(pName));
			if (pStyle)
			{
				delete pStyle;
				m_SharedResInfo.m_StyleHash.Remove(pName);
			}
		}
		else
		{
			pStyle = static_cast<CDuiString*>(m_ResInfo.m_StyleHash.Find(pName));
			if (pStyle)
			{
				delete pStyle;
				m_ResInfo.m_StyleHash.Remove(pName);
			}
		}
		return true;
	}

	const CStdStringPtrMap& CPaintManagerUI::GetStyles(bool bShared) const
	{
		if (bShared) return m_SharedResInfo.m_StyleHash;
		else return m_ResInfo.m_StyleHash;
	}

	void CPaintManagerUI::RemoveAllStyle(bool bShared)
	{
		if (bShared)
		{
			CDuiString* pStyle;
			for (int i = 0; i < m_SharedResInfo.m_StyleHash.GetSize(); i++)
			{
				if (LPCTSTR key = m_SharedResInfo.m_StyleHash.GetAt(i))
				{
					pStyle = static_cast<CDuiString*>(m_SharedResInfo.m_StyleHash.Find(key));
					delete pStyle;
				}
			}
			m_SharedResInfo.m_StyleHash.RemoveAll();
		}
		else
		{
			CDuiString* pStyle;
			for (int i = 0; i < m_ResInfo.m_StyleHash.GetSize(); i++)
			{
				if (LPCTSTR key = m_ResInfo.m_StyleHash.GetAt(i))
				{
					pStyle = static_cast<CDuiString*>(m_ResInfo.m_StyleHash.Find(key));
					delete pStyle;
				}
			}
			m_ResInfo.m_StyleHash.RemoveAll();
		}
	}

	const TImageInfo* CPaintManagerUI::GetImageString(LPCTSTR pStrImage, LPCTSTR pStrModify)
	{
		CDuiString sImageName = pStrImage;
		CDuiString sImageResType = _T("");
		DWORD dwMask = 0;
		CDuiString sItem;
		CDuiString sValue;
		LPTSTR pstr = NULL;

		for (int i = 0; i < 2; ++i)
		{
			if (i == 1)
				pStrImage = pStrModify;

			if (!pStrImage) continue;

			while (*pStrImage != _T('\0'))
			{
				sItem.Empty();
				sValue.Empty();
				while (*pStrImage > _T('\0') && *pStrImage <= _T(' ')) pStrImage = ::CharNext(pStrImage);
				while (*pStrImage != _T('\0') && *pStrImage != _T('=') && *pStrImage > _T(' '))
				{
					LPTSTR pstrTemp = ::CharNext(pStrImage);
					while (pStrImage < pstrTemp)
					{
						sItem += *pStrImage++;
					}
				}
				while (*pStrImage > _T('\0') && *pStrImage <= _T(' ')) pStrImage = ::CharNext(pStrImage);
				if (*pStrImage++ != _T('=')) break;
				while (*pStrImage > _T('\0') && *pStrImage <= _T(' ')) pStrImage = ::CharNext(pStrImage);
				if (*pStrImage++ != _T('\'')) break;
				while (*pStrImage != _T('\0') && *pStrImage != _T('\''))
				{
					LPTSTR pstrTemp = ::CharNext(pStrImage);
					while (pStrImage < pstrTemp)
					{
						sValue += *pStrImage++;
					}
				}
				if (*pStrImage++ != _T('\'')) break;
				if (!sValue.IsEmpty())
				{
					if (sItem == _T("file") || sItem == _T("res"))
					{
						sImageName = sValue;
					}
					else if (sItem == _T("restype"))
					{
						sImageResType = sValue;
					}
					else if (sItem == _T("mask"))
					{
						if (sValue[0] == _T('#')) dwMask = _tcstoul(sValue.GetData() + 1, &pstr, 16);
						else dwMask = _tcstoul(sValue.GetData(), &pstr, 16);
					}

				}
				if (*pStrImage++ != _T(' ')) break;
			}
		}
		return GetImageEx(sImageName, sImageResType, dwMask);
	}

	bool CPaintManagerUI::EnableDragDrop(bool bEnable)
	{
		if (m_bDragDrop == bEnable) return false;
		m_bDragDrop = bEnable;

		if (bEnable)
		{
			AddRef();

			if (FAILED(RegisterDragDrop(m_hWndPaint, this)))
			{
				return false;
			}

			SetTargetWnd(m_hWndPaint);

			FORMATETC ftetc = { 0 };
			ftetc.cfFormat = CF_BITMAP;
			ftetc.dwAspect = DVASPECT_CONTENT;
			ftetc.lindex = -1;
			ftetc.tymed = TYMED_GDI;
			AddSuportedFormat(ftetc);
			ftetc.cfFormat = CF_DIB;
			ftetc.tymed = TYMED_HGLOBAL;
			AddSuportedFormat(ftetc);
			ftetc.cfFormat = CF_HDROP;
			ftetc.tymed = TYMED_HGLOBAL;
			AddSuportedFormat(ftetc);
			ftetc.cfFormat = CF_ENHMETAFILE;
			ftetc.tymed = TYMED_ENHMF;
			AddSuportedFormat(ftetc);
		}
		else
		{
			Release();
			if (FAILED(RevokeDragDrop(m_hWndPaint)))
			{
				return false;
			}
		}
		return true;
	}

	void CPaintManagerUI::SetDragDrop(IDragDropUI* pDragDrop)
	{
		m_pDragDrop = pDragDrop;
	}

	static WORD DIBNumColors(void* pv)
	{
		int bits;
		LPBITMAPINFOHEADER  lpbi;
		LPBITMAPCOREHEADER  lpbc;
		lpbi = ((LPBITMAPINFOHEADER)pv);
		lpbc = ((LPBITMAPCOREHEADER)pv);
		/*  With the BITMAPINFO format headers, the size of the palette
		*  is in biClrUsed, whereas in the BITMAPCORE - style headers, it
		*  is dependent on the bits per pixel ( = 2 raised to the power of
		*  bits/pixel).
		*/
		if (lpbi->biSize != sizeof(BITMAPCOREHEADER))
		{
			if (lpbi->biClrUsed != 0)
				return (WORD)lpbi->biClrUsed;
			bits = lpbi->biBitCount;
		}
		else
			bits = lpbc->bcBitCount;
		switch (bits)
		{
			case 1:
				return 2;
			case 4:
				return 16;
			case 8:
				return 256;
			default:
				/* A 24 bitcount DIB has no color table */
				return 0;
		}
	}
	//code taken from SEEDIB MSDN sample
	static WORD ColorTableSize(LPVOID lpv)
	{
		LPBITMAPINFOHEADER lpbih = (LPBITMAPINFOHEADER)lpv;

		if (lpbih->biSize != sizeof(BITMAPCOREHEADER))
		{
			if (((LPBITMAPINFOHEADER)(lpbih))->biCompression == BI_BITFIELDS)
				/* Remember that 16/32bpp dibs can still have a color table */
				return (sizeof(DWORD) * 3) + (DIBNumColors(lpbih) * sizeof(RGBQUAD));
			else
				return (WORD)(DIBNumColors(lpbih) * sizeof(RGBQUAD));
		}
		else
			return (WORD)(DIBNumColors(lpbih) * sizeof(RGBTRIPLE));
	}

	bool CPaintManagerUI::OnDrop(FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD* pdwEffect)
	{
		POINT ptMouse = { 0 };
		GetCursorPos(&ptMouse);
		::SendMessage(m_hTargetWnd, WM_LBUTTONUP, NULL, MAKELPARAM(ptMouse.x, ptMouse.y));

		if (pFmtEtc->cfFormat == CF_DIB && medium.tymed == TYMED_HGLOBAL)
		{
			if (medium.hGlobal != NULL)
			{
				LPBITMAPINFOHEADER  lpbi = (BITMAPINFOHEADER*)GlobalLock(medium.hGlobal);
				if (lpbi != NULL)
				{
					HBITMAP hbm = NULL;
					HDC hdc = GetDC(NULL);
					if (hdc != NULL)
					{
						int i = ((BITMAPFILEHEADER*)lpbi)->bfOffBits;
						hbm = CreateDIBitmap(hdc, (LPBITMAPINFOHEADER)lpbi,
							(LONG)CBM_INIT,
							(LPSTR)lpbi + lpbi->biSize + ColorTableSize(lpbi),
							(LPBITMAPINFO)lpbi, DIB_RGB_COLORS);

						::ReleaseDC(NULL, hdc);
					}
					GlobalUnlock(medium.hGlobal);
					if (hbm != NULL)
						hbm = (HBITMAP)SendMessage(m_hTargetWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbm);
					if (hbm != NULL)
						DeleteObject(hbm);
					return true; //release the medium
				}
			}
		}
		if (pFmtEtc->cfFormat == CF_BITMAP && medium.tymed == TYMED_GDI)
		{
			if (medium.hBitmap != NULL)
			{
				HBITMAP hBmp = (HBITMAP)SendMessage(m_hTargetWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)medium.hBitmap);
				if (hBmp != NULL)
					DeleteObject(hBmp);
				return false; //don't free the bitmap
			}
		}
		if (pFmtEtc->cfFormat == CF_ENHMETAFILE && medium.tymed == TYMED_ENHMF)
		{
			ENHMETAHEADER emh;
			GetEnhMetaFileHeader(medium.hEnhMetaFile, sizeof(ENHMETAHEADER), &emh);
			RECT rc;//={0,0,EnhMetaHdr.rclBounds.right-EnhMetaHdr.rclBounds.left, EnhMetaHdr.rclBounds.bottom-EnhMetaHdr.rclBounds.top};
			HDC hDC = GetDC(m_hTargetWnd);
			//start code: taken from ENHMETA.EXE MSDN Sample
			//*ALSO NEED to GET the pallete (select and RealizePalette it, but i was too lazy*
			// Get the characteristics of the output device
			float PixelsX = (float)GetDeviceCaps(hDC, HORZRES);
			float PixelsY = (float)GetDeviceCaps(hDC, VERTRES);
			float MMX = (float)GetDeviceCaps(hDC, HORZSIZE);
			float MMY = (float)GetDeviceCaps(hDC, VERTSIZE);
			// Calculate the rect in which to draw the metafile based on the
			// intended size and the current output device resolution
			// Remember that the intended size is given in 0.01mm units, so
			// convert those to device units on the target device
			rc.top = (int)((float)(emh.rclFrame.top) * PixelsY / (MMY * 100.0f));
			rc.left = (int)((float)(emh.rclFrame.left) * PixelsX / (MMX * 100.0f));
			rc.right = (int)((float)(emh.rclFrame.right) * PixelsX / (MMX * 100.0f));
			rc.bottom = (int)((float)(emh.rclFrame.bottom) * PixelsY / (MMY * 100.0f));
			//end code: taken from ENHMETA.EXE MSDN Sample

			HDC hdcMem = CreateCompatibleDC(hDC);
			HGDIOBJ hBmpMem = CreateCompatibleBitmap(hDC, emh.rclBounds.right, emh.rclBounds.bottom);
			HGDIOBJ hOldBmp = ::SelectObject(hdcMem, hBmpMem);
			PlayEnhMetaFile(hdcMem, medium.hEnhMetaFile, &rc);
			HBITMAP hBmp = (HBITMAP)::SelectObject(hdcMem, hOldBmp);
			DeleteDC(hdcMem);
			ReleaseDC(m_hTargetWnd, hDC);
			hBmp = (HBITMAP)SendMessage(m_hTargetWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hBmp);
			if (hBmp != NULL)
				DeleteObject(hBmp);
			return true;
		}
		if (pFmtEtc->cfFormat == CF_HDROP && medium.tymed == TYMED_HGLOBAL)
		{
			HDROP hDrop = (HDROP)GlobalLock(medium.hGlobal);
			if (hDrop != NULL)
			{
				TCHAR szFileName[MAX_PATH];
				UINT cFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
				if (cFiles > 0)
				{
					DragQueryFile(hDrop, 0, szFileName, sizeof(szFileName));
					HBITMAP hBitmap = (HBITMAP)LoadImage(NULL, szFileName, IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_LOADFROMFILE);
					if (hBitmap)
					{
						HBITMAP hBmp = (HBITMAP)SendMessage(m_hTargetWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hBitmap);
						if (hBmp != NULL)
							DeleteObject(hBmp);
					}
				}
			}
			GlobalUnlock(medium.hGlobal);
		}
		return true; //let base free the medium
	}
} // namespace DuiLib

#pragma warning(pop)