webchild.h

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

/*
 * Copyright 2004, 2005 Martin Fuchs
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


 //
 // Explorer clone
 //
 // webchild.h
 //
 // Martin Fuchs, 08.02.2004
 //


#ifndef _MSC_VER
#include <exdisp.h>		// for IConnectionPointContainer
#include <exdispid.h>	// for DWebBrowserEvents2 IDs
#endif

#ifndef DISPID_BEFORENAVIGATE	// missing in MinGW (as of 07.02.2004)
#define DISPID_BEFORENAVIGATE			100
#define DISPID_NAVIGATECOMPLETE			101
#define DISPID_STATUSTEXTCHANGE			102
#define DISPID_QUIT						103
#define DISPID_DOWNLOADCOMPLETE			104
#define DISPID_COMMANDSTATECHANGE		105
#define DISPID_DOWNLOADBEGIN			106
#define DISPID_NEWWINDOW				107
#define DISPID_PROGRESSCHANGE			108
#define DISPID_WINDOWMOVE				109
#define DISPID_WINDOWRESIZE				110
#define DISPID_WINDOWACTIVATE			111
#define DISPID_PROPERTYCHANGE			112
#define DISPID_TITLECHANGE				113
#define DISPID_TITLEICONCHANGE			114
#define DISPID_FRAMEBEFORENAVIGATE		200
#define DISPID_FRAMENAVIGATECOMPLETE	201
#define DISPID_FRAMENEWWINDOW			204

#define DISPID_NAVIGATECOMPLETE2		252
#define DISPID_ONQUIT					253
#define DISPID_ONVISIBLE				254
#define DISPID_ONTOOLBAR				255
#define DISPID_ONMENUBAR				256
#define DISPID_ONSTATUSBAR				257
#define DISPID_ONFULLSCREEN				258
#define DISPID_DOCUMENTCOMPLETE			259
#define DISPID_ONTHEATERMODE			260
#define DISPID_ONADDRESSBAR				261
#define DISPID_WINDOWSETRESIZABLE		262
#define DISPID_WINDOWCLOSING			263
#define DISPID_WINDOWSETLEFT			264
#define DISPID_WINDOWSETTOP				265
#define DISPID_WINDOWSETWIDTH			266
#define DISPID_WINDOWSETHEIGHT			267
#define DISPID_CLIENTTOHOSTWINDOW		268
#define DISPID_SETSECURELOCKICON		269
#define DISPID_FILEDOWNLOAD				270
#define DISPID_NAVIGATEERROR			271
#define DISPID_PRIVACYIMPACTEDSTATECHANGE 272
#endif

#ifndef V_INT	// missing in MinGW (as of 07.02.2004)
#define	V_INT(x) V_UNION(x, intVal)
#endif

#ifdef _MSC_VER
#pragma warning(disable: 4355)	// use of 'this' for initialization of _connector
#endif


template<typename T> struct ConnectionPoint : public SIfacePtr<T>
{
	ConnectionPoint(IConnectionPointContainer* pCPC, REFIID riid)
	{
		CheckError(pCPC->FindConnectionPoint(riid, &this->_p));
	}
};

struct EventConnection
{
	EventConnection(IConnectionPoint* connectionpoint, IUnknown* sink)
	{
		CheckError(connectionpoint->Advise(sink, &_cookie));
		_connectionpoint = connectionpoint;
	}

	template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
	{
		CheckError(connectionpoint->Advise(sink, &_cookie));
		_connectionpoint = connectionpoint;
	}

/*	template<typename T> EventConnection(SIfacePtr<T>& connectionpoint, IUnknown* sink)
	{
		CheckError(connectionpoint->Advise(sink, &_cookie));
		_connectionpoint = connectionpoint.GetPtr();
	} */

/*	template<typename T> EventConnection(T& connectionpoint, IUnknown* sink)
	{
		CheckError(connectionpoint->Advise(sink, &_cookie));
		_connectionpoint = connectionpoint;
	} */

	~EventConnection()
	{
		if (_connectionpoint)
			_connectionpoint->Unadvise(_cookie);
	}

protected:
	SIfacePtr<IConnectionPoint> _connectionpoint;
	DWORD	_cookie;
};

struct EventConnector : public EventConnection
{
	EventConnector(IUnknown* unknown, REFIID riid, IUnknown* sink)
	 :	EventConnection(ConnectionPoint<IConnectionPoint>(
				SIfacePtr<IConnectionPointContainer>(unknown, IID_IConnectionPointContainer), riid), sink)
	{
	}
};


struct OleInPlaceClient : public SimpleComObject,
							public IOleClientSite,
							public IOleInPlaceSite
{
protected:
	HWND	_hwnd;

public:
	OleInPlaceClient(HWND hwnd=0)
	 :	_hwnd(hwnd)
	{
	}

	void attach(HWND hwnd)
	{
		_hwnd = hwnd;
	}

	HRESULT attach_control(IOleObject* ole_obj, LONG iVerb=OLEIVERB_INPLACEACTIVATE, HWND hwndParent=0, LPCRECT pRect=NULL)
	{
		HRESULT hr = ole_obj->SetClientSite(this);
		if (FAILED(hr))
			return hr;

//		hr = ole_obj->SetHostNames(app, doc));

		hr = ole_obj->DoVerb(iVerb, NULL, this, 0, 0/*hwnd*/, NULL/*&rcPos*/);

		return hr;
	}

	HRESULT detach(IOleObject* ole_obj, DWORD dwSaveOption=OLECLOSE_SAVEIFDIRTY)
	{
		HRESULT hr = ole_obj->Close(dwSaveOption);

		_hwnd = 0;

		return hr;
	}

	STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppv)
	{
		if (IsEqualIID(riid, IID_IOleClientSite))
			{*ppv=static_cast<IOleClientSite*>(this); IncRef(); return S_OK;}

		if (IsEqualIID(riid, IID_IOleInPlaceSite))
			{*ppv=static_cast<IOleInPlaceSite*>(this); IncRef(); return S_OK;}

		if (IsEqualIID(riid, IID_IUnknown))
			{*ppv=static_cast<IOleClientSite/*oder auch IOleInPlaceSite*/*>(this); IncRef(); return S_OK;}

		return E_NOINTERFACE;
	}

	STDMETHODIMP_(ULONG) AddRef() {return IncRef();}
	STDMETHODIMP_(ULONG) Release() {return DecRef();}


	 // IOleWindow:

	virtual /* [input_sync] */ HRESULT STDMETHODCALLTYPE GetWindow(/* [out] */ HWND __RPC_FAR *phwnd)
	{
		*phwnd = _hwnd;
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(/* [in] */ BOOL fEnterMode)
	{
		return E_NOTIMPL;
	}


	 // IOleClientSite:

	virtual HRESULT STDMETHODCALLTYPE SaveObject()
	{
		return E_NOTIMPL;
	}

	virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker __RPC_FAR *__RPC_FAR *ppmk)
	{
		return E_NOTIMPL;
	}

	virtual HRESULT STDMETHODCALLTYPE GetContainer(IOleContainer __RPC_FAR *__RPC_FAR *ppContainer)
	{
		ppContainer = 0;
		return E_NOINTERFACE;
	}

	virtual HRESULT STDMETHODCALLTYPE ShowObject()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE OnShowWindow(BOOL fShow)
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE RequestNewObjectLayout()
	{
		return S_OK;
	}


	 // IOleInPlaceSite:

	virtual HRESULT STDMETHODCALLTYPE CanInPlaceActivate()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE OnInPlaceActivate()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE OnUIActivate()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE GetWindowContext(
		/* [out] */ IOleInPlaceFrame __RPC_FAR *__RPC_FAR *ppFrame,
		/* [out] */ IOleInPlaceUIWindow __RPC_FAR *__RPC_FAR *ppDoc,
		/* [out] */ LPRECT lprcPosRect,
		/* [out] */ LPRECT lprcClipRect,
		/* [out][in] */ LPOLEINPLACEFRAMEINFO lpFrameInfo)
	{
		ClientRect rect(_hwnd);

		ppFrame = 0;
		ppDoc = 0;
		*lprcPosRect = rect;
		*lprcClipRect = rect;

		assert(lpFrameInfo->cb>=sizeof(OLEINPLACEFRAMEINFO));
		lpFrameInfo->fMDIApp = FALSE;	//@@
		lpFrameInfo->hwndFrame = 0;
		lpFrameInfo->haccel = 0;
		lpFrameInfo->cAccelEntries = 0;

		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE Scroll(/* [in] */ SIZE scrollExtant)
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE OnUIDeactivate(/* [in] */ BOOL fUndoable)
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE DiscardUndoState()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE DeactivateAndUndo()
	{
		return S_OK;
	}

	virtual HRESULT STDMETHODCALLTYPE OnPosRectChange(/* [in] */ LPCRECT lprcPosRect)
	{
		return S_OK;
	}
};


 // window with in place activates Active-X Control

template<typename BASE, typename SMARTPTR> struct IPCtrlWindow : public BASE
{
	typedef BASE super;

	IPCtrlWindow(HWND hwnd)
	 :	super(hwnd)
	{
	}

	template<typename T> IPCtrlWindow(HWND hwnd, T& info)
	 :	super(hwnd, info)
	{
	}

	HRESULT create_control(HWND hwnd, REFIID clsid, REFIID riid)
	{
		 // Erzeugen einer Instanz des Controls
		HRESULT hr = _control.CreateInstance(clsid, riid);
		if (FAILED(hr))
			return hr;

		_client_side.attach(hwnd);

		hr = _client_side.attach_control(SIfacePtr<IOleObject>(_control, IID_IOleObject)/*, OLEIVERB_INPLACEACTIVATE,
											hwnd, &Rect(10, 10, 500, 500)*/);
		if (FAILED(hr))
			return hr;

		 // try to get a IOleInPlaceObject interface for window resizing
		return _control.QueryInterface(IID_IOleInPlaceObject, &_in_place_object);	// _in_place_object = _control
	}

protected:
	LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
	{
		if (nmsg == WM_SIZE) {
			if (_in_place_object) {
				RECT rect = {0, 0, LOWORD(lparam), HIWORD(lparam)};

				_in_place_object->SetObjectRects(&rect, &rect);
			}
		} else if (nmsg == WM_CLOSE) {
			_in_place_object = NULL;

			if (_control) {
				_client_side.detach(SIfacePtr<IOleObject>(_control, IID_IOleObject), OLECLOSE_NOSAVE);
				_control = NULL;
			}
		}

		return super::WndProc(nmsg, wparam, lparam);
	}

	ComInit _usingCOM;
	SMARTPTR _control;
	OleInPlaceClient _client_side;
	SIfacePtr<IOleInPlaceObject> _in_place_object;
};



#include "exdispid.h"


struct DWebBrowserEvents2IF
{
	virtual ~DWebBrowserEvents2IF() {}

    virtual void StatusTextChange(const BStr& text)
		{}

    virtual void ProgressChange(long progress, long progressMax)
		{}

    virtual void WindowMove()
		{}

    virtual void WindowResize()
		{}

    virtual void WindowActivate()
		{}

    virtual void PropertyChange(const BStr& property)
		{}

    virtual void DownloadComplete()
		{}

    virtual void CommandStateChange(long command, bool enable)
		{}

    virtual void DownloadBegin()
		{}

    virtual void NewWindow2(IDispatch** ppDisp, VARIANT_BOOL& cancel)
		{}

    virtual void TitleChange(const BStr& text)
		{}

    virtual void TitleIconChange(const BStr& text)
		{}

	virtual void FrameBeforeNavigate(const BStr& url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& cancel)
		{}

	virtual void FrameNavigateComplete(const BStr& url)
		{}

	virtual void FrameNewWindow(const BStr&url, long flags, const BStr& targetFrameName, VARIANT* postData, const BStr& headers, VARIANT_BOOL& processed)
		{}

    virtual void BeforeNavigate2(IDispatch* pDisp, const Variant& url, const Variant& flags,
							const Variant& targetFrameName, const Variant& postData,
							const Variant& headers, VARIANT_BOOL& cancel)
		{}

    virtual void NavigateComplete2(IDispatch* pDisp, const Variant& url)
		{}

    virtual void OnQuit()
		{}

	virtual void OnVisible(bool Visible)
		{}

	virtual void OnToolbar(bool Visible)
		{}

	virtual void OnMenubar(bool Visible)
		{}

	virtual void OnStatusbar(bool Visible)
		{}

	virtual void OnFullscreen(bool Visible)
		{}

    virtual void DocumentComplete()
		{}

	virtual void OnTheatermode(bool Visible)
		{}

	virtual void OnAddressbar(bool Visible)
		{}

	virtual void WindowSetResizable(bool Visible)
		{}

	virtual void WindowClosing(VARIANT_BOOL IsChildWindow, VARIANT_BOOL& cancel)
		{}

	virtual void WindowSetLeft(long Left)
		{}

	virtual void WindowSetTop(long Top)
		{}

	virtual void WindowSetWidth(long Width)
		{}

	virtual void WindowSetHeight(long Height)
		{}

	virtual void ClientToHostWindow(long& CX, long& CY)
		{}

	virtual void SetSecureLockIcon(long SecureLockIcon)
		{}

    virtual void FileDownload(Variant& cancel)
		{}

    virtual void NavigateError(IDispatch* pDisp, const Variant& url, const Variant& Frame, const Variant& StatusCode, VARIANT_BOOL& cancel)
		{}

    virtual void PrivacyImpactedStateChange(bool bImpacted)
		{}
};


 // The web browser control has to be initialized completely before being able,
 // to display a page, that does not access internet.
struct ANSUNC BrowserNavigator
{
	BrowserNavigator();

	void	attach(IWebBrowser* browser);