stdtoolbarctrl.h

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

		if (dwStyleOld != m_dwStdToolBarStyle) {
			StdToolBar_UpdateImageList();
			StdToolBar_UpdateStyle();
			_UpdateBandInfo(m_hWnd);
		}
		else if (bForceUpdateStyle) {
			StdToolBar_UpdateStyle();	// for BTNS_STD_LIST
			_UpdateBandInfo(m_hWnd);
		}
	}

	DWORD StdToolBar_GetStyle() const
	{
		return m_dwStdToolBarStyle;
	}

	bool StdToolBar_TrackDropDownMenu(int nCmdID, HMENU hMenu, HWND hWndOwner)
	{
		CRect rc;
		GetItemRect(CommandToIndex(nCmdID), &rc);
		ClientToScreen(&rc);
		UINT uMenuFlags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_VERTICAL | TPM_LEFTALIGN | TPM_TOPALIGN | (!AtlIsOldWindows() ? TPM_VERPOSANIMATION : 0);
		TPMPARAMS TPMParams;
		TPMParams.cbSize = sizeof(TPMPARAMS);
		TPMParams.rcExclude = rc;

		return (::TrackPopupMenuEx(hMenu, uMenuFlags, rc.left, rc.bottom, hWndOwner, &TPMParams) == TRUE);
	}

	void StdToolBar_Customize()
	{
		CStdToolBarAdditionalCustomizeDlg dlg;

		dlg.Install(m_dwStdToolBarStyle, m_hWnd);

		Customize();

		StdToolBar_SetStyle(dlg.m_dwStdToolBarStyle, true);
	}

// Implementation
	bool StdToolBar_UpdateStyle()
	{
		if (_check_flag(STD_TBSTYLE_HIDELABEL, m_dwStdToolBarStyle))
			_StdToolBar_HideLabel(m_hWnd);
		else if (_check_flag(STD_TBSTYLE_SHOWLABEL, m_dwStdToolBarStyle))
			_StdToolBar_ShowLabel(m_hWnd, _begin(m_arrStdBtn), _end(m_arrStdBtn));
		else if (_check_flag(STD_TBSTYLE_SHOWLABELRIGHT, m_dwStdToolBarStyle))
			_StdToolBar_ShowLabelRight(m_hWnd, _begin(m_arrStdBtn), _end(m_arrStdBtn));
		else
			ATLASSERT(FALSE);

		return true;
	}

	bool StdToolBar_UpdateImageList()
	{
		if (!StdToolBar_IsImageListNeedUpdate())
			return false;

		StdToolBar_DestroyImageList();
			
		int nCount = StdToolBar_GetIconCount();
		CBitmap bmp, bmpHot;
		CImageList imgs, imgsHot;

		if (_check_flag(STD_TBSTYLE_SMALLICON, m_dwStdToolBarStyle))
		{
			MTLVERIFY( bmp.LoadBitmap(m_bmpIDSmall.first) );
			MTLVERIFY( imgs.Create(m_sizeSmall.cx, m_sizeSmall.cy, m_nFlags | ILC_MASK, nCount, 1) );
			MTLVERIFY( imgs.Add(bmp, m_clrMask) != -1 );

			MTLVERIFY( bmpHot.LoadBitmap(m_bmpIDSmall.second) );
			MTLVERIFY( imgsHot.Create(m_sizeSmall.cx, m_sizeSmall.cy, m_nFlags | ILC_MASK, nCount, 1));		
			MTLVERIFY( imgsHot.Add(bmpHot, m_clrMask) != -1 );
		}
		else if (_check_flag(STD_TBSTYLE_LARGEICON, m_dwStdToolBarStyle))
		{
			MTLVERIFY( bmp.LoadBitmap(m_bmpIDLarge.first) );
			MTLVERIFY( imgs.Create(m_sizeLarge.cx, m_sizeLarge.cy, m_nFlags | ILC_MASK, nCount, 1) );
			MTLVERIFY( imgs.Add(bmp, m_clrMask) != -1 );

			MTLVERIFY( bmpHot.LoadBitmap(m_bmpIDLarge.second) );
			MTLVERIFY( imgsHot.Create(m_sizeLarge.cx, m_sizeLarge.cy, m_nFlags | ILC_MASK, nCount, 1));		
			MTLVERIFY( imgsHot.Add(bmpHot, m_clrMask) != -1 );
		}
		else 
			ATLASSERT(FALSE);

		SetImageList(imgs);
		SetHotImageList(imgsHot);

		return true;
	}

	void StdToolBar_DestroyImageList()
	{
		CImageList imgsOld = GetImageList();
		SetImageList(NULL);
		imgsOld.Destroy();
		CImageList imgsHotOld = GetHotImageList();
		SetHotImageList(NULL);
		imgsHotOld.Destroy();
	}

	bool StdToolBar_IsImageListNeedUpdate()
	{
		CImageList imgs = GetImageList();
		if (imgs.IsNull())
			return true;

		CSize size;
		imgs.GetIconSize(size);

		if (_check_flag(STD_TBSTYLE_SMALLICON, m_dwStdToolBarStyle) && size == m_sizeSmall)
			return false;
		else if (_check_flag(STD_TBSTYLE_LARGEICON, m_dwStdToolBarStyle) && size == m_sizeLarge)
			return false;
		else
			return true;
	}

// Message map and handlers
	BEGIN_MSG_MAP(CStdToolBarCtrlImpl)
		MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDblClk)
		MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
		REFLECTED_NOTIFY_CODE_HANDLER(TBN_DROPDOWN, OnDropDown)
		CHAIN_MSG_MAP(CCustomizableStdToolBarHandler<T>)
	END_MSG_MAP()

	LRESULT OnLButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{
		LRESULT lRet = 0;
		CPoint pt( GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
		
		int nIndex = HitTest(&pt);
		if (nIndex < 0) {
			StdToolBar_Customize();
		}
		else {
			bHandled = FALSE;
		}

		return lRet;
	}

	LRESULT OnDropDown(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
	{
		LPNMTOOLBAR lpnmtb = (LPNMTOOLBAR)pnmh;
		int nCmdID = lpnmtb->iItem;

		USES_PT;
		return pT->StdToolBar_OnDropDown(nCmdID);
	}

	LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
	{
		bHandled = FALSE;

		StdToolBar_Term();
		
		return 1;
	}
/*
	void _WriteProfile()
	{
		CIniSection pr;
		pr.Open(_T("B:\\Document\\MyProjects\\tb_demo\\Debug\\tb.ini"), _T("ToolBar"));
		
		MtlWriteProfileTBBtns(pr, m_hWnd);
		pr.SetValue(m_dwStdToolBarStyle, _T("Std_ToolBar_Style"));
	}

	void _GetProfile()
	{
		CIniSection pr;
		pr.Open(_T("B:\\Document\\MyProjects\\tb_demo\\Debug\\tb.ini"), _T("ToolBar"));
		
		CSimpleArray<int> arrBmpIndex;
		if (MtlGetProfileTBBtns(pr, arrBmpIndex))
			StdToolBar_InitButtons(_begin(arrBmpIndex), _end(arrBmpIndex));
		else
			StdToolBar_InitButtons(_begin(m_arrBmpDefaultIndex), _end(m_arrBmpDefaultIndex));

		DWORD dwStyle = STD_TBSTYLE_DEFAULT;
		pr.QueryValue(dwStyle, _T("Std_ToolBar_Style"));

		StdToolBar_SetStyle(dwStyle);
	}
*/
};

/////////////////////////////////////////////////////////////////////////////
// CCustomizableStdToolBarHandler

template <class T>
class CCustomizableStdToolBarHandler
{
public:
// Data members
	TBBUTTON* m_pTBBtn; // on demand
	int m_nItems;
// Ctor
	CCustomizableStdToolBarHandler() : m_pTBBtn(NULL), m_nItems(0) { }

// Overridable
	void OnTbnCustHelp()
	{
		// you can override to deal with HELP.	
	}

// Message map and handlers
	BEGIN_MSG_MAP(CCustomizableStdToolBarHandler)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_BEGINADJUST, OnTbnBeginAdjust)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_ENDADJUST, OnTbnEndAdjust)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_QUERYINSERT, OnTbnQueryInsert)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_QUERYDELETE, OnTbnQueryDelete)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_GETBUTTONINFO, OnTbnGetButtonInfo)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_TOOLBARCHANGE, OnTbnToolBarChange)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_RESET, OnTbnReset)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_CUSTHELP, OnTbnCustHelp)
//		NOTIFY_HANDLER_EX(m_toolbar.GetDlgCtrlID(), TBN_BEGINDRAG, OnTbnBeginDrag)
//		NOTIFY_HANDLER_EX(m_toolbar.GetDlgCtrlID(), TBN_ENDDRAG, OnTbnEndDrag)
	END_MSG_MAP()

	LRESULT OnTbnBeginAdjust(LPNMHDR pnmh)
	{
		_CreateTBBtns();
		return 0;
	}

	LRESULT OnTbnEndAdjust(LPNMHDR pnmh)
	{
		_DestroyTBBtns();	
		T* pT = static_cast<T*>(this);

//		pT->StdToolBar_UpdateStyle();// make sure
		
//		CStdToolBarCtrlBase::_UpdateBandInfo(pT->m_hWnd);
		return 0;
	}

	LRESULT OnTbnQueryInsert(LPNMHDR pnmh)
	{
		return TRUE;
	}

	LRESULT OnTbnQueryDelete(LPNMHDR pnmh)
	{
		return TRUE;
	}

	LRESULT OnTbnGetButtonInfo(LPNMHDR pnmh)
	{
		ATLASSERT(m_pTBBtn != NULL);
		T* pT = static_cast<T*>(this);

		LPNMTOOLBAR lpnmtb = (LPNMTOOLBAR)pnmh; 

		// Note. If over IE5.01, I guess this is the best way to call
		// 	     CStdToolBarCtrlBase::StdToolBar_AddStrings(pT->m_hWnd, _begin(arrStdBtn), _end(arrStdBtn));
		//       I can't understand the relation between lpnmtb->pszText and lpnmtb->tbButton.iString.
		if (lpnmtb->iItem < m_nItems) {

//			if (_check_flag(STD_TBSTYLE_HIDELABEL, pT->StdToolBar_GetStyle()))
//			{
				lpnmtb->pszText[0] = 0;

				CString strText;
				if (CStdToolBarCtrlBase::_LoadToolTipText(m_pTBBtn[lpnmtb->iItem].idCommand, strText)) {
					// I don't know the buffer size of lpnmtb->pszText...
					strText = strText.Left(30);
					::lstrcpy(lpnmtb->pszText, strText);
				}
//			}

			lpnmtb->tbButton = m_pTBBtn[lpnmtb->iItem];
			
			return TRUE;
		}
		else
			return FALSE;
	}

	LRESULT OnTbnToolBarChange(LPNMHDR pnmh)
	{
		T* pT = static_cast<T*>(this);
		CStdToolBarCtrlBase::_UpdateBandInfo(pT->m_hWnd);

		return 0;
	}

	LRESULT OnTbnReset(LPNMHDR pnmh)
	{
		ATLASSERT(m_pTBBtn != NULL);
		T* pT = static_cast<T*>(this);
		pT->StdToolBar_Reset();
		return 0;
	}

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

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

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

// Implementation helpers
	bool _CreateTBBtns()
	{
		ATLASSERT(m_pTBBtn == NULL);

		T* pT = static_cast<T*>(this);
		CSimpleArray<STD_TBBUTTON>& arrStdBtn = pT->m_arrStdBtn;
		m_pTBBtn = CStdToolBarCtrlBase::_MakeFullTBBtns(_begin(arrStdBtn), _end(arrStdBtn), true);
		if (m_pTBBtn == NULL)
			return false;

		m_nItems = arrStdBtn.GetSize();

		return true;
	}

	void _DestroyTBBtns()
	{
		T* pT = static_cast<T*>(this);

		delete [] m_pTBBtn;
		m_pTBBtn = NULL;
		m_nItems = 0;
	}
};

/////////////////////////////////////////////////////////////////////////////
// Adding the special form to the toolbar's customize dialog

class CStdToolBarAdditionalCustomizeDlg :
	public CInitDialogImpl<CStdToolBarAdditionalCustomizeDlg>,
	public CWinDataExchange<CStdToolBarAdditionalCustomizeDlg>
{
public:
	enum { IDD = IDD_FORM_TOOLBAR };
	typedef CInitDialogImpl<CStdToolBarAdditionalCustomizeDlg> baseClass;

// Data members
	static HHOOK s_hCreateHook;
	static CStdToolBarAdditionalCustomizeDlg* s_pThis;

	CContainedWindow m_wndParentDlg;
	CContainedWindow m_wndToolBar;

	CSize m_sizeDlg;
	DWORD m_dwStdToolBarStyle;
	int m_nIcon, m_nText;

// Ctor/Dtor
	CStdToolBarAdditionalCustomizeDlg() : m_wndParentDlg(this, 1), m_wndToolBar(this, 2) { }

	~CStdToolBarAdditionalCustomizeDlg()
	{
		if (m_wndParentDlg.IsWindow())
			m_wndParentDlg.UnsubclassWindow();

		if (m_wndToolBar.IsWindow())
			m_wndToolBar.UnsubclassWindow();
	}
// Methods
	void Install(DWORD dwStyle, HWND hWndToolBar)
	{
		m_wndToolBar.SubclassWindow(hWndToolBar);

		::EnterCriticalSection(&_Module.m_csWindowCreate);

		ATLASSERT(s_hCreateHook == NULL);

		s_pThis = this;
		m_dwStdToolBarStyle = dwStyle;

		s_hCreateHook = ::SetWindowsHookEx(WH_CBT, _CreateHookProc, _Module.GetModuleInstance(), GetCurrentThreadId());
		ATLASSERT(s_hCreateHook != NULL);
	}

	void Uninstall()
	{
		::UnhookWindowsHookEx(s_hCreateHook);
		s_hCreateHook = NULL;
		s_pThis = NULL;

		::LeaveCriticalSection(&_Module.m_csWindowCreate);
	}

	void _Setup(HWND hWndDlg)
	{
		// uninstall here! otherwize, it will be hanged up.
		Uninstall();

		if (m_wndParentDlg.m_hWnd == NULL) {
			Create(hWndDlg);
			m_wndParentDlg.SubclassWindow(hWndDlg);
			ATLASSERT(::IsWindow(m_hWnd));
		}
	}

// Implementation - Hook procs
	static LRESULT CALLBACK _CreateHookProc(int nCode, WPARAM wParam, LPARAM lParam)
	{
		LRESULT lRet = 0;
		TCHAR szClassName[7];

		if(nCode == HCBT_CREATEWND)
		{
			HWND hWndDlg = (HWND)wParam;
			::GetClassName(hWndDlg, szClassName, 7);
			if(!lstrcmp(_T("#32770"), szClassName)) {
				stbTRACE(_T(" Customize dialog found!!\n"));
				s_pThis->_Setup(hWndDlg);
			}
		}
		else if(nCode < 0)
		{
			lRet = ::CallNextHookEx(s_hCreateHook, nCode, wParam, lParam);
		}
		return lRet;
	}

// Message map and handlers
	BEGIN_MSG_MAP(CStdToolBarAdditionalCustomizeDlg)
		MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
		MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
	ALT_MSG_MAP(1) // original dlg
		MESSAGE_HANDLER(WM_INITDIALOG, OnParentInitDialog)
	ALT_MSG_MAP(2)
		REFLECTED_NOTIFY_CODE_HANDLER_EX(TBN_RESET, OnTbnReset)		
	END_MSG_MAP()

	LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
	{
		stbTRACE(_T("OnInitDialog\n"));
		bHandled = FALSE;

		CRect rc;
		GetClientRect(&rc);
		m_sizeDlg = CSize(rc.Width(), rc.Height());

		ExecuteDlgInit();
		_SetData();

		return TRUE;
	}

	LRESULT OnParentInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
	{
		stbTRACE(_T("OnParentInitDialog\n"));
		
		LRESULT lRet = m_wndParentDlg.DefWindowProc(uMsg, wParam, lParam);

		CRect rcParent; m_wndParentDlg.GetWindowRect(&rcParent);
		CRect rcClient; m_wndParentDlg.GetClientRect(&rcClient);

		rcParent.bottom += m_sizeDlg.cy;
		m_wndParentDlg.MoveWindow(&rcParent);

		MoveWindow(0, rcClient.Height(), m_sizeDlg.cx, m_sizeDlg.cy);
		ShowWindow(SW_SHOWNORMAL);

		// now no need.
		m_wndParentDlg.UnsubclassWindow();

		return lRet;
	}

	LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
	{
		stbTRACE(_T("OnDestroy\n"));
		_GetData();
		return 0;
	}

	LRESULT OnTbnReset(LPNMHDR pnmh)
	{
		SetMsgHandled(FALSE);
		m_dwStdToolBarStyle = STD_TBSTYLE_DEFAULT;
		_SetData();
		return 0;
	}
	
	BEGIN_DDX_MAP(CStdToolBarAdditionalCustomizeDlg)
		DDX_CBINDEX(IDC_COMBO_STDTB_TEXT, m_nText)		
		DDX_CBINDEX(IDC_COMBO_STDTB_ICON, m_nIcon)
	END_DDX_MAP()

	void _GetData()
	{
		DoDataExchange(TRUE);
			
		m_dwStdToolBarStyle = 0;

		if (m_nText == 0)
			m_dwStdToolBarStyle |= STD_TBSTYLE_SHOWLABEL;
		else if (m_nText == 1)
			m_dwStdToolBarStyle |= STD_TBSTYLE_SHOWLABELRIGHT;
		else if (m_nText == 2)
			m_dwStdToolBarStyle |= STD_TBSTYLE_HIDELABEL;

		if (m_nIcon == 0)
			m_dwStdToolBarStyle |= STD_TBSTYLE_SMALLICON;
		else if (m_nIcon == 1)
			m_dwStdToolBarStyle |= STD_TBSTYLE_LARGEICON;
	}

	void _SetData()
	{
		if (_check_flag(STD_TBSTYLE_HIDELABEL, m_dwStdToolBarStyle))
			m_nText = 2;
		else if (_check_flag(STD_TBSTYLE_SHOWLABEL, m_dwStdToolBarStyle))
			m_nText = 0;
		else if (_check_flag(STD_TBSTYLE_SHOWLABELRIGHT, m_dwStdToolBarStyle))
			m_nText = 1;
		else
			ATLASSERT(FALSE);

		if (_check_flag(STD_TBSTYLE_SMALLICON, m_dwStdToolBarStyle))
			m_nIcon = 0;
		else if (_check_flag(STD_TBSTYLE_LARGEICON, m_dwStdToolBarStyle))
			m_nIcon = 1;
		else
			ATLASSERT(FALSE);

		DoDataExchange(FALSE);
	}
};

__declspec(selectany) HHOOK CStdToolBarAdditionalCustomizeDlg::s_hCreateHook = NULL;
__declspec(selectany) CStdToolBarAdditionalCustomizeDlg* CStdToolBarAdditionalCustomizeDlg::s_pThis = NULL;

class CStdToolBarCtrl : public CStdToolBarCtrlImpl<CStdToolBarCtrl>
{
public:
	DECLARE_WND_SUPERCLASS(_T("MTL_StdToolBar"), GetWndClassName())
};