mtlbrowser.h

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

		CComVariant vFlags((long) dwFlags);

		// for stupid Mozilla
		if (lpszHeaders)
			vHeaders = lpszHeaders;
		if (lpszTargetFrameName)
			vTargetFrameName = lpszTargetFrameName;

		m_spBrowser->Navigate(bstrURL,
			&vFlags,
			&vTargetFrameName,
			vPostData,
			&vHeaders);
	}

	void Navigate2(LPITEMIDLIST pIDL, DWORD dwFlags = 0,
		LPCTSTR lpszTargetFrameName = NULL)
	{
		ATLASSERT(m_spBrowser != NULL);

		CComVariant vPIDL; MtlInitVariantFromItemIDList(vPIDL, pIDL);
		CComVariant empty;
		CComVariant vTargetFrameName(lpszTargetFrameName);
		CComVariant vFlags((long)dwFlags);

		m_spBrowser->Navigate2(&vPIDL,
			&vFlags,
			&vTargetFrameName,
			&empty, &empty);
	}

	void Navigate2(LPCTSTR lpszURL, DWORD dwFlags = 0,
		LPCTSTR lpszTargetFrameName = NULL,
		LPCTSTR lpszHeaders = NULL,
		LPVOID lpvPostData = NULL, DWORD dwPostDataLen = 0)
	{
		ATLASSERT(m_spBrowser != NULL);

		CComSafeArray vPostData;
		if (lpvPostData != NULL)
		{
			if (dwPostDataLen == 0)
				dwPostDataLen = lstrlen((LPCTSTR) lpvPostData);

			vPostData.CreateOneDim(VT_UI1, dwPostDataLen, lpvPostData);
		}

		CComVariant vURL;
		CComVariant vHeaders;
		CComVariant vTargetFrameName;
		CComVariant vFlags((long) dwFlags);

		// for stupid Mizilla
		if (lpszURL)
			vURL = lpszURL;
		if (lpszHeaders)
			vHeaders = lpszHeaders;
		if (lpszTargetFrameName)
			vTargetFrameName = lpszTargetFrameName;

		m_spBrowser->Navigate2(&vURL,
			&vFlags, &vTargetFrameName, &vPostData, &vHeaders);
	}

	void Navigate2(LPCTSTR lpszURL, DWORD dwFlags,
		CSimpleArray<BYTE>& baPostData, LPCTSTR lpszTargetFrameName = NULL,
		LPCTSTR lpszHeaders = NULL)
	{
		ATLASSERT(m_spBrowser != NULL);

		CComVariant vPostData; MtlInitVariantFromArray(vPostData, baPostData);
		CComVariant vURL;
		CComVariant vHeaders;
		CComVariant vTargetFrameName;
		CComVariant vFlags((long) dwFlags);

		// for stupid Mozilla
		if (lpszURL)
			vURL = lpszURL;
		if (lpszHeaders)
			vHeaders = lpszHeaders;
		if (lpszTargetFrameName)
			vTargetFrameName = lpszTargetFrameName;

		m_spBrowser->Navigate2(&vURL, &vFlags, &vTargetFrameName,
			&vPostData, &vHeaders);
	}

	void PutProperty(LPCTSTR lpszProperty, const VARIANT& vtValue)
	{
		ATLASSERT(m_spBrowser != NULL);

		CComBSTR bstrProp(lpszProperty);
		m_spBrowser->PutProperty(bstrProp, vtValue);
	}

	bool GetProperty(LPCTSTR lpszProperty, CString& strValue)
	{
		ATLASSERT(m_spBrowser != NULL);

		CComBSTR bstrProperty(lpszProperty);

		bool bResult = false;
		CComVariant vReturn;
		vReturn.vt = VT_BSTR;
		vReturn.bstrVal = NULL;
		HRESULT hr = m_spBrowser->GetProperty(bstrProperty, &vReturn);

		if (SUCCEEDED(hr))
		{
			strValue = CString(vReturn.bstrVal);
			bResult = true;
		}

		return bResult;
	}

	CComVariant GetProperty(LPCTSTR lpszProperty)
	{
		ATLASSERT(m_spBrowser != NULL);

		CComVariant result;
		CComQIPtr<IDispatch> spDisp = m_spBrowser;

		CComDispatchDriver::GetProperty(spDisp, 0x12f, &result);
		return result;

//		static BYTE parms[] = VTS_BSTR;
//		m_wndBrowser.InvokeHelper(0x12f, DISPATCH_METHOD,
//			VT_VARIANT, (void*)&result, parms, lpszProperty);
	}

	CString GetFullName() const
	{
		ATLASSERT(m_spBrowser != NULL);

		CComBSTR bstr;
		m_spBrowser->get_FullName(&bstr);
		CString retVal(bstr);
		return retVal;
	}
};

/////////////////////////////////////////////////////////////////////////////
// IWebBrowserEvents2
class IWebBrowserEvents2Base
{
public:
	static _ATL_FUNC_INFO StatusTextChangeInfo;
	static _ATL_FUNC_INFO DownloadBeginInfo ;
	static _ATL_FUNC_INFO NewWindow2Info; 
	static _ATL_FUNC_INFO CommandStateChangeInfo;
	static _ATL_FUNC_INFO BeforeNavigate2Info;
	static _ATL_FUNC_INFO ProgressChangeInfo;
	static _ATL_FUNC_INFO NavigateComlete2Info;
	static _ATL_FUNC_INFO OnVisibleInfo;
};

__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::StatusTextChangeInfo = {CC_STDCALL, VT_EMPTY, 1, {VT_BSTR}};
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::DownloadBeginInfo = {CC_STDCALL, VT_EMPTY, 0, {NULL}};
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::NewWindow2Info = {CC_STDCALL, VT_EMPTY, 2, {VT_BYREF|VT_BOOL,VT_BYREF|VT_DISPATCH}}; 
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::CommandStateChangeInfo = {CC_STDCALL, VT_EMPTY, 2, {VT_I4,VT_BOOL}};
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::BeforeNavigate2Info = {CC_STDCALL, VT_EMPTY, 7,
	{VT_DISPATCH,VT_BYREF|VT_VARIANT,VT_BYREF|VT_VARIANT,VT_BYREF|VT_VARIANT,VT_BYREF|VT_VARIANT,VT_BYREF|VT_VARIANT,VT_BYREF|VT_BOOL}};
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::ProgressChangeInfo = {CC_STDCALL, VT_EMPTY, 2, {VT_I4,VT_I4}};
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::NavigateComlete2Info = {CC_STDCALL, VT_EMPTY, 2, {VT_DISPATCH, VT_BYREF|VT_VARIANT}};
__declspec(selectany) _ATL_FUNC_INFO IWebBrowserEvents2Base::OnVisibleInfo = {CC_STDCALL, VT_EMPTY, 1, {VT_BOOL}};

template <class T, UINT nID>
class IWebBrowserEvents2Impl :
	public IDispEventSimpleImpl<nID, IWebBrowserEvents2Impl, &DIID_DWebBrowserEvents2>,
	public IWebBrowserEvents2Base
{
public:
	typedef IWebBrowserEvents2Impl<T, nID> thisClass;

// Constructor
	IWebBrowserEvents2Impl()
		: m_nDownloadCounter(0)
	{
	}

// Methods
	void WebBrowserEvents2Advise()
	{
		T* pT = static_cast<T*>(this);
		DispEventAdvise(pT->m_spBrowser, &DIID_DWebBrowserEvents2);
	}

	void WebBrowserEvents2Unadvise()
	{
		T* pT = static_cast<T*>(this);
		DispEventUnadvise(pT->m_spBrowser, &DIID_DWebBrowserEvents2);
	}

	bool IsPageIWebBrowser(IDispatch* pDisp)
	{//Knowledge Base Q180366
		T* pT = static_cast<T*>(this);

		CComPtr<IDispatch> spDispatch;
		HRESULT hr = pT->m_spBrowser->QueryInterface(IID_IDispatch, (void**)&spDispatch);
		if (FAILED(hr))
			return false;

		if (pDisp == spDispatch.p)// Top-level Window object
			return true;
		else
			return false;

//		return pT->m_spBrowser.IsEqualObject(pDisp); I guess this is right...
	}

	static bool IsRefreshBeforeNavigate2(IDispatch* pDisp)
	{// Implemented by fub, thanks.
		CComQIPtr<IWebBrowser2> spBrowser = pDisp;
		if (!spBrowser)
			return false;

		CComBSTR bstr;
		spBrowser->get_LocationURL(&bstr);
		CString str(bstr);

		if (str.IsEmpty() || str == _T("about:blank"))
			return true;
		else
			return false;
	}

// Overridables
	void OnStatusTextChange(const CString& strText) { }
	void OnProgressChange(long progress, long progressMax) { }
	void OnCommandStateChange(long Command, bool bEnable) { }
	void OnDownloadBegin() { }
	void OnDownloadComplete() { }
	void OnTitleChange(const CString& strTitle) { }
	void OnNavigateComplete2(IDispatch* pDisp, const CString& strURL) { }
	void OnBeforeNavigate2(IDispatch* pDisp, const CString& strURL, DWORD nFlags,
		const CString& strTargetFrameName, CSimpleArray<BYTE>& baPostedData, const CString& strHeaders, bool& bCancel) { }
	void OnPropertyChange(const CString& strProperty) { }
	void OnNewWindow2(IDispatch** ppDisp, bool& bCancel) { }
	void OnDocumentComplete(IDispatch* pDisp, const CString& strURL) { }
	void OnQuit() { }
	void OnVisible(bool bVisible) { }
	void OnToolBar(bool bToolBar) { }
	void OnMenuBar(bool bMenuBar) { }
	void OnStatusBar(bool bStatusBar) { }
	void OnFullScreen(bool bFullScreen) { }
	void OnTheaterMode(bool bTheaterMode) { }

// For downloading state
	int m_nDownloadCounter;

	void OnStateConnecting() { }
	void OnStateDownloading() { }
	void OnStateCompleted() { }

// Sink map and event handlers
	BEGIN_SINK_MAP(thisClass)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 102, __StatusTextChange, &StatusTextChangeInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 108, __ProgressChange, &ProgressChangeInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 105, __CommandStateChange, &CommandStateChangeInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 106, __DownloadBegin, &DownloadBeginInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 104, __DownloadComplete, &DownloadBeginInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 113, __TitleChange, &StatusTextChangeInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 252, __NavigateComplete2, &NavigateComlete2Info)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 250, __BeforeNavigate2, &BeforeNavigate2Info)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 112, __PropertyChange, &StatusTextChangeInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 251, __NewWindow2, &NewWindow2Info)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 259, __DocumentComplete, &NavigateComlete2Info)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 253, __OnQuit, &DownloadBeginInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 254, __OnVisible, &OnVisibleInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 255, __OnToolBar, &OnVisibleInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 256, __OnMenuBar, &OnVisibleInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 257, __OnStatusBar, &OnVisibleInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 258, __OnFullScreen, &OnVisibleInfo)
		SINK_ENTRY_INFO(nID, DIID_DWebBrowserEvents2, 260, __OnTheaterMode, &OnVisibleInfo)
	END_SINK_MAP()

	void __stdcall __StatusTextChange(/*[in]*/ BSTR bstrText)
	{
		T* pT = static_cast<T*>(this);
		CString strStatusBar(bstrText);
		pT->OnStatusTextChange(strStatusBar);
	}

	void __stdcall __ProgressChange(/*[in]*/ long progress, /*[in]*/ long progressMax)
	{
		T* pT = static_cast<T*>(this);
		pT->OnProgressChange(progress, progressMax);
	}

	void __stdcall __CommandStateChange(/*[in]*/ long Command, /*[in]*/ VARIANT_BOOL Enable)
	{
		T* pT = static_cast<T*>(this);
		bool bEnable = (Enable == VARIANT_TRUE) ? true : false;
		pT->OnCommandStateChange(Command, bEnable);
	}

	void __stdcall __DownloadBegin()
	{
		T* pT = static_cast<T*>(this);
		pT->OnDownloadBegin();

		if (m_nDownloadCounter++ == 0)
			pT->OnStateConnecting();	// yes, connecting
	}

	void __stdcall __DownloadComplete()
	{
		T* pT = static_cast<T*>(this);
		pT->OnDownloadComplete();

		if (--m_nDownloadCounter == 0)
			pT->OnStateCompleted();		// complete!
	}
	
	void __stdcall __TitleChange(/*[in]*/ BSTR bstrText)
	{
		CString strTitle(bstrText);
		T* pT = static_cast<T*>(this);
		pT->OnTitleChange(strTitle);
	}
	
	void __stdcall __NavigateComplete2(/*[in]*/ IDispatch* pDisp, /*[in]*/ VARIANT* URL)
	{
		ATLASSERT(V_VT(URL) == VT_BSTR);

		CString strURL = V_BSTR(URL);
		T* pT = static_cast<T*>(this);
		pT->OnNavigateComplete2(pDisp, strURL);

		if (m_nDownloadCounter > 0)
			pT->OnStateDownloading();
	}
	
	void __stdcall __BeforeNavigate2(/*[in]*/ IDispatch* pDisp, /*[in]*/ VARIANT* URL, /*[in]*/ VARIANT* Flags, 
		/*[in]*/ VARIANT* TargetFrameName, /*[in]*/ VARIANT* PostData, /*[in]*/ VARIANT* Headers, 
		/*[out]*/ VARIANT_BOOL* Cancel)
	{
		ATLASSERT(V_VT(URL) == VT_BSTR);
		ATLASSERT(V_VT(TargetFrameName) == VT_BSTR);
		ATLASSERT(V_VT(PostData) == (VT_VARIANT | VT_BYREF));
		ATLASSERT(V_VT(Headers) == VT_BSTR);
		ATLASSERT(Cancel != NULL);
		
		VARIANT* vtPostedData = V_VARIANTREF(PostData);
		CSimpleArray<BYTE> array;
		if (V_VT(vtPostedData) & VT_ARRAY)
		{
			// must be a vector of bytes
			ATLASSERT(vtPostedData->parray->cDims == 1 && vtPostedData->parray->cbElements == 1);

			vtPostedData->vt |= VT_UI1;
			CComSafeArray safe(vtPostedData);

			DWORD dwSize = safe.GetOneDimSize();
			LPVOID pVoid;
			safe.AccessData(&pVoid);

			MtlSetSimpleArraySize(array, dwSize);
			LPBYTE lpByte = array.GetData();

			::memcpy(lpByte, pVoid, dwSize);
			safe.UnaccessData();
		}

		CString strTargetFrameName(V_BSTR(TargetFrameName));
		CString strURL = V_BSTR(URL);
		CString strHeaders = V_BSTR(Headers);
		DWORD nFlags = V_I4(Flags);
		bool bCancel = false;

		T* pT = static_cast<T*>(this);
		pT->OnBeforeNavigate2(pDisp, strURL, nFlags, strTargetFrameName,
			array, strHeaders, bCancel);

		*Cancel = bCancel ? VARIANT_TRUE : VARIANT_FALSE;

		if (!bCancel) {
			if (IsPageIWebBrowser(pDisp))
				if (m_nDownloadCounter++ == 0)
					pT->OnStateConnecting();
		}
	}

	void __stdcall __PropertyChange(/*[in]*/ BSTR bstrProperty)
	{
		CString strProperty(bstrProperty);
		T* pT = static_cast<T*>(this);
		pT->OnPropertyChange(strProperty);
	}
	
	void __stdcall __NewWindow2(/*[out]*/ IDispatch** ppDisp, /*[out]*/ VARIANT_BOOL* Cancel)
	{
		bool bCancel = false;
		T* pT = static_cast<T*>(this);
		pT->OnNewWindow2(ppDisp, bCancel);
		*Cancel = bCancel ? VARIANT_TRUE : VARIANT_FALSE;
	}
	
	void __stdcall __DocumentComplete(/*[in]*/ IDispatch* pDisp, /*[in]*/ VARIANT* URL)
	{
		ATLASSERT(V_VT(URL) == VT_BSTR);

		CString strURL = V_BSTR(URL);
		T* pT = static_cast<T*>(this);
		pT->OnDocumentComplete(pDisp, strURL);

		if (IsPageIWebBrowser(pDisp)) {// downloading over
			m_nDownloadCounter = 0;
			pT->OnStateCompleted();
		}
	}
	
	void __stdcall __OnQuit()
	{
		T* pT = static_cast<T*>(this);
		pT->OnQuit();
	}
	
	void __stdcall __OnVisible(/*[in]*/ VARIANT_BOOL Visible)
	{
		T* pT = static_cast<T*>(this);
		pT->OnVisible(Visible == VARIANT_TRUE ? true : false);
	}

	void __stdcall __OnToolBar(/*[in]*/ VARIANT_BOOL ToolBar)
	{
		T* pT = static_cast<T*>(this);
		pT->OnToolBar(ToolBar == VARIANT_TRUE ? true : false);
	}

	void __stdcall __OnMenuBar(/*[in]*/ VARIANT_BOOL MenuBar)
	{
		T* pT = static_cast<T*>(this);
		pT->OnMenuBar(MenuBar == VARIANT_TRUE ? true : false);
	}
	
	void __stdcall __OnStatusBar(/*[in]*/ VARIANT_BOOL StatusBar)
	{
		T* pT = static_cast<T*>(this);
		pT->OnStatusBar(StatusBar == VARIANT_TRUE ? true : false);
	}

	void __stdcall __OnFullScreen(/*[in]*/ VARIANT_BOOL FullScreen)
	{
		T* pT = static_cast<T*>(this);
		pT->OnFullScreen(FullScreen == VARIANT_TRUE ? true : false);
	}

	void __stdcall __OnTheaterMode(/*[in]*/ VARIANT_BOOL TheaterMode)
	{
		T* pT = static_cast<T*>(this);
		pT->OnTheaterMode(TheaterMode == VARIANT_TRUE ? true : false);
	}
};

////////////////////////////////////////////////////////////////////////////
} //namespace MTL

#endif // __MTLBROWSER_H__