mtluser.h

一个使用wtl写的完整的多窗口浏览器

//		NOTIFY_HANDLER_EX(m_toolbar.GetDlgCtrlID(), TBN_ENDDRAG, OnTbnEndDrag)		
	END_MSG_MAP()

	LRESULT OnTbnBeginAdjust(LPNMHDR pnmh)
	{
		LoadTBBtns();//_LoadTBBtns();
		return 0;
	}

	LRESULT OnTbnEndAdjust(LPNMHDR pnmh)
	{
		ATLTRACE2(atlTraceUser, 4, _T("CCustomizableToolBarHandler::OnTbnEndAdjust\n"));
		_UnloadTBBtns();
		_RefreshBandInfo();
		_UIUpdateToolBarFixed();
		return 0;
	}

	LRESULT OnTbnQueryInsert(LPNMHDR pnmh)
	{
		return TRUE;
	}

	LRESULT OnTbnQueryDelete(LPNMHDR pnmh)
	{
		return TRUE;
	}

	LRESULT OnTbnGetButtonInfo(LPNMHDR pnmh)
	{
		ATLASSERT(m_pTBBtn != NULL);

		LPTBNOTIFY ptbn = (LPTBNOTIFY)pnmh;
		if (ptbn->iItem < m_nItems) {
			CString strText = _GetToolTipText(m_pTBBtn[ptbn->iItem].idCommand);
			if (!strText.IsEmpty())
				::lstrcpy(ptbn->pszText, strText);
			::memcpy(&ptbn->tbButton, &m_pTBBtn[ptbn->iItem], sizeof(TBBUTTON));
			return TRUE;
		}
		else
			return FALSE;
	}

	LRESULT OnTbnToolBarChange(LPNMHDR pnmh)
	{
		ATLTRACE2(atlTraceUser, 4, _T("CCustomizableToolBarHandler::OnTbnToolBarChange\n"));
		_RefreshBandInfo();
		return 0;
	}

	LRESULT OnTbnReset(LPNMHDR pnmh)
	{
		ATLASSERT(m_pTBBtn != NULL);

		int iBtn = m_toolbar.GetButtonCount();
		while (iBtn != 0)
			m_toolbar.DeleteButton(--iBtn);

		m_toolbar.AddButtons(m_nItems, m_pTBBtn);
		return 0;
	}

	LRESULT OnTbnCustHelp(LPNMHDR pnmh)
	{
		T* pT = static_cast<T*>(this);
		pT->OnTbnCustHelp(m_toolbar.m_hWnd);
		return 0;
	}

	LRESULT OnTbnBeginDrag(LPNMHDR pnmh)
	{
		LPTBNOTIFY ptbn = (LPTBNOTIFY)pnmh;
		return 0;
	}

	LRESULT OnTbnEndDrag(LPNMHDR pnmh)
	{
		LPTBNOTIFY ptbn = (LPTBNOTIFY)pnmh;
		return 0;
	}

// Declarations
	struct _AtlToolBarData
	{
		WORD wVersion;
		WORD wWidth;
		WORD wHeight;
		WORD wItemCount;
		//WORD aItems[wItemCount]

		WORD* items()
			{ return (WORD*)(this+1); }
	};

// Data members
	CToolBarCtrl m_toolbar;
	UINT m_nResourceID;
	int m_nItems;
	TBBUTTON* m_pTBBtn;
	CUpdateUIBase* m_pUpdateUI;

	CSimpleArray<int> m_arrCmdID;

// Implementation helpers
	bool LoadTBBtns()
	{
		if (m_nResourceID != 0)
			_LoadTBBtns();
		else
			_LoadTBBtnsMtl();

		return true;
	}

	bool _LoadTBBtnsMtl()
	{
		if (m_arrCmdID.GetSize() == 0)
			return false;

		m_nItems = m_arrCmdID.GetSize();
		m_pTBBtn = new TBBUTTON[m_nItems];
		int nBmp = 0;
		int j = 0;
		for (int i = 0; i < m_nItems; ++i)
		{
			ATLASSERT(j < m_nItems);
			if(m_arrCmdID[i] != 0) {
				m_pTBBtn[j].iBitmap = nBmp++;
				m_pTBBtn[j].idCommand = m_arrCmdID[i];
				m_pTBBtn[j].fsState = TBSTATE_ENABLED;
				m_pTBBtn[j].fsStyle = TBSTYLE_BUTTON;
				m_pTBBtn[j].dwData = 0;
				m_pTBBtn[j].iString = 0;
			}
			else {
				m_pTBBtn[j].iBitmap = 8;
				m_pTBBtn[j].idCommand = 0;
				m_pTBBtn[j].fsState = 0;
				m_pTBBtn[j].fsStyle = TBSTYLE_SEP;
				m_pTBBtn[j].dwData = 0;
				m_pTBBtn[j].iString = 0;
			}
			++j;
		}

		return true;
	}

	bool _LoadTBBtns()
	{
		ATLASSERT(m_pTBBtn == NULL);

		HINSTANCE hInst = _Module.GetResourceInstance();
		HRSRC hRsrc = ::FindResource(hInst, MAKEINTRESOURCE(m_nResourceID), RT_TOOLBAR);
		if (hRsrc == NULL)
			return false;

		HGLOBAL hGlobal = ::LoadResource(hInst, hRsrc);
		if (hGlobal == NULL)
			return false;

		_AtlToolBarData* pData = (_AtlToolBarData*)::LockResource(hGlobal);
		if (pData == NULL)
			return false;
		ATLASSERT(pData->wVersion == 1);

		WORD* pItems = pData->items();
		m_nItems = pData->wItemCount;
		m_pTBBtn = new TBBUTTON[m_nItems];

		int nBmp = 0;
		for(int i = 0, j = 0; i < pData->wItemCount; i++, j++)
		{
			if(pItems[i] != 0)
			{
				m_pTBBtn[j].iBitmap = nBmp++;
				m_pTBBtn[j].idCommand = pItems[i];
				m_pTBBtn[j].fsState = TBSTATE_ENABLED;
				m_pTBBtn[j].fsStyle = TBSTYLE_BUTTON;
				m_pTBBtn[j].dwData = 0;
				m_pTBBtn[j].iString = 0;
			}
			else
			{
				m_pTBBtn[j].iBitmap = 8;
				m_pTBBtn[j].idCommand = 0;
				m_pTBBtn[j].fsState = 0;
				m_pTBBtn[j].fsStyle = TBSTYLE_SEP;
				m_pTBBtn[j].dwData = 0;
				m_pTBBtn[j].iString = 0;
			}
		}

		return true;
	}

	void _UnloadTBBtns()
	{
		m_nItems = 0;
		delete [] m_pTBBtn;
		m_pTBBtn = NULL;
	}

	void _RefreshBandInfo()
	{
		HWND hWndReBar = m_toolbar.GetParent();
		ATLASSERT(::IsWindow(hWndReBar));

		if (!MtlIsKindOf(hWndReBar, REBARCLASSNAME))
			return;
			
		CReBarCtrl rebar(hWndReBar);
		REBARBANDINFO rbBand;
		rbBand.cbSize = sizeof(REBARBANDINFO);
		rbBand.fMask = RBBIM_IDEALSIZE;

		// Calculate the size of the band
		int nBtnCount = m_toolbar.GetButtonCount();
		if(nBtnCount > 0)
		{
			RECT rcTmp;
			BOOL bRet = (BOOL)m_toolbar.GetItemRect(nBtnCount-1, &rcTmp);
			ATLASSERT(bRet);
			rbBand.cxIdeal = rcTmp.right;
			int nIndex = rebar.IdToIndex(m_toolbar.GetDlgCtrlID());
			rebar.SetBandInfo(nIndex, &rbBand);
		}
	}

	BOOL _UIUpdateToolBarFixed()
	{
		if (m_pUpdateUI == NULL)
			return FALSE;
			
		const CUpdateUIBase::_AtlUpdateUIMap* pMap = m_pUpdateUI->m_pUIMap;
		CUpdateUIBase::_AtlUpdateUIData* pUIData = m_pUpdateUI->m_pUIData;
		if(pUIData == NULL)
			return FALSE;

		while(pMap->m_nID != (WORD)-1)
		{
			for(int i = 0; i < m_pUpdateUI->m_UIElements.GetSize(); i++)
			{
				if(m_pUpdateUI->m_UIElements[i].m_wType == CUpdateUIBase::UPDUI_TOOLBAR)
				{
					if(pMap->m_wType & CUpdateUIBase::UPDUI_TOOLBAR)
						m_pUpdateUI->UIUpdateToolBarElement(pMap->m_nID, pUIData, m_pUpdateUI->m_UIElements[i].m_hWnd);
				}
			}
			pMap++;
			pUIData->m_wState &= ~CUpdateUIBase::UPDUI_TOOLBAR;
			pUIData++;
		}

		m_pUpdateUI->m_wDirtyType &= ~CUpdateUIBase::UPDUI_TOOLBAR;
		return TRUE;
	}

	CString _GetToolTipText(int idCtrl)
	{
		if(idCtrl != 0)
		{
			TCHAR szBuff[256];
			szBuff[0] = 0;
			int nRet = ::LoadString(_Module.GetResourceInstance(), idCtrl, szBuff, 256);
			for (int i = 0; i < nRet; i++)
			{
				if (szBuff[i] == _T('\n'))
				{
					return CString(&szBuff[i + 1]);
				}
			}
		}

		return CString();
	}
};

template <class T>
class CClipboardViewer
{
public:
// Data members
	HWND m_hWndNext;
	bool m_bFirst;
	bool m_bInitialUpdate;
	bool m_bSetClipboardViewer;

// Constructor
	CClipboardViewer()
		: m_hWndNext(NULL), m_bFirst(true), m_bInitialUpdate(false),
		  m_bSetClipboardViewer(false)
	{
	}

	~CClipboardViewer()
	{
		ATLASSERT(m_bSetClipboardViewer == false);
	}

	void InstallClipboardViewer(bool bInitialUpdate = false)
	{
		if (m_bSetClipboardViewer)
			return;

		T* pT = static_cast<T*>(this);
		m_bInitialUpdate = bInitialUpdate;
		m_hWndNext = ::SetClipboardViewer(pT->m_hWnd);
		m_bInitialUpdate = bInitialUpdate;

		m_bSetClipboardViewer = true;
	}

	void UninstallClipboardViewer()
	{
		if (!m_bSetClipboardViewer)
			return;

		T* pT = static_cast<T*>(this);
		::ChangeClipboardChain(pT->m_hWnd, m_hWndNext);
		m_hWndNext			= NULL;
		m_bFirst			= true;
		m_bInitialUpdate	= false;

		m_bSetClipboardViewer = false;
	}

// Overridables
	void OnUpdateClipboard()
	{
		ATLASSERT(FALSE);
	}

// Message map and handlers
	BEGIN_MSG_MAP(CClipboardViewer)
		MSG_WM_DRAWCLIPBOARD(OnDrawClipboard)
		MSG_WM_CHANGECBCHAIN(OnChangeCBChain)
		MSG_WM_DESTROY(OnDestroy)
	END_MSG_MAP()

	void OnDrawClipboard()
	{
		ATLTRACE2(atlTraceUser, 4, _T("CClipboardViewer::OnDrawClipboard\n"));
		T* pT = static_cast<T*>(this);
		
		if (m_hWndNext != NULL)
			::PostMessage(m_hWndNext, WM_DRAWCLIPBOARD, 0, 0);//!!Post!?
		
		if (m_bFirst) {				// first time
			if (m_bInitialUpdate) {	// callback
				pT->OnUpdateClipboard();
				m_bInitialUpdate = false;
			}
			m_bFirst = false;
		}
		else {
			pT->OnUpdateClipboard();
		}
	}

	void OnChangeCBChain(HWND hWndRemove, HWND hWndAfter)
	{
		ATLTRACE2(atlTraceUser, 4, _T("CClipboardViewer::OnChangeCBChain\n"));
		if (m_hWndNext == hWndRemove)
			m_hWndNext = hWndAfter;
		else if (m_hWndNext != NULL)// SendMessage if I'm not last
			::SendMessage(m_hWndNext, WM_CHANGECBCHAIN, (WPARAM)hWndRemove, (LPARAM)hWndAfter);
	}

	void OnDestroy()
	{
		SetMsgHandled(FALSE);
		UninstallClipboardViewer();
	}
};

inline void MtlDestroyImageLists(HWND hWndToolBar)
{
	ATLTRACE2(atlTraceUser, 4, _T("MtlDestroyImageList\n"));
	CToolBarCtrl toolbar(hWndToolBar);
	HIMAGELIST hImg = toolbar.GetImageList();
	if (hImg) {
		ATLTRACE2(atlTraceUser, 4, _T(" delete imagelist\n"));
		MTLVERIFY(ImageList_Destroy(hImg));
	}

	hImg = toolbar.GetHotImageList();
	if (hImg) {
		ATLTRACE2(atlTraceUser, 4, _T(" delete hot imagelist\n"));
		MTLVERIFY(ImageList_Destroy(hImg));
	}
}

// __nID == 0 then separator
HWND MtlCreateSimpleToolBarCtrl(HWND hWndParent, int* __firstID, int* __lastID,
	UINT nImageBmpID, UINT nHotImageBmpID, int cx, int cy, COLORREF clrMask, UINT nFlags = ILC_COLOR8,
	DWORD dwStyle = ATL_SIMPLE_TOOLBAR_PANE_STYLE, UINT nID = ATL_IDW_TOOLBAR)
{
		int nCount = __lastID - __firstID;
		if (nCount == 0)
			return NULL;

		CImageList imgs;
		MTLVERIFY(imgs.Create(cx, cy, nFlags | ILC_MASK, nCount, 1));

		CBitmap bmp;
		MTLVERIFY(bmp.LoadBitmap(nImageBmpID));
		imgs.Add(bmp, clrMask);


		CImageList imgsHot;
		MTLVERIFY(imgsHot.Create(cx, cy, nFlags | ILC_MASK, nCount, 1));

		CBitmap bmpHot;
		MTLVERIFY(bmpHot.LoadBitmap(nHotImageBmpID));
		imgsHot.Add(bmpHot, clrMask);


		TBBUTTON* pTBBtn = (TBBUTTON*)_alloca(nCount * sizeof(TBBUTTON));

		int nBmp = 0;
		int j = 0;
		for (; __firstID < __lastID; ++__firstID) {
			ATLASSERT(j < nCount);
			if(*__firstID != 0) {
				pTBBtn[j].iBitmap = nBmp++;
				pTBBtn[j].idCommand = *__firstID;
				pTBBtn[j].fsState = TBSTATE_ENABLED;
				pTBBtn[j].fsStyle = TBSTYLE_BUTTON;
				pTBBtn[j].dwData = 0;
				pTBBtn[j].iString = 0;
			}
			else {
				pTBBtn[j].iBitmap = 8;
				pTBBtn[j].idCommand = 0;
				pTBBtn[j].fsState = 0;
				pTBBtn[j].fsStyle = TBSTYLE_SEP;
				pTBBtn[j].dwData = 0;
				pTBBtn[j].iString = 0;
			}
			++j;
		}

		CToolBarCtrl toolbar = ::CreateWindowEx(0, TOOLBARCLASSNAME, NULL, dwStyle, 0,0,100,100,
				hWndParent, (HMENU)LongToHandle(nID), _Module.GetModuleInstance(), NULL);

		toolbar.SetButtonStructSize(sizeof(TBBUTTON));
		toolbar.AddButtons(nCount, pTBBtn);
		toolbar.SetImageList(imgs);
		toolbar.SetHotImageList(imgsHot);

		return toolbar.m_hWnd;
	}

#ifdef __ATLCTRLW_H__
BOOL MtlCmdBarLoadImages(CCommandBarCtrl& cmdbar, int* __firstID, int* __lastID,
	UINT nImageBmpID, int cx, int cy, COLORREF clrMask, UINT nFlags = ILC_COLOR8)
{
	// Add bitmap to our image list (create it if it doesn't exist)
	int nCount = __lastID - __firstID;
	if (nCount == 0)
		return FALSE;

	if(cmdbar.m_hImageList == NULL)
	{
		cmdbar.m_hImageList = ::ImageList_Create(cx, cy, nFlags | ILC_MASK, nCount, 1);
		ATLASSERT(cmdbar.m_hImageList != NULL);
		if(cmdbar.m_hImageList == NULL)
			return FALSE;
	}

	CBitmap bmp;
	bmp.LoadBitmap(nImageBmpID);
	ATLASSERT(bmp.m_hBitmap != NULL);
	if(bmp.m_hBitmap == NULL)
		return FALSE;
	if(::ImageList_AddMasked(cmdbar.m_hImageList, bmp, cmdbar.m_clrMask = clrMask) == -1)
		return FALSE;

	// Fill the array with command IDs
	for (; __firstID < __lastID; ++__firstID) {
		if(*__firstID != 0)
			cmdbar.m_arrCommand.Add(*__firstID);
	}

	ATLASSERT(::ImageList_GetImageCount(cmdbar.m_hImageList) == cmdbar.m_arrCommand.GetSize());
	if(::ImageList_GetImageCount(cmdbar.m_hImageList) != cmdbar.m_arrCommand.GetSize())
		return FALSE;

	// Set some internal stuff
	cmdbar.m_szBitmap.cx = cx;
	cmdbar.m_szBitmap.cy = cy;
	cmdbar.m_szButton.cx = cmdbar.m_szBitmap.cx + 2 * CCommandBarCtrl::s_kcxButtonMargin;
	cmdbar.m_szButton.cy = cmdbar.m_szBitmap.cy + 2 * CCommandBarCtrl::s_kcyButtonMargin;

	return TRUE;
}
#endif

////////////////////////////////////////////////////////////////////////////
// Mouse Wheel Support for Windows 95 or Windows NT 3.51

class CMSMouseWheelMessageHandlerBase
{
public:
	DECLARE_REGISTERED_MESSAGE(MSWHEEL_ROLLMSG)
};

template <class T>
class CMSMouseWheelMessageHandler : public CMSMouseWheelMessageHandlerBase
{
public:
	BEGIN_MSG_MAP(CMSMouseWheelMessageHandler<T>)
		MESSAGE_HANDLER(GET_REGISTERED_MESSAGE(MSWHEEL_ROLLMSG), OnRegisteredMouseWheel)
	END_MSG_MAP()

	LRESULT OnRegisteredMouseWheel(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{// pasted from MFC6
		// convert from MSH_MOUSEWHEEL to WM_MOUSEWHEEL

		WORD keyState = 0;
		keyState |= (::GetKeyState(VK_CONTROL) < 0) ? MK_CONTROL : 0;
		keyState |= (::GetKeyState(VK_SHIFT) < 0) ? MK_SHIFT : 0;

		LRESULT lResult;
		HWND hwFocus = ::GetFocus();
		const HWND hwDesktop = ::GetDesktopWindow();

		if (hwFocus == NULL)
		{
			T* pT = static_cast<T*>(this);
			lResult = pT->SendMessage(WM_MOUSEWHEEL, (wParam << 16) | keyState, lParam);
		}
		else
		{
			do {
				lResult = ::SendMessage(hwFocus, WM_MOUSEWHEEL,
					(wParam << 16) | keyState, lParam);
				hwFocus = ::GetParent(hwFocus);
			}
			while (lResult == 0 && hwFocus != NULL && hwFocus != hwDesktop);
		}
		return lResult;
	}
};

////////////////////////////////////////////////////////////////////////////
// MDI main frame Title changer
//  but I've found there is no easy way to change task bar's text if MDI...

template <class T>
class CMDIFrameTitleUpsideDownMessageHandler
{
public:
// Data members
	bool m_bValid;

// Constructor
	CMDIFrameTitleUpsideDownMessageHandler() : m_bValid(true) { }