zhipuzi_pos_windows/DuiLib/Control/UICombo.cpp

#include "StdAfx.h"

namespace DuiLib {

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

	// =========================================================================
	// 【下拉弹框的根布局】把"落在空白处"的那一手点击，交给**纵向最近的那一项**。
	//
	// 要修的 bug（用户真机 Win10）：**触摸点下拉项，有时点了没反应，要点第二下。**
	//
	// 【成因（同一份真机日志实证）】弹框固定 140×60，两项各 28px：
	//     项0 = y[1,29)     项1 = y[29,57)      ← 根布局 inset(1,1,1,1) + 边框 1px
	//     y ∈ [57,60) 是**最后一项下方的空白**（`Init` 里 `cyFixed += 4` 留的收尾空间）
	//     ⇒ 命中它得到的是根布局自己，整手**没有任何效果**。
	//   日志对照（同一段 60 秒 / 多次开框）：
	//     点 (65,57)/(34,59)/(46,58) → 落点 = 根布局 VerticalLayoutUI，**没有 itemclick**；
	//     点 (37,52)/(37,51)/(51,18) → 落点 = 下拉项，正常选中并关框。
	//   为什么鼠标不觉得、手指却很容易踩到：鼠标指针精确，3px 空白基本踩不到；
	//   手指的落点（触点重心）天然比目标准几像素，点**最后一项**时尤其容易
	//   落到它下沿的空白上 ⇒ 表现为"某一下点了没反应，要点第二下"。
	//
	// 【修法：只改命中，不改几何】
	//   弹框高度 / 缩进 / 边框一律不动 —— 几何怎么挪都只是把边界平移，
	//   几像素的落点偏差照样跨过去；把弹框缩小更糟（手指会落到弹框**外面**，
	//   那就成了"点弹框外 ⇒ 关框但不选中"，比现在更糟）。
	//   改成"点在空白里 ⇒ 交给纵向最近的那一项"，并**原样补发 BUTTONDOWN + BUTTONUP**：
	//   那一项跑的代码与"手指就点在它身上"逐字相同
	//   （`CListLabelElementUI::DoEvent` 这两支都不看坐标），于是
	//     选中 → Select(true) → CComboUI::SelectItem → itemselect（业务）
	//     关框 → SendNotify(itemclick) → CComboWnd::Notify → PostMessage(WM_KILLFOCUS)
	//   全部原路照走，**不引入任何新机制**。
	//   两条通道都走这里：触摸由 `CPaintManagerUI::TouchUp` 把 BUTTONUP 派发给
	//   `m_pEventClick`；鼠标由 `MessageHandler` 的 `WM_LBUTTONUP` 派发给同一个对象
	//   ⇒ 鼠标与触摸表现继续保持一致。
	// =========================================================================
	namespace {
		class CComboDropLayoutUI : public CVerticalLayoutUI
		{
		public:
			// 纵向离 pt 最近的可见子项（pt 落在某一项内时距离为 0）；无可见子项时返回 NULL。
			CControlUI* FindNearestItem(const POINT& pt) const
			{
				CControlUI* pBest = NULL;
				int nBestDist = 0;
				for( int i = 0; i < GetCount(); ++i ) {
					CControlUI* pItem = GetItemAt(i);
					if( pItem == NULL || !pItem->IsVisible() ) continue;
					const RECT& rc = pItem->GetPos();
					int nDist = 0;
					if( pt.y < rc.top ) nDist = rc.top - pt.y;
					else if( pt.y > rc.bottom ) nDist = pt.y - rc.bottom;
					if( pBest == NULL || nDist <= nBestDist ) {
						pBest = pItem;
						nBestDist = nDist;
					}
				}
				return pBest;
			}

			void DoEvent(TEventUI& event)
			{
				// 只有"抬起"这一下才可能构成一次点击。
				// （滑动被判定为"不算点击"时：鼠标路径把 ptMouse 置成 (-1,-1)，
				//   触摸路径干脆一个 BUTTON* 都不派发 —— 见 TouchUp 的 !bTapLike 分支。）
				if( event.Type == UIEVENT_BUTTONUP )
				{
					const POINT pt = event.ptMouse;
					// 守卫 ①：坐标必须落在**本布局自己的矩形内**。
					//   滑动收尾那句 `ptMouse = (-1,-1)` 是"这一手作废"的约定，
					//   绝不能被当成"落点在第一项上面"。
					if( ::PtInRect(&GetPos(), pt) )
					{
						// 守卫 ②：确认没落在任何子项上。
						//   理论上走到本布局的 BUTTONUP 就说明 FindControl 没命中子项，
						//   但按下点与抬起点可以不是同一点，这里再判一次，语义自洽。
						bool bOnItem = false;
						for( int i = 0; i < GetCount() && !bOnItem; ++i ) {
							CControlUI* pItem = GetItemAt(i);
							if( pItem != NULL && pItem->IsVisible() && ::PtInRect(&pItem->GetPos(), pt) )
								bOnItem = true;
						}
						if( !bOnItem )
						{
							CControlUI* pItem = FindNearestItem(pt);
							if( pItem != NULL )
							{
								// 先落变量再取 data（`CDuiString` 直接进可变参是 UB，见项目铁律）。
								CDuiString sItemText = pItem->GetText();
								DuiLibDiag::Log(_T("COMBO-DROP snap pt=%d,%d -> item '%s' (空白处点击转给最近项)"),
									pt.x, pt.y, sItemText.GetData());
								// 与真实点击**逐字相同**的一对事件。
								TEventUI ev = event;
								ev.pSender = pItem;
								ev.Type = UIEVENT_BUTTONDOWN;
								ev.dwTimestamp = ::GetTickCount();
								pItem->Event(ev);
								ev.Type = UIEVENT_BUTTONUP;
								ev.dwTimestamp = ::GetTickCount();
								pItem->Event(ev);
								// 本手已按"点在那一项上"处理完，不再往下走。
								return;
							}
						}
					}
				}
				CVerticalLayoutUI::DoEvent(event);
			}
		};
	}

	class CComboWnd : public CWindowWnd, public INotifyUI
	{
	public:
		void Init(CComboUI* pOwner);
		LPCTSTR GetWindowClassName() const;
		void OnFinalMessage(HWND hWnd);

		LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
		void Notify(TNotifyUI& msg) override;

		void EnsureVisible(int iIndex);
		void Scroll(int dx, int dy);

#if(_WIN32_WINNT >= 0x0501)
		virtual UINT GetClassStyle() const;
#endif
		bool IsHitItem(POINT ptMouse);
		// 【Win7"点了不出来"】焦点丢失后的**延迟一帧**判定（见该函数定义处的长注释）。
		void DecideAfterFocusLoss();
	public:
		// 【与鼠标行为对齐 · 唯一的关闭出口】Post 一条 WM_CLOSE，且**只生效一次**。
		// 下拉框自己没有"关闭"入口（原实现全靠鼠标消息里的收尾），抽出来是为了让
		// "再点一次 Combo" 与 "焦点被抢走" 两条路共用**同一个**收尾动作。
		void PostCloseOnce();
		CPaintManagerUI m_pm;
		CComboUI* m_pOwner;
		CVerticalLayoutUI* m_pLayout;
		int m_iOldSel;
		bool m_bHitItem;
		// 【与鼠标行为对齐】"本框已决定关闭"的幂等位。关闭可能从两条路同时到来 ——
		//   ① 用户**再点一次**同一个 Combo（`Activate()` 的复用分支，靠它收起下拉框）；
		//   ② 系统把激活抢走引发的 `WM_KILLFOCUS`（延迟一帧判定，见 DecideAfterFocusLoss）。
		// 置真之后：不再重复 Post WM_CLOSE（第二条会打在已销毁的 HWND 上），
		// 且判定不再走"赦免回声"那条路（否则会给正在销毁的窗口 SetForegroundWindow/SetFocus）。
		bool m_bClosePosted;
		// owner Combo 的**屏幕**矩形（建窗时快照）：判定"这一下点的是不是这个 Combo"
		// 必须用屏幕坐标 —— 客户区坐标一换窗口就不可比（与提升副本的坐标系一致）。
		RECT m_rcOwnerScreen;
	};

	// =========================================================================
	// 【诊断脚手架 · 定位完就删】Combo 下拉框现场日志
	//
	// 要回答的问题（用户实测：**Win7 上点 Combo 容易卡顿，有时要点 2~4 下才弹出**）：
	//   Q1 这一下有没有派发到 Combo 控件（= `CComboUI::Activate()` 有没有被调用）？
	//   Q2 弹窗是"根本没被创建"，还是"创建后被立刻关掉"？开→关隔了多少毫秒？
	//   Q3 关掉它的是哪条路：`WM_LBUTTONUP`(m_bHitItem) / `WM_KILLFOCUS`(谁抢了焦点)
	//      / `itemclick` / 其它？
	//   Q4 打开时有没有"提升鼠标副本"（drain 摘掉几条）？副本自己有没有投进来？
	//
	// 出口统一走 `DuiLibDiag::Log`（写 exe 同目录 touch_trace.log）。
	// 关闭方式：`Utils/UIDiag.cpp` 的 `Enabled()` 改成 return false；定位完整体删除。
	// =========================================================================
	static DWORD s_dwComboOpenTick = 0;   // 最近一次 ShowWindow 的时刻，用于算存活时长

	// 私有消息：焦点丢失后的"延迟一帧判定"（见 CComboWnd::DecideAfterFocusLoss）。
	// 用消息而不是直接判断，是因为焦点丢失那一刻**证据还没到**：
	// 抢激活的那条提升副本要等系统把当前这条消息派发完才会进窗口过程。
	static const UINT kMsgComboDecideAfterFocusLoss = WM_APP + 0x0C0D;

	// 本条消息是不是"系统为触摸提升出来的鼠标消息"。
	// 与 UIManager.cpp 里那个同源判据逐字一致 —— 那边在匿名 namespace 里取不到，
	// 诊断用途故此处重写一份。低 7 位是触点 id，每次手势都变，必须屏蔽掉；
	// 别用文档示例的 `& 0xFFFFFF80`（真机恒为假，历史坑）。
	static bool Combo_IsPromotedMouse()
	{
		return (DWORD)((DWORD_PTR)::GetMessageExtraInfo() & 0xFFFFFF00) == 0xFF515700;
	}

	static LPCTSTR Combo_MsgName(UINT uMsg)
	{
		switch (uMsg)
		{
		case WM_CREATE:				return _T("CREATE");
		case WM_DESTROY:			return _T("DESTROY");
		case WM_NCDESTROY:			return _T("NCDESTROY");
		case WM_CLOSE:				return _T("CLOSE");
		case WM_SHOWWINDOW:			return _T("SHOWWINDOW");
		case WM_ACTIVATE:			return _T("ACTIVATE");
		case WM_NCACTIVATE:			return _T("NCACTIVATE");
		case WM_MOUSEACTIVATE:		return _T("MOUSEACTIVATE");
		case WM_SETFOCUS:			return _T("SETFOCUS");
		case WM_KILLFOCUS:			return _T("KILLFOCUS");
		case WM_LBUTTONDOWN:		return _T("LBUTTONDOWN");
		case WM_LBUTTONUP:			return _T("LBUTTONUP");
		case WM_LBUTTONDBLCLK:		return _T("LBUTTONDBLCLK");
		case WM_WINDOWPOSCHANGED:	return _T("WINDOWPOSCHANGED");
		default:					return _T("?");
		}
	}

	// 便利函数：把下拉框弹窗的"当前激活/焦点现场"打一行出来。
	// fg/active/focus 三个是谁，直接说明"是不是被别的窗口把焦点抢走了"。
	static void Combo_LogWndState(LPCTSTR pszTag, HWND hWnd)
	{
		DuiLibDiag::Log(_T("COMBO-%s hwnd=%p visible=%d enabled=%d fg=%p active=%p focus=%p owner=%p"),
			pszTag, hWnd,
			(int)(::IsWindowVisible(hWnd) ? 1 : 0),
			(int)(::IsWindowEnabled(hWnd) ? 1 : 0),
			::GetForegroundWindow(), ::GetActiveWindow(), ::GetFocus(),
			(::GetWindow(hWnd, GW_OWNER)));
	}

	void CComboWnd::Notify(TNotifyUI& msg)
	{
		if (msg.sType == _T("windowinit"))
		{
			EnsureVisible(m_iOldSel);
		}
		else if (msg.sType == _T("itemclick"))
		{
			// ------------------------------------------------------------------
			// ★【触摸点击必须在这里收尾】用户在下拉列表里选中一项 ⇒ 关闭下拉框。
			//
			// 为什么必须有这一支（真机 bug：Win10 下"item 点了有效果，下拉框不消失"）：
			//
			//   鼠标路径的收尾点在 HandleMessage 的 **WM_LBUTTONUP** 里
			//   （`m_bHitItem && IsHitItem(pt)` ⇒ PostMessage(WM_KILLFOCUS) ⇒ 关窗口）。
			//   而触摸点击走的是 DuiLib 自己的触摸状态机（WM_TOUCH / WM_POINTER*）：
			//   CPaintManagerUI::TouchUp 直接给命中控件**合成** BUTTONDOWN/BUTTONUP，
			//   全程不产生 WM_LBUTTONUP（Win10 上系统更是完全不投递提升鼠标消息）
			//   ⇒ 那条收尾**永远不会执行** ⇒ 下拉框一直挂着。
			//
			//   而业务其实已经生效了：CListLabelElementUI/... 在 **BUTTONDOWN** 里就
			//   Select(true) ⇒ CComboUI::SelectItem ⇒ SendNotify(itemselect) 到主窗口，
			//   所以现象是"选了有用、框不关"（用户实测原话）。
			//
			// 为什么选 itemclick 当信号：
			//   · 它是**两条通道都会到达**的同一个通知 ——
			//     CListLabelElementUI / CListContainerElementUI 的 UIEVENT_BUTTONUP
			//     都调 SendNotify(DUI_MSGTYPE_ITEMCLICK)（= "itemclick"）；
			//   · 触摸链只在**判定为轻点**时才合成 BUTTONUP（滑动滚动列表时
			//     TouchUp 走 !bTapLike 分支，一个 BUTTON* 都不派发）⇒ 滑动不会误关；
			//   · 滚动条不发 itemclick ⇒ 拖滑块也不会误关。
			//
			// 收尾动作与鼠标路径**逐字一致**：PostMessage(WM_KILLFOCUS)
			//   ⇒ HandleMessage 的 WM_KILLFOCUS 分支 ⇒ PostMessage(WM_CLOSE)
			//   ⇒ 销毁本窗口 ⇒ OnFinalMessage 里清掉 m_pOwner->m_pWindow。
			// 不引入任何新机制，只是把**已有的收尾点**补到另一条通道上。
			//
			// ⚠️ 用 PostMessage（异步）而不是直接 Close()：本条通知是在
			//    CPaintManagerUI::TouchUp 派发 BUTTONUP 的**同步调用栈里**发出的，
			//    就地销毁窗口会让调用栈上的 m_pEventClick 等立刻悬垂。
			// ------------------------------------------------------------------
			// ------------------------------------------------------------------
			// 【诊断】下拉项被点中（两条通道都会到）：这是"选完就该关框"的那条通知。
			// ------------------------------------------------------------------
			DuiLibDiag::Log(_T("COMBO-CLOSE reason=itemclick sender=%s alive=%ums"),
				(msg.pSender != NULL) ? msg.pSender->GetName().GetData() : _T("null"),
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
			if (m_hWnd != NULL && ::IsWindow(m_hWnd))
				PostMessage(WM_KILLFOCUS);
		}
		else if(msg.sType == _T("click")) {
			// 测试代码
			CDuiString sName = msg.pSender->GetName();
			CControlUI* pCtrl = msg.pSender;
			while(pCtrl != NULL) {
				IListItemUI* pListItem = (IListItemUI*)pCtrl->GetInterface(DUI_CTR_LISTITEM);
				if(pListItem != NULL ) {
					break;
				}
				pCtrl = pCtrl->GetParent();
			}
			if( m_pOwner->GetManager() != NULL ) m_pOwner->GetManager()->SendNotify(msg.pSender, DUI_MSGTYPE_CLICK, 0, 0);
		}
	}

	void CComboWnd::Init(CComboUI* pOwner)
	{
		m_bHitItem = false;
		// 【与鼠标行为对齐】每一次弹出的都是**新的 CComboWnd 实例**（Activate() 里 new），
		// 这里显式复位，避免"已决定关闭"的语义跨代残留。
		m_bClosePosted = false;
		m_pOwner = pOwner;
		m_pLayout = NULL;
		m_iOldSel = m_pOwner->GetCurSel();

		// 【诊断】弹窗构建开始：owner 是谁、建之前光标/焦点在哪、owner 是否可见可用。
		{
			POINT ptCur = { 0 }; ::GetCursorPos(&ptCur);
			DuiLibDiag::Log(_T("COMBO-INIT begin owner=%s ownerHwnd=%p cursor=%d,%d ownerVisible=%d ownerEnabled=%d wnd=%p"),
				pOwner != NULL ? pOwner->GetName().GetData() : _T("null"),
				// 【R57】链式解引用必须逐级判空：GetManager() 可能为 NULL（历史崩点同款）。
				(pOwner != NULL && pOwner->GetManager() != NULL) ? pOwner->GetManager()->GetPaintWindow() : NULL,
				ptCur.x, ptCur.y,
				(int)(pOwner != NULL && pOwner->IsVisible() ? 1 : 0),
				(int)(pOwner != NULL && pOwner->IsEnabled() ? 1 : 0),
				(void*)this);
		}

		// Position the popup window in absolute space
		SIZE szDrop = m_pOwner->GetDropBoxSize();
		RECT rcInset = m_pOwner->GetDropBoxInset();
		RECT rcOwner = pOwner->GetPos();
		// 【Win7"点了不出来"】快照 owner Combo 的**屏幕**矩形。
		// 用途：焦点丢失后的延迟判定要回答"用户刚点的那一下，是不是就在这个 Combo 上"——
		// 是 ⇒ 那是"打开我那一出手势的回声"（系统行为）；不是 ⇒ 用户点了别处，该关框。
		// 一律用屏幕坐标：提升副本的记录点就是屏幕坐标（见 UIManager.cpp 的 ArmPromotedMouseDuplicate）。
		m_rcOwnerScreen = rcOwner;
		::MapWindowRect(pOwner->GetManager()->GetPaintWindow(), HWND_DESKTOP, &m_rcOwnerScreen);
		RECT rc = rcOwner;
		rc.top = rc.bottom;		// 父窗口left、bottom位置作为弹出窗口起点
		rc.bottom = rc.top + szDrop.cy;	// 计算弹出窗口高度
		if( szDrop.cx > 0 ) rc.right = rc.left + szDrop.cx;	// 计算弹出窗口宽度

		SIZE szAvailable = { rc.right - rc.left, rc.bottom - rc.top };
		int cyFixed = rcInset.top;
		for( int it = 0; it < pOwner->GetCount(); it++ ) {
			CControlUI* pControl = static_cast<CControlUI*>(pOwner->GetItemAt(it));
			if( !pControl->IsVisible() ) continue;
			SIZE sz = pControl->EstimateSize(szAvailable);
			cyFixed += sz.cy;
		}
		cyFixed += 4;
		rc.bottom = rc.top + MIN(cyFixed, szDrop.cy);

		::MapWindowRect(pOwner->GetManager()->GetPaintWindow(), HWND_DESKTOP, &rc);

		MONITORINFO oMonitor = {};
		oMonitor.cbSize = sizeof(oMonitor);
		::GetMonitorInfo(::MonitorFromWindow(*this, MONITOR_DEFAULTTOPRIMARY), &oMonitor);
		CDuiRect rcWork = oMonitor.rcWork;
		if( rc.bottom > rcWork.bottom ) {
			rc.left = rcOwner.left;
			rc.right = rcOwner.right;
			if( szDrop.cx > 0 ) rc.right = rc.left + szDrop.cx;
			rc.top = rcOwner.top - MIN(cyFixed, szDrop.cy);
			rc.bottom = rcOwner.top;
			::MapWindowRect(pOwner->GetManager()->GetPaintWindow(), HWND_DESKTOP, &rc);
		}

		// 【诊断】创建前的目标矩形（已是屏幕坐标）+ 创建前焦点现场。
		DuiLibDiag::Log(_T("COMBO-INIT create rc=%d,%d,%d,%d (screen) ownerRc=%d,%d,%d,%d"),
			rc.left, rc.top, rc.right, rc.bottom,
			rcOwner.left, rcOwner.top, rcOwner.right, rcOwner.bottom);

		Create(pOwner->GetManager()->GetPaintWindow(), NULL, WS_POPUP, WS_EX_TOOLWINDOW, rc);
		// HACK: Don't deselect the parent's caption
		HWND hWndParent = m_hWnd;
		while( ::GetParent(hWndParent) != NULL ) hWndParent = ::GetParent(hWndParent);
		// 【诊断】ShowWindow 之前记时刻：之后所有"存活时长"都以它为零点。
		s_dwComboOpenTick = ::GetTickCount();
		::ShowWindow(m_hWnd, SW_SHOW);
		{
			POINT ptCur = { 0 }; ::GetCursorPos(&ptCur);
			DuiLibDiag::Log(_T("COMBO-INIT shown rcOwnerCli=%d,%d,%d,%d cursor=%d,%d"),
				rcOwner.left, rcOwner.top, rcOwner.right, rcOwner.bottom, ptCur.x, ptCur.y);
			Combo_LogWndState(_T("OPEN"), m_hWnd);
		}
		::SendMessage(hWndParent, WM_NCACTIVATE, TRUE, 0L);
		// 【诊断】给 owner 发完 WM_NCACTIVATE 之后再打一次：看焦点是否在这一步被挪走。
		Combo_LogWndState(_T("OPEN2"), m_hWnd);
	}

	LPCTSTR CComboWnd::GetWindowClassName() const
	{
		return _T("ComboWnd");
	}

	void CComboWnd::OnFinalMessage(HWND hWnd)
	{
		// 【诊断】窗口真的没了。开→关的存活时长是判断"是不是刚弹出就被关掉"的关键数字：
		// 正常打开放着不动会是几百 ms 以上；若是几十 ms 内反复出现，
		// 就说明每次点击都在"建窗口 → 立刻销毁"，这既是"要点好几下"的原因，也是卡顿的来源。
		DuiLibDiag::Log(_T("COMBO-FIN hwnd=%p alive=%ums"),
			hWnd, (unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
		s_dwComboOpenTick = 0;
		// 【第 42 轮】owner 可能已经不在了（控件被移除/销毁后才轮到我们收尾）。
		// 判空只防"指针为 NULL"，防不了"内存已释放" —— 另一半由 CComboUI::~CComboUI()
		// 同步收掉本窗口来保证（见那里的长注释）。两者互补，缺一不可。
		if( m_pOwner != NULL ) {
			m_pOwner->m_pWindow = NULL;
			m_pOwner->m_uButtonState &= ~ UISTATE_PUSHED;
			m_pOwner->Invalidate();
		}
		delete this;
	}

	bool CComboWnd::IsHitItem(POINT ptMouse)
	{
		CControlUI* pControl = m_pm.FindControl(ptMouse);
		if(pControl != NULL) {
			LPVOID pInterface = pControl->GetInterface(DUI_CTR_SCROLLBAR);
			if(pInterface) return false;

			while(pControl != NULL) {
				IListItemUI* pListItem = (IListItemUI*)pControl->GetInterface(DUI_CTR_LISTITEM);
				if(pListItem != NULL ) {
					return true;
				}
				pControl = pControl->GetParent();
			}
		}
		
		return false;
	}

	LRESULT CComboWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		// ==================================================================
		// 【诊断】只登记"与弹出/关闭/焦点"有关的消息，**不改动任何原有分支**。
		// 消息名见 Combo_MsgName；`extra` 用来认"提升鼠标副本"。
		// ==================================================================
		if (uMsg == WM_CREATE || uMsg == WM_DESTROY || uMsg == WM_NCDESTROY
			|| uMsg == WM_SHOWWINDOW || uMsg == WM_ACTIVATE || uMsg == WM_NCACTIVATE
			|| uMsg == WM_MOUSEACTIVATE || uMsg == WM_SETFOCUS || uMsg == WM_KILLFOCUS)
		{
			DuiLibDiag::Log(_T("COMBO-MSG %s hwnd=%p wParam=0x%08X lParam=0x%08X alive=%ums"),
				Combo_MsgName(uMsg), m_hWnd, (unsigned)wParam, (unsigned)lParam,
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
		}
		else if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK)
		{
			// 用**光标**取点（与下面原有分支一致）：提升副本的 lParam 归属窗口可能不是本窗口，
			// 用 GetCursorPos 才不会把坐标解释错。
			POINT ptCli = { 0 }; ::GetCursorPos(&ptCli);
			::ScreenToClient(m_pm.GetPaintWindow(), &ptCli);
			DuiLibDiag::Log(_T("COMBO-MSG %s hwnd=%p extra=0x%08X promoted=%d ptCli=%d,%d hitItem=%d m_bHitItem=%d alive=%ums"),
				Combo_MsgName(uMsg), m_hWnd,
				(unsigned)(DWORD_PTR)::GetMessageExtraInfo(),
				(int)(Combo_IsPromotedMouse() ? 1 : 0),
				ptCli.x, ptCli.y, (int)IsHitItem(ptCli), (int)m_bHitItem,
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
		}

		if( uMsg == WM_CREATE ) {
			m_pm.SetForceUseSharedRes(true);
			m_pm.Init(m_hWnd);
			m_pm.SetLayered(true);
			// The trick is to add the items to the new container. Their owner gets
			// reassigned by this operation - which is why it is important to reassign
			// the items back to the righfull owner/manager when the window closes.
			// 用 CComboDropLayoutUI 而不是裸的 CVerticalLayoutUI：
			// 唯一区别是"点在空白处（没落在任何下拉项上）时把这一手交给最近的那一项"。
			// 成因与实证见该类的注释 —— 触摸点最后一项时很容易落到它下沿的空白上。
			m_pLayout = new CComboDropLayoutUI;
			m_pLayout->SetManager(&m_pm, NULL, true);
			LPCTSTR pDefaultAttributes = m_pOwner->GetManager()->GetDefaultAttributeList(_T("VerticalLayout"));
			if( pDefaultAttributes ) {
				m_pLayout->ApplyAttributeList(pDefaultAttributes);
			}
			m_pLayout->SetInset(CDuiRect(1, 1, 1, 1));
			m_pLayout->SetBkColor(0xFFFFFFFF);
			m_pLayout->SetBorderColor(0xFFC6C7D2);
			m_pLayout->SetBorderSize(1);
			m_pLayout->SetAutoDestroy(false);
			m_pLayout->EnableScrollBar();
			m_pLayout->ApplyAttributeList(m_pOwner->GetDropBoxAttributeList());
			for( int i = 0; i < m_pOwner->GetCount(); i++ ) {
				m_pLayout->Add(static_cast<CControlUI*>(m_pOwner->GetItemAt(i)));
			}
			CShadowUI *pShadow = m_pOwner->GetManager()->GetShadow();
			pShadow->CopyShadow(m_pm.GetShadow());
			m_pm.GetShadow()->ShowShadow(m_pOwner->IsShowShadow());
			m_pm.AttachDialog(m_pLayout);
			m_pm.AddNotifier(this);
			return 0;
		}
		else if( uMsg == WM_CLOSE ) {
			// 【诊断】关闭现场：走到这里说明"关下拉框"的收尾已经开始。
			DuiLibDiag::Log(_T("COMBO-CLOSE reason=WM_CLOSE alive=%ums"),
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
			// 【第 42 轮】owner 可能已被移出控件树（此时它的 manager 是 NULL）或已销毁。
			// 这段收尾是"把 items 归还给 owner 的 manager"，owner 不在了就没有归还对象，
			// 直接跳过即可 —— 但**绝不能**不判空就解引用。
			if( m_pOwner != NULL ) {
				m_pOwner->SetManager(m_pOwner->GetManager(), m_pOwner->GetParent(), false);
				RECT rcNull = { 0 };
				for( int i = 0; i < m_pOwner->GetCount(); i++ ) static_cast<CControlUI*>(m_pOwner->GetItemAt(i))->SetPos(rcNull);
				m_pOwner->SetFocus();
			}
		}
		else if( uMsg == WM_LBUTTONDOWN ) {
			POINT pt = { 0 };
			::GetCursorPos(&pt);
			::ScreenToClient(m_pm.GetPaintWindow(), &pt);
			m_bHitItem = IsHitItem(pt);
			DuiLibDiag::Log(_T("COMBO-DECIDE LBUTTONDOWN ptCli=%d,%d -> m_bHitItem=%d alive=%ums"),
				pt.x, pt.y, (int)m_bHitItem,
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
		}
		else if( uMsg == WM_LBUTTONUP ) {
			POINT pt = { 0 };
			::GetCursorPos(&pt);
			::ScreenToClient(m_pm.GetPaintWindow(), &pt);
			const bool bHitNow = IsHitItem(pt) ? true : false;
			DuiLibDiag::Log(_T("COMBO-DECIDE LBUTTONUP ptCli=%d,%d m_bHitItem=%d hitNow=%d -> %s alive=%ums"),
				pt.x, pt.y, (int)m_bHitItem, (int)bHitNow,
				(m_bHitItem && bHitNow) ? _T("PostMessage(KILLFOCUS) 即关掉下拉框") : _T("不关"),
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
			if(m_bHitItem && bHitNow) {
				PostMessage(WM_KILLFOCUS);
			}
			m_bHitItem = false;
		}
		else if( uMsg == WM_KEYDOWN ) {
			switch( wParam ) {
			case VK_ESCAPE:
				m_pOwner->SelectItem(m_iOldSel, true);
				EnsureVisible(m_iOldSel);
			case VK_RETURN:
				PostMessage(WM_KILLFOCUS);
				break;
			default:
				TEventUI event;
				event.Type = UIEVENT_KEYDOWN;
				event.chKey = (TCHAR)wParam;
				m_pOwner->DoEvent(event);
				EnsureVisible(m_pOwner->GetCurSel());
				return 0;
			}
		}
		else if( uMsg == WM_MOUSEWHEEL ) {
			int zDelta = (int) (short) HIWORD(wParam);
			TEventUI event = { 0 };
			event.Type = UIEVENT_SCROLLWHEEL;
			event.wParam = MAKELPARAM(zDelta < 0 ? SB_LINEDOWN : SB_LINEUP, 0);
			event.lParam = lParam;
			event.dwTimestamp = ::GetTickCount();
			if(m_pOwner->GetScrollSelect()) {
				m_pOwner->DoEvent(event);
				EnsureVisible(m_pOwner->GetCurSel());
				return 0;
			}
			else {
				m_pLayout->DoEvent(event);
				return 0;
			}
		}
		else if( uMsg == WM_KILLFOCUS ) {
			// 【诊断】谁把焦点抢走了 —— 这一行的 wParam 就是"接任焦点的窗口"。
			// 若它与 owner 相同，说明是"主窗口被重新激活"把我们挤掉，而不是你点了别处
			//（鼠标激活发生在**进入窗口过程之前**，所以这里拦不住）。
			// ⚠️⚠️【第 42 轮 · "手指快速触摸点 Combo 直接崩"的修点】这一行的实参以前是
			//     `m_pOwner->GetManager()->GetPaintWindow()` —— **裸连环解引用**。两个理由使它必崩：
			//     ① `Log(...)` 的**实参在调用之前就求值**，与日志开关无关
			//        （把 `Enabled()` 改成 false 也拦不住 —— `Log` 第一行 return 时表达式早算完了）；
			//     ② owner 被移出控件树 / 正在销毁时 `GetManager()` 返回 NULL
			//        ⇒ `NULL->GetPaintWindow()` ⇒ 访问违例 ⇒ 进程直接崩。
			//   ⇒ 铁律：**探针里的每一次指针解引用都必须先判空 —— 探针的代价不能高于它探测的东西。**
			//     （本项目第二次栽在同一件事上：第一次是把 CDuiString 对象塞进变参。）
			CPaintManagerUI* pOwnerMgr = (m_pOwner != NULL) ? m_pOwner->GetManager() : NULL;
			const HWND hOwnerWnd = (pOwnerMgr != NULL) ? pOwnerMgr->GetPaintWindow() : NULL;
			DuiLibDiag::Log(_T("COMBO-DECIDE KILLFOCUS newFocus=%p self=%p ownerHwnd=%p -> %s alive=%ums"),
				(HWND)wParam, m_hWnd, hOwnerWnd,
				(m_hWnd != (HWND)wParam) ? _T("延迟一帧判定") : _T("忽略（焦点回到自己）"),
				(unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
			// ⚠️ 不能在这里当场 PostMessage(WM_CLOSE)：
			//   抢激活的那条提升副本**此刻还没进窗口过程**（激活先于派发），
			//   当场判"要不要关"必然把"打开我那一出手势的回声"误判成"用户点了别处"。
			//   见 DecideAfterFocusLoss 的长注释。
			if( m_hWnd != (HWND) wParam ) PostMessage(kMsgComboDecideAfterFocusLoss);
		}
		else if( uMsg == kMsgComboDecideAfterFocusLoss ) {
			DecideAfterFocusLoss();
		}

		LRESULT lRes = 0;
		if( m_pm.MessageHandler(uMsg, wParam, lParam, lRes) ) return lRes;
		return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
	}

	// ======================================================================
	// ★★【Combo 下拉框 · 焦点丢失后的延迟一帧判定】★★
	//   Win7 的"点了不出来" 与 Win10 的"再点一下收不起来 / item 点一下没反应"
	//   都收束在这里，是同一个判据的两个失效方向。
	//
	// 【现象一（Win7）「点 Combo 要点 2~4 下才弹出」】
	//   日志实证：41 次打开里有 11 次是"建好之后 15~46ms 就被关掉"。
	//   根因：**打开下拉框的那一出手势**，它的提升鼠标副本会反过来把下拉框关掉 ——
	//     ① 手指点 Combo → 触摸链合成 BUTTONDOWN/BUTTONUP → CComboUI::Activate()
	//        → 建窗 + ShowWindow（约 15ms）→ 下拉框成为前台/激活/焦点窗口；
	//     ② 系统随后才把**同一次触摸**的提升鼠标 `WM_LBUTTONDOWN` 投出来，
	//        投给 owner（此刻光标在 Combo 上，下拉框在它下面、盖不到这个点）；
	//     ③ 系统"把鼠标点击投给非前台窗口"的处理是**先激活该窗口**，且发生在
	//        **进入窗口过程之前** —— WndProc 里任何闸门都拦不住（PROMOTED-DUP
	//        照样把消息吞掉了，`dupHit=1`，但激活已经发生）；
	//     ④ owner 被激活 ⇒ 刚 ShowWindow 出来的下拉框收到 WM_KILLFOCUS；
	//     ⑤ 于是**同一个 KILLFOCUS 有两种来源**：可能是②③这条回声，也可能是
	//        用户真的点了别处。两者都表现为同一条消息 ⇒ 才需要"延迟一帧判定"。
	//
	// 【为什么必须延迟一帧】KILLFOCUS 当场判只能看到"③ 已经发生"，看不到
	//   "② 那条副本是什么"（副本要等系统把当前这条消息派发完才进窗口过程）。
	//   所以 KILLFOCUS 只 Post 一条私有消息，等它被处理时现场才齐。
	//
	// 【现象二（Win10）「再点一下 Combo，弹框就是不收起来」】
	//   同一手在两条通道上的差别（真机日志实证，60 秒 / 58 次开框）：
	//     · 点击都是**合成**的（CPaintManagerUI::TouchUp → BUTTONDOWN/BUTTONUP
	//       → CComboUI::DoEvent 的 UIEVENT_BUTTONDOWN → Activate()）；
	//     · Win7 的触摸还会被提升成鼠标消息 ⇒ 系统顺手把**光标挪到触点**
	//       ⇒ 本判定的坐标是对的 ⇒ 走"赦免" ⇒ 框活到抬手 ⇒ 抬手的合成点击
	//       看到 `m_pWindow != NULL` ⇒ 走 `PostCloseOnce()` 收起 ✓
	//     · Win10 走 WM_POINTER*，**主窗口的触摸一条提升副本都不产生**
	//       （日志：54 对提升消息全部属于"点在下拉列表里"的那一手，点 Combo 的 0 条）
	//       ⇒ 光标停在**上一手**的位置 ⇒ 判成"不在 Combo 上" ⇒ **不赦免**
	//       ⇒ 框被失焦链先关掉（KILLFOCUS → decide → PostCloseOnce → WM_CLOSE），
	//       紧接着**同一手的合成点击**才到 `Activate()`，`m_pWindow` 已被
	//       OnFinalMessage 清成 NULL ⇒ **又新建一个框** ⇒ 用户看到"就是不收起来"。
	//       实证：58 次 `COMBO-ACT enter` **全部** `hasWindow=0`。
	//   同一处失效还有第二个方向：点列表里的 item 时，**上一手**的位置可能恰好
	//   落在 Combo 上 ⇒ 误赦免 ⇒ 框不关 ⇒ 用户以为"点一下没反应"，于是点第二下。
	//
	// 【唯一判据：这一手点的位置还在不在**这个 Combo 自己**身上】
	//   坐标源必须是 `CPaintManagerUI::GetLastInputScreenPoint()`
	//   （触摸 ⇒ 触摸链记录的真实触点；鼠标 ⇒ GetCursorPos），**不能直接用
	//   `::GetCursorPos()`** —— 触摸下它慢一手，这正是 Win7/Win10 的分界线。
	//   判定成立 ⇒ 赦免（不关框，并把激活/焦点拿回来）；收起的动作交给抬手的
	//   合成点击走 `Activate()` → `PostCloseOnce()`，与鼠标"再点一次"同一条路
	//   ⇒ 不会变成"关一次又开一次"。
	//
	// 【为什么不会误伤"点别处要关框"】
	//   点弹框外面 / 别的控件 / 列表里的 item ⇒ 这一手的坐标不在 Combo 上 ⇒ 照旧关框。
	//
	// 【自限（务必保留）】
	//   纯鼠标机器（从未有过触摸）⇒ 坐标源恒等于 `::GetCursorPos()`
	//   ⇒ 本函数与改动前**逐字等价**。真实鼠标点 Combo 时，`Activate()` 在
	//   BUTTONDOWN 里已经把 `m_bClosePosted` 置真 ⇒ 本函数当场早退，根本用不到判据。
	//
	// 【已废弃、勿再引入】
	//   · 用"有没有见过一条提升鼠标点击"（`ConsumePromotedMouseMsgJustSeen`）当**闸门**：
	//     该标志按"自上次判定以来"结算，而每一手的副本都落在**该手自己的判定之后**、
	//     被**下一手**收走 ⇒ 稳态恒真、不携带信息（48/47 次为真），还恰好在需要它的
	//     那几手上为假。现在只消费、不判定。
	//   · 用"代数水位 / extra 指纹 / 时间戳"区分回声：均已被真机日志逐一证伪
	//     （Win7 的 extra 恒为定值；水位一手就追平）。**判据只认状态与坐标。**
	// ======================================================================
	void CComboWnd::DecideAfterFocusLoss()
	{
		if( m_hWnd == NULL || !::IsWindow(m_hWnd) ) return;

		// ⚠️ 这个一次性标志**无论后面走哪条分支都必须先消费掉** ——
		//    它的语义是"自上次判定以来"，跳过消费会把 true 残留给下一次判定。
		//    （它现在**不再参与判定**，见下面注释；消费只为保持"自上次判定以来"的语义。）
		(void)CPaintManagerUI::ConsumePromotedMouseMsgJustSeen();

		// 【与鼠标行为对齐】已经决定关闭了 ⇒ 不再回头赦免。
		// 命中这条说明用户是"**再点了一次**同一个 Combo"（Activate() 的复用分支
		// 已经把框推上关闭路径）—— 此刻若还去抢激活/焦点，只会把焦点硬塞给一个
		// 正在销毁的窗口。位置必须在消费那一行之后。
		if( m_bClosePosted ) {
			DuiLibDiag::Log(_T("COMBO-DECIDE afterFocusLoss 已决定关闭 -> 不再判定"));
			return;
		}

		// ==================================================================
		// ★★【Win10 · 修复点】判定"这一下点的还是不是这个 Combo" —— 坐标源换了 ★★
		//
		// 【改前】`::GetCursorPos()`。它在**鼠标**下是对的（鼠标就是光标），
		//   在**触摸**下是**错的**：系统的触摸提升才会把光标挪到触点，而本项目
		//   Combo 的打开/关闭是触摸链**合成**的点击（CPaintManagerUI::TouchUp），
		//   发生在提升**之前** ⇒ 这里读到的光标永远是**上一手**停留的位置。
		//   真机日志实证（Win10，60 秒 / 58 次开框）：
		//     `COMBO-INIT begin ... cursor=768,251`，而这一手的触点是 (789,153)；
		//     768,251 正是**上一手**点在下拉列表里的位置。
		//
		// 【为什么"Win7 好、Win10 坏"就是这一行造成的】
		//   两条通道的**点击**都是合成的，差异只在"提升副本会不会顺手把光标挪对"：
		//     · Win7（WM_TOUCH）：同一次触摸还会被提升成鼠标消息 ⇒ 光标被挪到触点
		//       ⇒ 本判定读到的坐标是对的 ⇒ 走"赦免"分支 ⇒ 框活到抬手 ⇒ 抬手的
		//       合成点击看到 `m_pWindow != NULL` ⇒ 收起 ✓
		//     · Win10（WM_POINTER*）：主窗口的触摸**一条提升副本都不产生**（日志实证：
		//       54 对提升消息全部属于"点在下拉列表里"的那一手，点 Combo 的手势 0 条）
		//       ⇒ 光标停在上一手 ⇒ 判成"不在 Combo 上" ⇒ **不赦免** ⇒ 框被失焦链
		//       （KILLFOCUS → decide → PostCloseOnce → WM_CLOSE）先关掉；紧接着
		//       **同一手的合成点击**才到 `Activate()`，此刻 `m_pWindow` 已被
		//       OnFinalMessage 清成 NULL ⇒ **又新建一个下拉框** ⇒
		//       用户看到"再点一下 Combo，框就是不收起来"（58/58 次 `hasWindow=0` 实证）。
		//
		// 【改后】用 `CPaintManagerUI::GetLastInputScreenPoint()`；最后输入是触摸时它
		//   返回**触摸链记录的真实触点**（两通道公共入口 BeginTouchSlideGesture 里
		//   记的屏幕坐标），是鼠标时才退回 `::GetCursorPos()`。
		//   于是两平台拿到的都是"这一手点在哪"，判定第一次名副其实：
		//     · 点 Combo 自己 ⇒ 在 `m_rcOwnerScreen` 内 ⇒ 赦免（别让失焦链抢先把框关掉）
		//       ⇒ 抬手时 `Activate()` 看到 `m_pWindow != NULL` ⇒ 收起 ✓（与鼠标同表现）
		//     · 点列表里的 item ⇒ 坐标在 owner 之外 ⇒ 不赦免 ⇒ 照旧关框 ✓
		//     · 点弹框外空白 / 别的控件 ⇒ 同样不赦免 ⇒ 照旧关框 ✓
		//
		// 【为什么不拿 bEcho 当闸门了】
		//   原判据是 `bEcho && bOnOwnCombo`。真机日志把 bEcho 的意义证伪了：这台
		//   Win10 机器**确实**产生提升副本（60 秒里 54 对），只是它们都归属主窗口；
		//   而每手的副本都落在**该手自己的判定之后**，于是恒定被**下一手**的判定收走
		//   ⇒ 48 次判定里 47 次为真 ⇒ **稳态恒真、不携带信息**，还恰恰在需要它的
		//   那几手上为假（日志里 6 次 echo=0，其中 2 次 onOwnCombo=1 却因此没赦免）。
		//   [`最近一次输入是不是触摸`] 这个事实由触摸链的公共入口提供，比"有没有见过
		//   一条提升副本"更直接、更可靠，而且**与"这台机器产不产生提升副本"完全无关**
		//   —— 这恰恰是必须摆脱 bEcho 的原因：Win7 与 Win10 的差别就在"提升副本会不会
		//   顺手把光标挪对"，任何以"提升副本"为前提的判据都会跟着平台漂移。
		//
		// 【自限（务必保留）】纯鼠标机器（从未有过触摸）⇒ GetLastInputScreenPoint()
		//   恒等于 `::GetCursorPos()` ⇒ 本函数与改动前**逐字等价**；
		//   真实鼠标点 Combo 时 `Activate()` 在 BUTTONDOWN 里已经把 m_bClosePosted
		//   置真 ⇒ 上面那行早退 ⇒ 这里根本不会被用到。
		// ==================================================================
		const POINT ptInput = CPaintManagerUI::GetLastInputScreenPoint();
		POINT ptCursor = { 0 };
		::GetCursorPos(&ptCursor);
		const bool bOnOwnCombo = (::PtInRect(&m_rcOwnerScreen, ptInput) != FALSE);

		DuiLibDiag::Log(_T("COMBO-DECIDE afterFocusLoss input=%d,%d onOwnCombo=%d (cursor=%d,%d) ownerRc=%d,%d,%d,%d -> %s"),
			ptInput.x, ptInput.y, (int)(bOnOwnCombo ? 1 : 0), ptCursor.x, ptCursor.y,
			m_rcOwnerScreen.left, m_rcOwnerScreen.top, m_rcOwnerScreen.right, m_rcOwnerScreen.bottom,
			bOnOwnCombo ? _T("赦免（用户正点在这个 Combo 上，让 Activate() 去收起它）")
						: _T("关掉下拉框"));

		if( bOnOwnCombo )
		{
			// 系统的激活被这次手势抢走了，但用户的本意就是"点这个 Combo"。
			// 把现场恢复成"刚打开"的样子：前台 + 焦点都回到下拉框自己。
			// （只把焦点拿回来也够用，但两样都还原才与 COMBO-OPEN 记录的状态一致：
			//   那边 fg/active/focus 三个都是下拉框本身。）
			//
			// 框**不在这里关**：收起的动作统一由抬手的合成点击走 `Activate()`
			// ⇒ `PostCloseOnce()`（与鼠标"再点一次"完全同一条路），这样
			// "点一下 Combo 收起框"不会变成"关一次 + 又开一次"。
			::SetForegroundWindow(m_hWnd);
			::SetFocus(m_hWnd);
			return;
		}

		PostCloseOnce();
	}

	// ======================================================================
	// ★【与鼠标行为对齐】下拉框的**唯一关闭出口**（幂等）。
	//
	// 【为什么需要它】用户要求"手指点击的表现与鼠标点击完全一样"。拿"下拉框已经开着，
	//   再点一次同一个 Combo"这一手来比：
	//     · 鼠标：按下 owner ⇒ 系统**先激活 owner**（激活发生在**进入窗口过程之前**，
	//       所以它不体现为任何一条我们能处理的鼠标消息）⇒ 下拉框收到 WM_KILLFOCUS
	//       ⇒ 自己关掉。用户看到的就是"再点一次就收起"。
	//     · 触摸：点击是本项目触摸链**合成**的 BUTTONDOWN/BUTTONUP
	//       （`CPaintManagerUI::TouchUp`）⇒ 走到 `CComboUI::DoEvent` 只有 `Activate()`，
	//       而它在弹窗已存在时是"复用后直接 return" ⇒ **一个关闭动作都没有**。
	//       Win7 上还偶有提升副本把 owner 重新激活（那条副作用被"意外补上"），
	//       Win10 走 WM_POINTER*、一条提升消息都不产生 ⇒ 100% 收不起来。
	//   ⇒ 差异不在"关闭动作"本身，而在**鼠标有一条触摸链不具备的副作用**。
	//     这里把那条副作用显式写出来（调用点：`Activate()` 的复用分支）。
	//
	// 【为什么必须幂等】同一次"再点一次"可能同时触发两条关闭路径：
	//   ① `Activate()` 复用分支直接调本函数；
	//   ② 提升副本把 owner 激活 ⇒ WM_KILLFOCUS ⇒ DecideAfterFocusLoss 也会调本函数。
	//   若不幂等就会 Post 两条 WM_CLOSE，第二条会打在**已销毁**的 HWND 上
	//   （句柄可能已被复用）。`m_bClosePosted` 同时让判定函数知道
	//   "已经决定关了，别再回头赦免"。
	//
	// 【收尾动作与鼠标路径逐字一致】仍然是 `WM_CLOSE`
	//   ⇒ HandleMessage 的 WM_CLOSE 分支 ⇒ 销毁本窗口 ⇒ OnFinalMessage 里
	//   清掉 `m_pOwner->m_pWindow`。不新增任何收尾语义。
	// ======================================================================
	void CComboWnd::PostCloseOnce()
	{
		if( m_bClosePosted ) return;
		m_bClosePosted = true;
		DuiLibDiag::Log(_T("COMBO-CLOSE reason=postCloseOnce hwnd=%p alive=%ums"),
			m_hWnd, (unsigned)(s_dwComboOpenTick != 0 ? (::GetTickCount() - s_dwComboOpenTick) : 0));
		if( m_hWnd != NULL && ::IsWindow(m_hWnd) ) PostMessage(WM_CLOSE);
	}

	void CComboWnd::EnsureVisible(int iIndex)
	{
		if( m_pOwner->GetCurSel() < 0 ) return;
		m_pLayout->FindSelectable(m_pOwner->GetCurSel(), false);
		RECT rcItem = m_pLayout->GetItemAt(iIndex)->GetPos();
		RECT rcList = m_pLayout->GetPos();
		CScrollBarUI* pHorizontalScrollBar = m_pLayout->GetHorizontalScrollBar();
		if( pHorizontalScrollBar && pHorizontalScrollBar->IsVisible() ) rcList.bottom -= pHorizontalScrollBar->GetFixedHeight();
		int iPos = m_pLayout->GetScrollPos().cy;
		if( rcItem.top >= rcList.top && rcItem.bottom < rcList.bottom ) return;
		int dx = 0;
		if( rcItem.top < rcList.top ) dx = rcItem.top - rcList.top;
		if( rcItem.bottom > rcList.bottom ) dx = rcItem.bottom - rcList.bottom;
		Scroll(0, dx);
	}

	void CComboWnd::Scroll(int dx, int dy)
	{
		if( dx == 0 && dy == 0 ) return;
		SIZE sz = m_pLayout->GetScrollPos();
		m_pLayout->SetScrollPos(CDuiSize(sz.cx + dx, sz.cy + dy));
	}

#if(_WIN32_WINNT >= 0x0501)
	UINT CComboWnd::GetClassStyle() const
	{
		return __super::GetClassStyle();
		if(m_pOwner->IsShowShadow()) {
			return __super::GetClassStyle();

		}
		else {
			return __super::GetClassStyle() | CS_DROPSHADOW;
		}
	}
#endif
	////////////////////////////////////////////////////////
	IMPLEMENT_DUICONTROL(CComboUI)

	// ======================================================================
	// ★★【第 42 轮 · "手指快速触摸点击 Combo 程序直接崩"】owner 死了必须同步收掉下拉窗 ★★
	//
	// 【为什么必须有这个析构】下拉窗（CComboWnd）是一个**独立顶层窗口**，它的生命周期
	//   跟 owner 控件**没有**任何自动绑定关系。而它收尾时（OnFinalMessage）会回头写 owner：
	//       m_pOwner->m_pWindow = NULL;
	//       m_pOwner->m_uButtonState &= ~UISTATE_PUSHED;
	//       m_pOwner->Invalidate();
	//   ⇒ 只要 owner 先被销毁（设置页重建 / 控件被 Remove+delete），这三行就是
	//     **写已释放内存** ⇒ 访问违例 ⇒ 进程直接崩。
	//
	// 【为什么触摸下特别容易撞上（鼠标不犯的原因）】
	//   鼠标按在 Combo/item 上时，系统会**先激活 owner**（激活发生在进入窗口过程之前），
	//   下拉窗随即因失焦而关掉 —— 这个"关闭"通常发生在 owner 被销毁**之前**。
	//   而触摸的点击是本项目触摸链**合成**的（CPaintManagerUI::TouchUp），
	//   **不改变窗口激活** ⇒ 下拉窗的关闭只能靠显式收尾（itemclick / Activate 复用分支），
	//   于是它**可能晚于** owner 的销毁（业务在 itemselect 回调里重建设置页时尤其如此）
	//   ⇒ 撞上悬垂写的概率远高于鼠标。这就是"手指点崩、鼠标点不崩"的分界线。
	//
	// ⚠️⚠️ 为什么**不能**照抄 DuiLib 原版的 `if (m_pWindow) m_pWindow->Close();`
	//   本项目 `CWindowWnd::Close()` 末尾是 `PostMessage(WM_CLOSE, ...)` —— **异步**！
	//   在析构里 Post 一条消息，真正的销毁与 OnFinalMessage 会推迟到本对象
	//   **析构完成之后**才跑 ⇒ 悬垂照旧，等于没修。
	//
	// ⇒ 修法：**同步**走完同一条收尾链，让 OnFinalMessage 在本对象仍然有效时跑完。
	//   SendMessage(WM_CLOSE) 会进 CComboWnd::HandleMessage 的 WM_CLOSE 分支
	//   （把 items 归还给 owner 的 manager、复位 owner 状态 —— 这段收尾不能跳过），
	//   随后由基类/DefWindowProc 销毁窗口 ⇒ WM_NCDESTROY ⇒ OnFinalMessage（同步）。
	//   仍不放心就再 DestroyWindow 兜一次；两处都用线程 ID 校验，避免句柄被系统
	//   复用到别的窗口时误杀。
	// ======================================================================
	CComboUI::~CComboUI()
	{
		if( m_pWindow == NULL ) return;

		HWND hDropWnd = m_pWindow->GetHWND();
		if( hDropWnd != NULL && ::IsWindow(hDropWnd)
			&& ::GetWindowThreadProcessId(hDropWnd, NULL) == ::GetCurrentThreadId() )
		{
			::SendMessage(hDropWnd, WM_CLOSE, 0L, 0L);
			if( ::IsWindow(hDropWnd) ) ::DestroyWindow(hDropWnd);
		}
		m_pWindow = NULL;   // OnFinalMessage 里已置 NULL；这里兜底，防它没跑到
	}

	CComboUI::CComboUI() : m_uTextStyle(DT_VCENTER | DT_SINGLELINE)
		, m_dwTextColor(0)
		, m_dwDisabledTextColor(0)
		, m_iFont(-1)
		, m_bShowHtml(false)
		, m_pWindow(NULL)
		, m_iCurSel(-1)
		, m_uButtonState(0)
		, m_bScrollSelect(true)
		, m_bShowShadow(false)
	{
		m_szDropBox = CDuiSize(0, 150);
		::ZeroMemory(&m_rcTextPadding, sizeof(m_rcTextPadding));
		::ZeroMemory(&m_rcDropBox, sizeof(m_rcDropBox));

		m_ListInfo.nColumns = 0;
		m_ListInfo.nFont = -1;
		m_ListInfo.uTextStyle = DT_VCENTER;
		m_ListInfo.dwTextColor = 0xFF000000;
		m_ListInfo.dwBkColor = 0;
		m_ListInfo.bAlternateBk = false;
		m_ListInfo.dwSelectedTextColor = 0xFF000000;
		m_ListInfo.dwSelectedBkColor = 0xFFC1E3FF;
		m_ListInfo.dwHotTextColor = 0xFF000000;
		m_ListInfo.dwHotBkColor = 0xFFE9F5FF;
		m_ListInfo.dwDisabledTextColor = 0xFFCCCCCC;
		m_ListInfo.dwDisabledBkColor = 0xFFFFFFFF;
		m_ListInfo.dwLineColor = 0;
		m_ListInfo.bShowHtml = false;
		m_ListInfo.bMultiExpandable = false;
		::ZeroMemory(&m_ListInfo.rcTextPadding, sizeof(m_ListInfo.rcTextPadding));
		::ZeroMemory(&m_ListInfo.rcColumn, sizeof(m_ListInfo.rcColumn));

		m_pCompareFunc = NULL;
		m_compareData = NULL;
	}

	LPCTSTR CComboUI::GetClass() const
	{
		return _T("ComboUI");
	}

	LPVOID CComboUI::GetInterface(LPCTSTR pstrName)
	{
		if( _tcsicmp(pstrName, DUI_CTR_COMBO) == 0 ) return static_cast<CComboUI*>(this);
		if( _tcsicmp(pstrName, _T("IListOwner")) == 0 ) return static_cast<IListOwnerUI*>(this);
		return CContainerUI::GetInterface(pstrName);
	}

	UINT CComboUI::GetControlFlags() const
	{
		return UIFLAG_TABSTOP | UIFLAG_SETCURSOR;
	}

	void CComboUI::DoInit()
	{
	}

	UINT CComboUI::GetListType()
	{
		return LT_COMBO;
	}

	TListInfoUI* CComboUI::GetListInfo()
	{
		return &m_ListInfo;
	}

	int CComboUI::GetCurSel() const
	{
		return m_iCurSel;
	}

	bool CComboUI::SelectItem(int iIndex, bool bTakeFocus)
	{
		if( iIndex == m_iCurSel ) return true;
		int iOldSel = m_iCurSel;
		if( m_iCurSel >= 0 ) {
			CControlUI* pControl = static_cast<CControlUI*>(m_items[m_iCurSel]);
			if( !pControl ) return false;
			IListItemUI* pListItem = static_cast<IListItemUI*>(pControl->GetInterface(_T("ListItem")));
			if( pListItem != NULL ) pListItem->Select(false);
			m_iCurSel = -1;
		}
		if( iIndex < 0 ) return false;
		if( m_items.GetSize() == 0 ) return false;
		if( iIndex >= m_items.GetSize() ) iIndex = m_items.GetSize() - 1;
		CControlUI* pControl = static_cast<CControlUI*>(m_items[iIndex]);
		if( !pControl || !pControl->IsEnabled() ) return false;
		IListItemUI* pListItem = static_cast<IListItemUI*>(pControl->GetInterface(_T("ListItem")));
		if( pListItem == NULL ) return false;
		m_iCurSel = iIndex;
		if( m_pWindow != NULL || bTakeFocus ) pControl->SetFocus();
		pListItem->Select(true);
		if( m_pManager != NULL ) m_pManager->SendNotify(this, DUI_MSGTYPE_ITEMSELECT, m_iCurSel, iOldSel);
		Invalidate();

		return true;
	}

	bool CComboUI::SelectMultiItem(int iIndex, bool bTakeFocus)
	{
		return SelectItem(iIndex, bTakeFocus);
	}
	
	bool CComboUI::UnSelectItem(int iIndex, bool bOthers)
	{
		return false;
	}
		
	bool CComboUI::SetItemIndex(CControlUI* pControl, int iIndex)
	{
		int iOrginIndex = GetItemIndex(pControl);
		if( iOrginIndex == -1 ) return false;
		if( iOrginIndex == iIndex ) return true;

		IListItemUI* pSelectedListItem = NULL;
		if( m_iCurSel >= 0 ) pSelectedListItem = 
			static_cast<IListItemUI*>(GetItemAt(m_iCurSel)->GetInterface(_T("ListItem")));
		if( !CContainerUI::SetItemIndex(pControl, iIndex) ) return false;
		int iMinIndex = min(iOrginIndex, iIndex);
		int iMaxIndex = max(iOrginIndex, iIndex);
		for(int i = iMinIndex; i < iMaxIndex + 1; ++i) {
			CControlUI* p = GetItemAt(i);
			IListItemUI* pListItem = static_cast<IListItemUI*>(p->GetInterface(_T("ListItem")));
			if( pListItem != NULL ) {
				pListItem->SetIndex(i);
			}
		}
		if( m_iCurSel >= 0 && pSelectedListItem != NULL ) m_iCurSel = pSelectedListItem->GetIndex();
		return true;
	}

	bool CComboUI::Add(CControlUI* pControl)
	{
		IListItemUI* pListItem = static_cast<IListItemUI*>(pControl->GetInterface(_T("ListItem")));
		if( pListItem != NULL ) 
		{
			pListItem->SetOwner(this);
			pListItem->SetIndex(m_items.GetSize());
		}
		return CContainerUI::Add(pControl);
	}

	bool CComboUI::AddAt(CControlUI* pControl, int iIndex)
	{
		if (!CContainerUI::AddAt(pControl, iIndex)) return false;

		// The list items should know about us
		IListItemUI* pListItem = static_cast<IListItemUI*>(pControl->GetInterface(_T("ListItem")));
		if( pListItem != NULL ) {
			pListItem->SetOwner(this);
			pListItem->SetIndex(iIndex);
		}

		for(int i = iIndex + 1; i < GetCount(); ++i) {
			CControlUI* p = GetItemAt(i);
			pListItem = static_cast<IListItemUI*>(p->GetInterface(_T("ListItem")));
			if( pListItem != NULL ) {
				pListItem->SetIndex(i);
			}
		}
		if( m_iCurSel >= iIndex ) m_iCurSel += 1;
		return true;
	}

	bool CComboUI::Remove(CControlUI* pControl)
	{
		int iIndex = GetItemIndex(pControl);
		if (iIndex == -1) return false;

		if (!CContainerUI::RemoveAt(iIndex)) return false;

		for(int i = iIndex; i < GetCount(); ++i) {
			CControlUI* p = GetItemAt(i);
			IListItemUI* pListItem = static_cast<IListItemUI*>(p->GetInterface(_T("ListItem")));
			if( pListItem != NULL ) {
				pListItem->SetIndex(i);
			}
		}

		if( iIndex == m_iCurSel && m_iCurSel >= 0 ) {
			int iSel = m_iCurSel;
			m_iCurSel = -1;
			SelectItem(FindSelectable(iSel, false));
		}
		else if( iIndex < m_iCurSel ) m_iCurSel -= 1;
		return true;
	}

	bool CComboUI::RemoveAt(int iIndex)
	{
		if (!CContainerUI::RemoveAt(iIndex)) return false;

		for(int i = iIndex; i < GetCount(); ++i) {
			CControlUI* p = GetItemAt(i);
			IListItemUI* pListItem = static_cast<IListItemUI*>(p->GetInterface(_T("ListItem")));
			if( pListItem != NULL ) pListItem->SetIndex(i);
		}

		if( iIndex == m_iCurSel && m_iCurSel >= 0 ) {
			int iSel = m_iCurSel;
			m_iCurSel = -1;
			SelectItem(FindSelectable(iSel, false));
		}
		else if( iIndex < m_iCurSel ) m_iCurSel -= 1;
		return true;
	}

	void CComboUI::RemoveAll()
	{
		m_iCurSel = -1;
		CContainerUI::RemoveAll();
	}

	void CComboUI::DoEvent(TEventUI& event)
	{
		if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
			if( m_pParent != NULL ) m_pParent->DoEvent(event);
			else CContainerUI::DoEvent(event);
			return;
		}

		if( event.Type == UIEVENT_SETFOCUS ) 
		{
			Invalidate();
		}
		if( event.Type == UIEVENT_KILLFOCUS ) 
		{
			Invalidate();
		}
		if( event.Type == UIEVENT_BUTTONDOWN )
		{
			if( IsEnabled() ) {
				Activate();
				m_uButtonState |= UISTATE_PUSHED | UISTATE_CAPTURED;
			}
			return;
		}
		if( event.Type == UIEVENT_BUTTONUP )
		{
			if( (m_uButtonState & UISTATE_CAPTURED) != 0 ) {
				m_uButtonState &= ~ UISTATE_CAPTURED;
				Invalidate();
			}
			return;
		}
		if( event.Type == UIEVENT_MOUSEMOVE )
		{
			return;
		}
		if( event.Type == UIEVENT_KEYDOWN )
		{
			if (!IsKeyboardEnabled())
			{
				return;
			}
			switch( event.chKey ) {
			case VK_F4:
				Activate();
				return;
			case VK_UP:
				SelectItem(FindSelectable(m_iCurSel - 1, false));
				return;
			case VK_DOWN:
				SelectItem(FindSelectable(m_iCurSel + 1, true));
				return;
			case VK_PRIOR:
				SelectItem(FindSelectable(m_iCurSel - 1, false));
				return;
			case VK_NEXT:
				SelectItem(FindSelectable(m_iCurSel + 1, true));
				return;
			case VK_HOME:
				SelectItem(FindSelectable(0, false));
				return;
			case VK_END:
				SelectItem(FindSelectable(GetCount() - 1, true));
				return;
			}
		}
		if( event.Type == UIEVENT_SCROLLWHEEL )
		{
			if(GetScrollSelect()) {
				bool bDownward = LOWORD(event.wParam) == SB_LINEDOWN;
				SelectItem(FindSelectable(m_iCurSel + (bDownward ? 1 : -1), bDownward));
			}
			return;
		}
		if( event.Type == UIEVENT_CONTEXTMENU )
		{
			return;
		}
		if( event.Type == UIEVENT_MOUSEENTER )
		{
			if( ::PtInRect(&m_rcItem, event.ptMouse ) ) {
				if( (m_uButtonState & UISTATE_HOT) == 0  )
					m_uButtonState |= UISTATE_HOT;
				Invalidate();
			}
			return;
		}
		if( event.Type == UIEVENT_MOUSELEAVE )
		{
			if( (m_uButtonState & UISTATE_HOT) != 0 ) {
				m_uButtonState &= ~UISTATE_HOT;
				Invalidate();
			}
			return;
		}
		CControlUI::DoEvent(event);
	}

	SIZE CComboUI::EstimateSize(SIZE szAvailable)
	{
		if( m_cxyFixed.cy == 0 ) return CDuiSize(m_cxyFixed.cx, m_pManager->GetDefaultFontInfo()->tm.tmHeight + 12);
		return CControlUI::EstimateSize(szAvailable);
	}

	bool CComboUI::Activate()
	{
		// 【诊断】Q1：这一下点击有没有派发到 Combo 控件、走到打开动作。
		// 若某个"点了没反应"的那一下**根本看不到这条**，说明问题不在弹窗，
		// 而在更上游（点击没派发到控件 / TouUp 没走到这里）。
		DuiLibDiag::Log(_T("COMBO-ACT enter name=%s hasWindow=%d curSel=%d mgr=%p"),
			GetName().GetData(), (int)(m_pWindow != NULL), m_iCurSel, (void*)m_pManager);
		if( !CControlUI::Activate() ) {
			DuiLibDiag::Log(_T("COMBO-ACT deny (visible=%d enabled=%d)"),
				(int)(IsVisible() ? 1 : 0), (int)(IsEnabled() ? 1 : 0));
			return false;
		}
		if( m_pManager != NULL ) m_pManager->SendNotify(this, DUI_MSGTYPE_PREDROPDOWN);
		if( m_pWindow ) {
			// ------------------------------------------------------------------
			// ★【与鼠标行为对齐 · 用户明确要求】"复用" = 用户**再点了一次**同一个
			//   Combo ⇒ 收起下拉框。
			//
			// 【原来为什么只是直接返回】DuiLib 原实现（含 NIM_Duilib）在这里什么都不做，
			//   因为**鼠标**再点一下时，"按下 owner ⇒ 系统先激活 owner ⇒ 下拉框失焦"
			//   这条系统副作用已经把框关掉了（激活发生在**进入窗口过程之前**，
			//   甚至不体现为任何一条我们能处理的鼠标消息）⇒ 用户看到"再点一次就收起"。
			//
			// 【触摸为什么收不起来】合成点击本身**不改变窗口激活**；真正把框关掉的
			//   是"手指按下时系统先激活 owner ⇒ 下拉框失焦"这条链（见下）。
			//
			// 【机制（真机日志已钉死）】这一支以前**根本没被走到**：
			//   ① 手指按在 Combo 上 ⇒ 系统**先激活 owner**（Win8+ 指针激活，发生在
			//      进入窗口过程之前，WndProc 拦不住）⇒ 下拉框收到 WM_KILLFOCUS；
			//   ② KILLFOCUS → 延迟一帧判定 → 修复前判成"用户点了别处"
			//      ⇒ PostCloseOnce() ⇒ 框**先**被销毁、m_pWindow 清成 NULL；
			//   ③ 手指抬起 ⇒ 合成 BUTTONDOWN 走到这里 ⇒ 看到 m_pWindow 是 NULL
			//      ⇒ 走下面的新建分支 ⇒ **又开一个框** ⇒ 用户看到"点了不收起来"。
			//   实证：修复前 58 次 COMBO-ACT enter **全部** hasWindow=0。
			//
			// ⚠️ 本分支要**真正生效**，前提是 DecideAfterFocusLoss 别抢先把框关掉 ——
			//   那正是它的"赦免"分支要干的事（判据已改用触摸链的真实触点）。
			//
			// 【修法：把那条缺失的副作用显式写出来】关闭。收尾动作与鼠标路径完全一致
			//   （同一个 WM_CLOSE，见 PostCloseOnce 的长注释），因此"焦点/前台"这些状态
			//   最终都由系统按同一条路走完 —— 用户看到的表现也就与鼠标完全一样。
			//   键盘 F4 也会走到这里：框开着时 F4 = 收起，与 Windows 标准 ComboBox 一致。
			//
			// 【自限】鼠标路径下这一支同样会执行，但它**本来就是要关框**的
			//   （失焦副作用已经在关它了）⇒ 幂等位保证结果不变、只少一次重复的 WM_CLOSE。
			// ------------------------------------------------------------------
			DuiLibDiag::Log(_T("COMBO-ACT reuse: 弹窗已存在 -> 收起（与鼠标的失焦副作用对齐）"));
			m_pWindow->PostCloseOnce();
			return true;
		}
		m_pWindow = new CComboWnd();
		ASSERT(m_pWindow);

		// ------------------------------------------------------------------
		// ★【Win7 · Combo"点了不出来"】第一道：把"打开本下拉框的那次手势"的提升鼠标
		//   副本，从消息队列里**就地摘掉**（这里摘一次、Init() 之后再摘一次，见下）。
		//
		// 【现象（用户原话）】Win10 单击正常；Win7 上「有时候点击 combox 点不动 /
		//   要点 2 下甚至 3 下 4 下才会弹出下拉框」，还有"卡顿"感。
		//
		// 【为什么只有 Win7 中招】两个平台**唯一的输入差异**就在这里：
		//   本项目的触摸链（CPaintManagerUI::TouchUp）给命中控件**合成**
		//   BUTTONDOWN/BUTTONUP —— Combo 的下拉框就是在这条合成链里被打开的
		//   （CComboUI::DoEvent 的 UIEVENT_BUTTONDOWN → Activate）。
		//   而 Win7 的触摸栈**还会**把同一次触摸提升成一套鼠标消息
		//   （MOVE + LBUTTONDOWN + LBUTTONUP，extra 带 MOUSEEVENTF_FROMTOUCH）；
		//   Win10 的 WM_POINTER* 通道**一条都不产生**（真机日志实证）。
		//
		// 【副本为什么能杀掉刚弹出的下拉框】它的归属窗口是在**投递那一刻**
		//   才按"光标下的窗口"结算的（见 UIManager.cpp 里
		//   DropQueuedPromotedMouseMessages 的说明）—— 这次手势按下时下拉框
		//   还不存在，等副本真正被投递时下拉框已经在那儿了，于是：
		//     · 副本投给**下拉框自己** ⇒ 命中 CComboWnd::HandleMessage 的
		//       WM_LBUTTONDOWN/UP 分支 ⇒ `m_bHitItem && IsHitItem(pt)` ⇒ 自己关掉自己；
		//     · 副本投给**主窗口**（owner）⇒ 主窗口被重新激活（激活发生在**进入窗口
		//       过程之前**，闸门拦不住）⇒ 下拉框收到 WM_KILLFOCUS ⇒ 被关掉。
		//   两条路都通向"弹出即消失"，用户看到的就是"点了没反应"。
		//
		// 【为什么摘除有用、以及它为什么**不足以**单独保证】与 CWindowWnd::ShowModal
		//   那一处同源：
		//   · 判据只有一件事「触摸通道确实收到了这次手势」（IsPromotedMouseDuplicatePending），
		//     与模态边界 / 代数水位 / extra 指纹全都无关；
		//   · 摘除范围只限"**owner 窗口**的鼠标类消息"，且此刻下拉框窗口**还不存在**
		//     ⇒ 副本必然结算给 owner，按 owner 句柄一定摘得到。
		//   ⚠️ 但真机日志证明这条副本**有时候是在 CreateWindowEx 那 15ms 里才被
		//      排进队列的**（41 次打开里 11 次失败，其中 10 次这里只摘到 1 条，
		//      随后副本自己投进来把下拉框关掉）⇒ 单靠"创建前摘一次"是**抢不赢这场
		//      竞态**的。所以：这里摘一次 + Init() 之后再摘一次（顺手把队列清干净），
		//      并且**真正的保证在 CComboWnd::DecideAfterFocusLoss**（焦点丢失后的
		//      延迟一帧判定）—— 那一层不依赖"谁先谁后"，见到回声就忍。
		//
		// 【自限】不产生提升副本的平台（Win10）标志恒假 ⇒ 本机制从不启用 ⇒ 零影响；
		//   鼠标点击打开下拉框时也没有"副本"这回事 ⇒ 行为与以前完全一致。
		// ------------------------------------------------------------------
		// 【诊断】Q4：打开前队列里到底有没有"本次手势的提升鼠标副本"，摘掉了几条。
		// dropped=0 有两种含义：① 这台机器压根不产生副本（Win10 常态）；
		// ② 副本还没排进队列（就会在后面投进来杀掉刚弹出的下拉框）。
		// 结合后续 COMBO-MSG 里 promoted=1 是否出现，就能区分这两种。
		{
			const bool bDupPending = CPaintManagerUI::IsPromotedMouseDuplicatePending();
			int nDropped = 0;
			if (m_pManager != NULL && bDupPending)
			{
				nDropped = CPaintManagerUI::DropQueuedPromotedMouseMessages(m_pManager->GetPaintWindow());
			}
			DuiLibDiag::Log(_T("COMBO-ACT drain dupPending=%d dropped=%d ownerHwnd=%p"),
				(int)(bDupPending ? 1 : 0), nDropped,
				m_pManager != NULL ? m_pManager->GetPaintWindow() : NULL);
		}

		m_pWindow->Init(this);

		// 【第二道摘除：这一处才是"抢在位的那一半"】
		// 真机日志实证：那条提升副本常常是在 Init() 里的 CreateWindowEx 那 **15ms**
		// 才被系统排进队列的（所以上面那次摘除只摘到 1 条，随后副本自己投进来把框关掉）。
		// 此刻窗口已经建好，但**还没回消息泵**（Init 里没有任何 PeekMessage/DispatchMessage
		// 泵，CreateWindowEx/ShowWindow 都不抽队列）⇒ 现在再摘一次一定赶在投递之前。
		// 仍然只摘"owner 的鼠标类消息"：这几条本来就是同一次手势的重复。
		if (m_pManager != NULL && CPaintManagerUI::IsPromotedMouseDuplicatePending())
		{
			const int nDropped2 = CPaintManagerUI::DropQueuedPromotedMouseMessages(m_pManager->GetPaintWindow());
			DuiLibDiag::Log(_T("COMBO-ACT redrain dropped=%d ownerHwnd=%p"), nDropped2,
				m_pManager->GetPaintWindow());
		}

		// 【诊断】Q2：窗口建完并 ShowWindow 之后，弹窗与焦点的现场。
		DuiLibDiag::Log(_T("COMBO-ACT done hwnd=%p"),
			(m_pWindow != NULL) ? m_pWindow->GetHWND() : NULL);
		if( m_pManager != NULL ) m_pManager->SendNotify(this, DUI_MSGTYPE_DROPDOWN);
		Invalidate();
		return true;
	}

	CDuiString CComboUI::GetText() const
	{
		if( m_iCurSel < 0 ) return CControlUI::GetText();

		CControlUI* pControl = static_cast<CControlUI*>(m_items[m_iCurSel]);
		return pControl->GetText();
	}

	void CComboUI::SetEnabled(bool bEnable)
	{
		CContainerUI::SetEnabled(bEnable);
		if( !IsEnabled() ) m_uButtonState = 0;
	}

	CDuiString CComboUI::GetDropBoxAttributeList()
	{
		return m_sDropBoxAttributes;
	}

	void CComboUI::SetDropBoxAttributeList(LPCTSTR pstrList)
	{
		m_sDropBoxAttributes = pstrList;
	}

	SIZE CComboUI::GetDropBoxSize() const
	{
		return m_szDropBox;
	}

	void CComboUI::SetDropBoxSize(SIZE szDropBox)
	{
		m_szDropBox = szDropBox;
	}

	RECT CComboUI::GetDropBoxInset() const
	{
		return m_rcDropBox;
	}

	void CComboUI::SetDropBoxInset(RECT rcDropBox)
	{
		m_rcDropBox = rcDropBox;
	}
	void CComboUI::SetTextStyle(UINT uStyle)
	{
		m_uTextStyle = uStyle;
		Invalidate();
	}

	UINT CComboUI::GetTextStyle() const
	{
		return m_uTextStyle;
	}

	void CComboUI::SetTextColor(DWORD dwTextColor)
	{
		m_dwTextColor = dwTextColor;
		Invalidate();
	}

	DWORD CComboUI::GetTextColor() const
	{
		return m_dwTextColor;
	}

	void CComboUI::SetDisabledTextColor(DWORD dwTextColor)
	{
		m_dwDisabledTextColor = dwTextColor;
		Invalidate();
	}

	DWORD CComboUI::GetDisabledTextColor() const
	{
		return m_dwDisabledTextColor;
	}

	void CComboUI::SetFont(int index)
	{
		m_iFont = index;
		Invalidate();
	}

	int CComboUI::GetFont() const
	{
		return m_iFont;
	}

	RECT CComboUI::GetTextPadding() const
	{
		RECT rcTextPadding = m_rcTextPadding;
		if(m_pManager != NULL) m_pManager->GetDPIObj()->Scale(&rcTextPadding);
		return rcTextPadding;
	}

	void CComboUI::SetTextPadding(RECT rc)
	{
		m_rcTextPadding = rc;
		Invalidate();
	}

	bool CComboUI::IsShowHtml()
	{
		return m_bShowHtml;
	}

	void CComboUI::SetShowHtml(bool bShowHtml)
	{
		if( m_bShowHtml == bShowHtml ) return;

		m_bShowHtml = bShowHtml;
		Invalidate();
	}

	bool CComboUI::IsShowShadow()
	{
		return m_bShowShadow;
	}

	void CComboUI::SetShowShadow(bool bShow)
	{
		if( m_bShowShadow == bShow ) return;

		m_bShowShadow = bShow;
		Invalidate();
	}

	LPCTSTR CComboUI::GetNormalImage() const
	{
		return m_sNormalImage;
	}

	void CComboUI::SetNormalImage(LPCTSTR pStrImage)
	{
		m_sNormalImage = pStrImage;
		Invalidate();
	}

	LPCTSTR CComboUI::GetHotImage() const
	{
		return m_sHotImage;
	}

	void CComboUI::SetHotImage(LPCTSTR pStrImage)
	{
		m_sHotImage = pStrImage;
		Invalidate();
	}

	LPCTSTR CComboUI::GetPushedImage() const
	{
		return m_sPushedImage;
	}

	void CComboUI::SetPushedImage(LPCTSTR pStrImage)
	{
		m_sPushedImage = pStrImage;
		Invalidate();
	}

	LPCTSTR CComboUI::GetFocusedImage() const
	{
		return m_sFocusedImage;
	}

	void CComboUI::SetFocusedImage(LPCTSTR pStrImage)
	{
		m_sFocusedImage = pStrImage;
		Invalidate();
	}

	LPCTSTR CComboUI::GetDisabledImage() const
	{
		return m_sDisabledImage;
	}

	void CComboUI::SetDisabledImage(LPCTSTR pStrImage)
	{
		m_sDisabledImage = pStrImage;
		Invalidate();
	}

	bool CComboUI::GetScrollSelect()
	{
		return m_bScrollSelect;
	}

	void CComboUI::SetScrollSelect(bool bScrollSelect)
	{
		m_bScrollSelect = bScrollSelect;
	}

	void CComboUI::SetItemFont(int index)
	{
		m_ListInfo.nFont = index;
		Invalidate();
	}

	void CComboUI::SetItemTextStyle(UINT uStyle)
	{
		m_ListInfo.uTextStyle = uStyle;
		Invalidate();
	}

	RECT CComboUI::GetItemTextPadding() const
	{
		return m_ListInfo.rcTextPadding;
	}

	void CComboUI::SetItemTextPadding(RECT rc)
	{
		m_ListInfo.rcTextPadding = rc;
		Invalidate();
	}

	void CComboUI::SetItemTextColor(DWORD dwTextColor)
	{
		m_ListInfo.dwTextColor = dwTextColor;
		Invalidate();
	}

	void CComboUI::SetItemBkColor(DWORD dwBkColor)
	{
		m_ListInfo.dwBkColor = dwBkColor;
	}

	void CComboUI::SetItemBkImage(LPCTSTR pStrImage)
	{
		m_ListInfo.sBkImage = pStrImage;
	}

	DWORD CComboUI::GetItemTextColor() const
	{
		return m_ListInfo.dwTextColor;
	}

	DWORD CComboUI::GetItemBkColor() const
	{
		return m_ListInfo.dwBkColor;
	}

	LPCTSTR CComboUI::GetItemBkImage() const
	{
		return m_ListInfo.sBkImage;
	}

	bool CComboUI::IsAlternateBk() const
	{
		return m_ListInfo.bAlternateBk;
	}

	void CComboUI::SetAlternateBk(bool bAlternateBk)
	{
		m_ListInfo.bAlternateBk = bAlternateBk;
	}

	void CComboUI::SetSelectedItemTextColor(DWORD dwTextColor)
	{
		m_ListInfo.dwSelectedTextColor = dwTextColor;
	}

	void CComboUI::SetSelectedItemBkColor(DWORD dwBkColor)
	{
		m_ListInfo.dwSelectedBkColor = dwBkColor;
	}

	void CComboUI::SetSelectedItemImage(LPCTSTR pStrImage)
	{
		m_ListInfo.sSelectedImage = pStrImage;
	}

	DWORD CComboUI::GetSelectedItemTextColor() const
	{
		return m_ListInfo.dwSelectedTextColor;
	}

	DWORD CComboUI::GetSelectedItemBkColor() const
	{
		return m_ListInfo.dwSelectedBkColor;
	}

	LPCTSTR CComboUI::GetSelectedItemImage() const
	{
		return m_ListInfo.sSelectedImage;
	}

	void CComboUI::SetHotItemTextColor(DWORD dwTextColor)
	{
		m_ListInfo.dwHotTextColor = dwTextColor;
	}

	void CComboUI::SetHotItemBkColor(DWORD dwBkColor)
	{
		m_ListInfo.dwHotBkColor = dwBkColor;
	}

	void CComboUI::SetHotItemImage(LPCTSTR pStrImage)
	{
		m_ListInfo.sHotImage = pStrImage;
	}

	DWORD CComboUI::GetHotItemTextColor() const
	{
		return m_ListInfo.dwHotTextColor;
	}
	DWORD CComboUI::GetHotItemBkColor() const
	{
		return m_ListInfo.dwHotBkColor;
	}

	LPCTSTR CComboUI::GetHotItemImage() const
	{
		return m_ListInfo.sHotImage;
	}

	void CComboUI::SetDisabledItemTextColor(DWORD dwTextColor)
	{
		m_ListInfo.dwDisabledTextColor = dwTextColor;
	}

	void CComboUI::SetDisabledItemBkColor(DWORD dwBkColor)
	{
		m_ListInfo.dwDisabledBkColor = dwBkColor;
	}

	void CComboUI::SetDisabledItemImage(LPCTSTR pStrImage)
	{
		m_ListInfo.sDisabledImage = pStrImage;
	}

	DWORD CComboUI::GetDisabledItemTextColor() const
	{
		return m_ListInfo.dwDisabledTextColor;
	}

	DWORD CComboUI::GetDisabledItemBkColor() const
	{
		return m_ListInfo.dwDisabledBkColor;
	}

	LPCTSTR CComboUI::GetDisabledItemImage() const
	{
		return m_ListInfo.sDisabledImage;
	}

	DWORD CComboUI::GetItemLineColor() const
	{
		return m_ListInfo.dwLineColor;
	}

	void CComboUI::SetItemLineColor(DWORD dwLineColor)
	{
		m_ListInfo.dwLineColor = dwLineColor;
	}

	bool CComboUI::IsItemShowHtml()
	{
		return m_ListInfo.bShowHtml;
	}

	void CComboUI::SetItemShowHtml(bool bShowHtml)
	{
		if( m_ListInfo.bShowHtml == bShowHtml ) return;

		m_ListInfo.bShowHtml = bShowHtml;
		Invalidate();
	}

	void CComboUI::SetPos(RECT rc, bool bNeedInvalidate)
	{
		if(!::EqualRect(&rc, &m_rcItem)) {
			// 隐藏下拉窗口
			if(m_pWindow && ::IsWindow(m_pWindow->GetHWND())) m_pWindow->Close();
			// 所有元素大小置为0
			RECT rcNull = { 0 };
			for( int i = 0; i < m_items.GetSize(); i++ ) static_cast<CControlUI*>(m_items[i])->SetPos(rcNull);
			// 调整位置
			CControlUI::SetPos(rc, bNeedInvalidate);
		}
	}

	void CComboUI::Move(SIZE szOffset, bool bNeedInvalidate)
	{
		CControlUI::Move(szOffset, bNeedInvalidate);
	}
	void CComboUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
	{
		if( _tcsicmp(pstrName, _T("align")) == 0 ) {
			if( _tcsstr(pstrValue, _T("left")) != NULL ) {
				m_uTextStyle &= ~(DT_CENTER | DT_RIGHT | DT_SINGLELINE);
				m_uTextStyle |= DT_LEFT;
			}
			if( _tcsstr(pstrValue, _T("center")) != NULL ) {
				m_uTextStyle &= ~(DT_LEFT | DT_RIGHT );
				m_uTextStyle |= DT_CENTER;
			}
			if( _tcsstr(pstrValue, _T("right")) != NULL ) {
				m_uTextStyle &= ~(DT_LEFT | DT_CENTER | DT_SINGLELINE);
				m_uTextStyle |= DT_RIGHT;
			}
		}
		else if( _tcsicmp(pstrName, _T("valign")) == 0 ) {
			if( _tcsstr(pstrValue, _T("top")) != NULL ) {
				m_uTextStyle &= ~(DT_BOTTOM | DT_VCENTER);
				m_uTextStyle |= (DT_TOP | DT_SINGLELINE);
			}
			if( _tcsstr(pstrValue, _T("vcenter")) != NULL ) {
				m_uTextStyle &= ~(DT_TOP | DT_BOTTOM );            
				m_uTextStyle |= (DT_VCENTER | DT_SINGLELINE);
			}
			if( _tcsstr(pstrValue, _T("bottom")) != NULL ) {
				m_uTextStyle &= ~(DT_TOP | DT_VCENTER);
				m_uTextStyle |= (DT_BOTTOM | DT_SINGLELINE);
			}
		}
		else if( _tcsicmp(pstrName, _T("endellipsis")) == 0 ) {
			if( _tcsicmp(pstrValue, _T("true")) == 0 ) m_uTextStyle |= DT_END_ELLIPSIS;
			else m_uTextStyle &= ~DT_END_ELLIPSIS;
		}   
		else if( _tcsicmp(pstrName, _T("wordbreak")) == 0 ) {
			if( _tcsicmp(pstrValue, _T("true")) == 0 ) {
				m_uTextStyle &= ~DT_SINGLELINE;
				m_uTextStyle |= DT_WORDBREAK | DT_EDITCONTROL;
			}
			else {
				m_uTextStyle &= ~DT_WORDBREAK & ~DT_EDITCONTROL;
				m_uTextStyle |= DT_SINGLELINE;
			}
		}    
		else if( _tcsicmp(pstrName, _T("font")) == 0 ) SetFont(_ttoi(pstrValue));
		else if( _tcsicmp(pstrName, _T("textcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetTextColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("disabledtextcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetDisabledTextColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("textpadding")) == 0 ) {
			RECT rcTextPadding = { 0 };
			LPTSTR pstr = NULL;
			rcTextPadding.left = _tcstol(pstrValue, &pstr, 10);  ASSERT(pstr);    
			rcTextPadding.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);    
			rcTextPadding.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);    
			rcTextPadding.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);    
			SetTextPadding(rcTextPadding);
		}
		else if( _tcsicmp(pstrName, _T("showhtml")) == 0 ) SetShowHtml(_tcsicmp(pstrValue, _T("true")) == 0);
		else if( _tcsicmp(pstrName, _T("showshadow")) == 0 ) SetShowShadow(_tcsicmp(pstrValue, _T("true")) == 0);
		else if( _tcsicmp(pstrName, _T("normalimage")) == 0 ) SetNormalImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("hotimage")) == 0 ) SetHotImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("pushedimage")) == 0 ) SetPushedImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("focusedimage")) == 0 ) SetFocusedImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("disabledimage")) == 0 ) SetDisabledImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("scrollselect")) == 0 ) SetScrollSelect(_tcsicmp(pstrValue, _T("true")) == 0);
		else if( _tcsicmp(pstrName, _T("dropbox")) == 0 ) SetDropBoxAttributeList(pstrValue);
		else if( _tcsicmp(pstrName, _T("dropboxsize")) == 0)
		{
			SIZE szDropBoxSize = { 0 };
			LPTSTR pstr = NULL;
			szDropBoxSize.cx = _tcstol(pstrValue, &pstr, 10);  ASSERT(pstr);    
			szDropBoxSize.cy = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);    
			SetDropBoxSize(szDropBoxSize);
		}
		else if( _tcsicmp(pstrName, _T("dropboxinset")) == 0 ) {
			RECT rcTextPadding = { 0 };
			LPTSTR pstr = NULL;
			rcTextPadding.left = _tcstol(pstrValue, &pstr, 10);  ASSERT(pstr);    
			rcTextPadding.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);    
			rcTextPadding.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);    
			rcTextPadding.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);    
			SetDropBoxInset(rcTextPadding);
		}
		else if( _tcsicmp(pstrName, _T("itemfont")) == 0 ) SetItemFont(_ttoi(pstrValue));
		else if( _tcsicmp(pstrName, _T("itemalign")) == 0 ) {
			if( _tcsstr(pstrValue, _T("left")) != NULL ) {
				m_ListInfo.uTextStyle &= ~(DT_CENTER | DT_RIGHT);
				m_ListInfo.uTextStyle |= DT_LEFT;
			}
			if( _tcsstr(pstrValue, _T("center")) != NULL ) {
				m_ListInfo.uTextStyle &= ~(DT_LEFT | DT_RIGHT);
				m_ListInfo.uTextStyle |= DT_CENTER;
			}
			if( _tcsstr(pstrValue, _T("right")) != NULL ) {
				m_ListInfo.uTextStyle &= ~(DT_LEFT | DT_CENTER);
				m_ListInfo.uTextStyle |= DT_RIGHT;
			}
		}
		else if( _tcsicmp(pstrName, _T("itemvalign")) == 0 ) {
			if( _tcsstr(pstrValue, _T("top")) != NULL ) {
				m_ListInfo.uTextStyle &= ~(DT_VCENTER | DT_BOTTOM);
				m_ListInfo.uTextStyle |= DT_TOP;
			}
			if( _tcsstr(pstrValue, _T("vcenter")) != NULL ) {
				m_ListInfo.uTextStyle &= ~(DT_TOP | DT_BOTTOM | DT_WORDBREAK);
				m_ListInfo.uTextStyle |= DT_VCENTER | DT_SINGLELINE;
			}
			if( _tcsstr(pstrValue, _T("bottom")) != NULL ) {
				m_ListInfo.uTextStyle &= ~(DT_TOP | DT_VCENTER);
				m_ListInfo.uTextStyle |= DT_BOTTOM;
			}
		}
		else if( _tcsicmp(pstrName, _T("itemendellipsis")) == 0 ) {
			if( _tcsicmp(pstrValue, _T("true")) == 0 ) m_ListInfo.uTextStyle |= DT_END_ELLIPSIS;
			else m_ListInfo.uTextStyle &= ~DT_END_ELLIPSIS;
		}   
		else if( _tcsicmp(pstrName, _T("itemtextpadding")) == 0 ) {
			RECT rcTextPadding = { 0 };
			LPTSTR pstr = NULL;
			rcTextPadding.left = _tcstol(pstrValue, &pstr, 10);  ASSERT(pstr);    
			rcTextPadding.top = _tcstol(pstr + 1, &pstr, 10);    ASSERT(pstr);    
			rcTextPadding.right = _tcstol(pstr + 1, &pstr, 10);  ASSERT(pstr);    
			rcTextPadding.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);    
			SetItemTextPadding(rcTextPadding);
		}
		else if( _tcsicmp(pstrName, _T("itemtextcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetItemTextColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itembkcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetItemBkColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itembkimage")) == 0 ) SetItemBkImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("itemaltbk")) == 0 ) SetAlternateBk(_tcsicmp(pstrValue, _T("true")) == 0);
		else if( _tcsicmp(pstrName, _T("itemselectedtextcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetSelectedItemTextColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemselectedbkcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetSelectedItemBkColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemselectedimage")) == 0 ) SetSelectedItemImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("itemhottextcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetHotItemTextColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemhotbkcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetHotItemBkColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemhotimage")) == 0 ) SetHotItemImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("itemdisabledtextcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetDisabledItemTextColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemdisabledbkcolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetDisabledItemBkColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemdisabledimage")) == 0 ) SetDisabledItemImage(pstrValue);
		else if( _tcsicmp(pstrName, _T("itemlinecolor")) == 0 ) {
			if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
			LPTSTR pstr = NULL;
			DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
			SetItemLineColor(clrColor);
		}
		else if( _tcsicmp(pstrName, _T("itemshowhtml")) == 0 ) SetItemShowHtml(_tcsicmp(pstrValue, _T("true")) == 0);
		else CContainerUI::SetAttribute(pstrName, pstrValue);
	}

	bool CComboUI::DoPaint(HDC hDC, const RECT& rcPaint, CControlUI* pStopControl)
	{
		return CControlUI::DoPaint(hDC, rcPaint, pStopControl);
	}

	void CComboUI::PaintStatusImage(HDC hDC)
	{
		if( IsFocused() ) m_uButtonState |= UISTATE_FOCUSED;
		else m_uButtonState &= ~ UISTATE_FOCUSED;
		if( !IsEnabled() ) m_uButtonState |= UISTATE_DISABLED;
		else m_uButtonState &= ~ UISTATE_DISABLED;

		if( (m_uButtonState & UISTATE_DISABLED) != 0 ) {
			if( !m_sDisabledImage.IsEmpty() ) {
				if( !DrawImage(hDC, (LPCTSTR)m_sDisabledImage) ) {}
				else return;
			}
		}
		else if( (m_uButtonState & UISTATE_PUSHED) != 0 ) {
			if( !m_sPushedImage.IsEmpty() ) {
				if( !DrawImage(hDC, (LPCTSTR)m_sPushedImage) ) {}
				else return;
			}
		}
		else if( (m_uButtonState & UISTATE_HOT) != 0 ) {
			if( !m_sHotImage.IsEmpty() ) {
				if( !DrawImage(hDC, (LPCTSTR)m_sHotImage) ) {}
				else return;
			}
		}
		else if( (m_uButtonState & UISTATE_FOCUSED) != 0 ) {
			if( !m_sFocusedImage.IsEmpty() ) {
				if( !DrawImage(hDC, (LPCTSTR)m_sFocusedImage) ) {}
				else return;
			}
		}

		if( !m_sNormalImage.IsEmpty() ) {
			if( !DrawImage(hDC, (LPCTSTR)m_sNormalImage) ) {}
			else return;
		}
	}

	void CComboUI::PaintText(HDC hDC)
	{
		if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
		if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();

		RECT rc = m_rcItem;
		rc.left += m_rcTextPadding.left;
		rc.right -= m_rcTextPadding.right;
		rc.top += m_rcTextPadding.top;
		rc.bottom -= m_rcTextPadding.bottom;

		CDuiString sText = GetText();
		if( sText.IsEmpty() ) return;
		int nLinks = 0;
		if( IsEnabled() ) {
			if( m_bShowHtml )
				CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, sText, m_dwTextColor, NULL, NULL, nLinks, m_iFont, m_uTextStyle);
			else
				CRenderEngine::DrawText(hDC, m_pManager, rc, sText, m_dwTextColor, m_iFont, m_uTextStyle);
		}
		else {
			if( m_bShowHtml )
				CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, sText, m_dwDisabledTextColor, NULL, NULL, nLinks, m_iFont, m_uTextStyle);
			else
				CRenderEngine::DrawText(hDC, m_pManager, rc, sText, m_dwDisabledTextColor, m_iFont, m_uTextStyle);
		}
	}

	BOOL CComboUI::SortItems(PULVCompareFunc pfnCompare, UINT_PTR dwData)
	{
		if (!pfnCompare)
			return FALSE;
		m_pCompareFunc = pfnCompare;
		m_compareData = dwData;

		qsort_s(m_items.GetData(), m_items.GetSize(), sizeof(CControlUI*), CComboUI::ItemComareFunc, this);
		IListItemUI* pItem = NULL;
		for (int i = 0; i < m_items.GetSize(); ++i)
		{
			pItem = (IListItemUI*)(static_cast<CControlUI*>(m_items[i])->GetInterface(TEXT("ListItem")));
			if (pItem)
			{
				pItem->SetIndex(i);
				pItem->Select(false);
			}
		}

		if (m_pManager)
		{
			SetPos(GetPos());
			Invalidate();
		}

		return TRUE;
	}

	static int __cdecl ComareFunc(void* pvlocale, const void* item1, const void* item2)
	{
		CComboUI* pThis = (CComboUI*)pvlocale;

		if (!pThis || !item1 || !item2)
			return 0;

		CControlUI* pControl1 = *(CControlUI**)item1;
		CControlUI* pControl2 = *(CControlUI**)item2;
		if (!pControl1 || !pControl2)
		{
			return 0;
		}
		return pControl1->GetText().Compare(pControl2->GetText());
	}

	void CComboUI::SortItems()
	{
		qsort_s(m_items.GetData(), m_items.GetSize(), sizeof(CControlUI*), ComareFunc, this);
		IListItemUI* pItem = NULL;
		for (int i = 0; i < m_items.GetSize(); ++i)
		{
			pItem = (IListItemUI*)(static_cast<CControlUI*>(m_items[i])->GetInterface(TEXT("ListItem")));
			if (pItem)
			{
				pItem->SetIndex(i);
				pItem->Select(false);
			}
		}

		if (m_pManager)
		{
			SetPos(GetPos());
			Invalidate();
		}

		return ;
	}

	int __cdecl CComboUI::ItemComareFunc(void* pvlocale, const void* item1, const void* item2)
	{
		CComboUI* pThis = (CComboUI*)pvlocale;
		if (!pThis || !item1 || !item2)
			return 0;
		return pThis->ItemComareFunc(item1, item2);
	}

	int __cdecl CComboUI::ItemComareFunc(const void* item1, const void* item2)
	{
		if (!m_pCompareFunc)
		{
			return 0;
		}
		CControlUI* pControl1 = *(CControlUI**)item1;
		CControlUI* pControl2 = *(CControlUI**)item2;
		return m_pCompareFunc((UINT_PTR)pControl1, (UINT_PTR)pControl2, m_compareData);
	}
} // namespace DuiLib