Initial community commit

1 files changed, 2108 insertions, 0 deletions

diff --git a/Src/nu/HTMLContainer2.cpp b/Src/nu/HTMLContainer2.cpp
new file mode 100644
index 00000000..cfb5bbd6
--- /dev/null
+++ b/Src/nu/HTMLContainer2.cpp
@@ -0,0 +1,2108 @@
+#include "./HTMLContainer2.h"
+#include "../winamp/wa_ipc.h"
+#include "CGlobalAtom.h"
+
+#include <exdisp.h>
+#include <mshtmdid.h>
+#include <mshtml.h>
+#include <exdispid.h>
+#include <urlmon.h>
+#include <Wininet.h>
+#include <shlwapi.h>
+#include <strsafe.h>
+
+#ifndef GetWindowStyle
+#define GetWindowStyle(__hwnd) ((UINT)GetWindowLongPtrW((__hwnd), GWL_STYLE))
+#endif //GetWindowStyle
+
+#ifndef GetWindowStyleEx
+#define GetWindowStyleEx(__hwnd) ((UINT)GetWindowLongPtrW((__hwnd), GWL_EXSTYLE))
+#endif // GetWindowStyleEx
+
+static UINT WM_REDIRECTNAVIGATE	= 0;
+
+#ifndef DISPID_NEWWINDOW3
+#define DISPID_NEWWINDOW3 273 
+#endif 
+
+static CGlobalAtom WNDPROP_SCCTRLW(L"SCCTRL");
+
+static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;
+
+#define REGISTRY_FEATURE_CONTROL		L"Software\\Microsoft\\Internet Explorer\\Main\\FeatureControl"
+#define REGISTRY_FEATURE_USE_LEGACY_JSCRIPT (REGISTRY_FEATURE_CONTROL L"\\FEATURE_USE_LEGACY_JSCRIPT")
+
+#ifndef LONGX86
+#ifdef _WIN64
+  #define LONGX86	LONG_PTR
+#else /*_WIN64*/
+  #define LONGX86	 LONG	
+#endif  /*_WIN64*/
+#endif // LONGX86
+
+#ifndef CSTR_INVARIANT
+#define CSTR_INVARIANT MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)
+#endif //CSTR_INVARIANT
+
+#define IS_EQUALCLASS(__class1, __class2)\
+	(CSTR_EQUAL == CompareStringW(CSTR_INVARIANT, NORM_IGNORECASE, __class1, -1, __class2, -1))
+
+#define DEFAULT_HOSTBKCOLOR		0x00FFFFFF
+#define DEFAULT_DOCHOSTUIFLAGS	(DOCHOSTUIFLAG_NO3DOUTERBORDER |			\
+								DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION |	\
+								DOCHOSTUIFLAG_NO3DBORDER |					\
+								DOCHOSTUIDBLCLK_DEFAULT |					\
+								0)
+
+#define DEFAULT_DOWNLOADFLAGS	(DLCTL_DLIMAGES |							\
+								DLCTL_VIDEOS |								\
+								DLCTL_PRAGMA_NO_CACHE |						\
+								0)
+
+#define CF_DISABLEBEFORENAVFILTER	0x00000002
+
+typedef struct __RMNAVIGATE2
+{
+	VARIANT URL;
+	VARIANT Flags;
+	VARIANT TargetFrameName;
+	VARIANT PostData;
+	VARIANT Headers;
+}RMNAVIGATE2;
+
+typedef struct __RMNAVIGATETONAME
+{
+	BSTR url;
+	UINT flags;
+} RMNAVIGATETONAME;
+
+typedef struct _IECURSOR
+{
+	INT			nSysId;
+	HCURSOR		hSys;
+	HCURSOR		hUser;
+} IECURSOR;
+
+static INT bIsVistaOrHigher = -1;
+
+typedef struct __LIBHDR LIBHDR;
+
+typedef BOOL (WINAPI *LIBRARYLOADER)(LIBHDR* /*header*/);
+
+typedef struct __LIBHDR
+{
+	HMODULE hMod;
+	LPCWSTR name;
+	LIBRARYLOADER loader;
+	size_t	size;
+} LIBHDR;
+
+typedef struct __LIBWININET
+{
+	LIBHDR hdr;
+
+	typedef BOOL (WINAPI *INTERNETCRACKURL)(LPCWSTR /*lpszUrl*/, DWORD /*dwUrlLength*/, DWORD /*dwFlags*/, URL_COMPONENTSW* /*lpUrlComponents*/);
+	
+	INTERNETCRACKURL InternetCrackUrl;
+
+	static BOOL CALLBACK Loader(LIBHDR *pHdr)
+	{
+		LIBWININET *lib = (LIBWININET*)pHdr;
+		lib->InternetCrackUrl = (LIBWININET::INTERNETCRACKURL)GetProcAddress(pHdr->hMod, "InternetCrackUrlW");
+		return TRUE;
+	}
+} LIBWININET;
+
+typedef struct __LIBURLMON
+{	
+	LIBHDR hdr;
+
+	typedef HRESULT (WINAPI *COINTERNETSETFEATUREENABLED)(INTERNETFEATURELIST /*FeatureEntry*/, DWORD /*dwFlags*/, BOOL /*fEnable*/);
+	typedef HRESULT (WINAPI *COINTERNETISFEATUREENABLED)(INTERNETFEATURELIST /*FeatureEntry*/, DWORD /*dwFlags*/);
+
+	COINTERNETSETFEATUREENABLED CoInternetSetFeatureEnabled;
+	COINTERNETISFEATUREENABLED CoInternetIsFeatureEnabled;
+	
+	static BOOL CALLBACK Loader(LIBHDR *pHdr)
+	{
+		LIBURLMON *lib = (LIBURLMON*)pHdr;
+		lib->CoInternetSetFeatureEnabled = (LIBURLMON::COINTERNETSETFEATUREENABLED)GetProcAddress(pHdr->hMod, "CoInternetSetFeatureEnabled");
+		lib->CoInternetIsFeatureEnabled = (LIBURLMON::COINTERNETISFEATUREENABLED)GetProcAddress(pHdr->hMod, "CoInternetIsFeatureEnabled");
+		return TRUE;
+	}
+} LIBURLMON;
+
+static LIBWININET libWininet = { { NULL, L"WinInet.dll", LIBWININET::Loader, sizeof(LIBWININET)}, NULL, };
+static LIBURLMON libUrlmon = { { NULL, L"UrlMon.dll", LIBURLMON::Loader, sizeof(LIBURLMON)}, NULL, };
+static LIBHDR* szLibrary[] = { (LIBHDR*)&libWininet, (LIBHDR*)&libUrlmon };
+
+BOOL HTMLContainer2_Initialize()
+{	
+	for(size_t i = 0; i < ARRAYSIZE(szLibrary); i++)
+	{
+		if (NULL == szLibrary[i]->hMod)
+		{
+			size_t size = szLibrary[i]->size - sizeof(LIBHDR);
+			ZeroMemory((BYTE*)szLibrary[i] + sizeof(LIBHDR), size);
+		}
+	}
+	return TRUE;
+}
+
+BOOL HTMLContainer2_Uninitialize()
+{
+	for(size_t i = 0; i < ARRAYSIZE(szLibrary); i++)
+	{
+		if (NULL != szLibrary[i]->hMod)
+		{
+			FreeLibrary(szLibrary[i]->hMod);
+			szLibrary[i]->hMod = NULL;
+		}
+		size_t size = szLibrary[i]->size - sizeof(LIBHDR);
+		ZeroMemory((BYTE*)szLibrary[i] + sizeof(LIBHDR), size);
+	}
+	return TRUE;
+}
+
+BOOL HTMLContainer2_LoadLibray(LIBHDR *libraryHeader)
+{
+	if (NULL == libraryHeader)
+		return FALSE;
+
+	if (NULL != libraryHeader->hMod)
+		return TRUE;
+
+	libraryHeader->hMod = LoadLibraryW(libraryHeader->name);
+	if (NULL == libraryHeader->hMod)
+		return FALSE;
+
+	return (NULL != libraryHeader->loader) ? 
+			libraryHeader->loader(libraryHeader) :
+			TRUE;
+}
+
+static BOOL SublassControl_IsAttached(HWND hwnd);
+static BOOL SubclassControl_Attach(HWND hControl, HTMLContainer2 *pContainer);
+
+// uncomment if you ever want to use mozilla instead of IE
+// change the CLSID_WebBrowser in the constructor below to CLSID_MozillaBrowser
+// but window.external from javascript doesn't work :(
+
+static const CLSID CLSID_MozillaBrowser=
+    { 0x1339B54C, 0x3453, 0x11D2, { 0x93, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
+
+HTMLContainer2::HTMLContainer2(HWND waWindow, HWND hwndParent) :
+							   ref(1), pUnk(NULL), hParent(hwndParent), dwCookie(0),
+							   dwFlags(0), fnBrwoserCB(NULL) ,userData(NULL),
+							   bNavigating(FALSE), hCursors(NULL), nCursors(0),
+							   ensureChakraLoaded(TRUE), winampWindow(waWindow)
+{
+	if (NULL == hParent || FALSE == GetClientRect(hParent, &rect))
+		SetRectEmpty(&rect);
+
+	if (-1 == bIsVistaOrHigher)
+	{
+		OSVERSIONINFO os;
+		os.dwOSVersionInfoSize  = sizeof(OSVERSIONINFO);
+		bIsVistaOrHigher = (GetVersionEx(&os) && os.dwMajorVersion >= 6);
+	}
+}
+
+HTMLContainer2::~HTMLContainer2(void)
+{	
+	if (NULL != fnBrwoserCB)
+		fnBrwoserCB(this, DISPID_DESTRUCTOR, NULL, userData);
+
+	if (hCursors)
+	{
+		HCURSOR hc;
+		for(int i = 0; i < nCursors; i++)
+		{
+			hc = ((IECURSOR*)hCursors)[i].hUser;
+			if (hc) DestroyCursor(hc);
+		}
+		free(hCursors);
+	}
+}
+
+STDMETHODIMP HTMLContainer2::Initialize(void)
+{
+	IOleObject *pioo = NULL;
+	IConnectionPoint *pcp = NULL;
+	IConnectionPointContainer *pcpc = NULL;
+
+    HRESULT hr = CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_INPROC, IID_IUnknown, (PVOID*)&pUnk);
+	if (FAILED(hr)) 
+		return hr;
+
+	hr = pUnk->QueryInterface(IID_IOleObject, (PVOID*)&pioo);
+	if (SUCCEEDED(hr))
+	{
+		DWORD dwFlags = 0;
+		if (FAILED(pioo->GetMiscStatus(DVASPECT_CONTENT, &dwFlags)))
+			dwFlags = 0;
+
+		if (0 != (OLEMISC_SETCLIENTSITEFIRST & dwFlags))
+		{
+			IOleClientSite *pClientSite = NULL;
+			hr = QueryInterface(IID_IOleClientSite, (void**)&pClientSite);
+			if (SUCCEEDED(hr))
+			{
+				pioo->SetClientSite(pClientSite);
+				pioo->SetHostNames(L"NullsoftHtmlContainer2", NULL);
+
+				if(NULL == hParent || FALSE == GetClientRect(hParent, &rect))
+					SetRectEmpty(&rect);
+
+				pioo->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, pClientSite, 0, hParent, &rect);
+
+				pClientSite->Release();
+			}
+		}
+		pioo->Release();	
+
+		HWND hHost = GetHostHWND();
+		if (IsWindow(hHost)) 
+		{
+			SubclassControl_Attach(hHost, this);
+		}
+	}
+
+	if (FAILED(hr)) return hr;
+
+	hr = pUnk->QueryInterface(IID_IConnectionPointContainer, (PVOID*)&pcpc);
+	if (SUCCEEDED (hr))
+	{
+		hr = pcpc->FindConnectionPoint(DIID_DWebBrowserEvents2, &pcp);
+		if (SUCCEEDED(hr))
+		{
+			hr = pcp->Advise(static_cast<IDispatch*>(this), &dwCookie);
+			if (FAILED(hr)) dwCookie = 0;
+			pcp->Release();
+		}
+		pcpc->Release();
+	}
+
+	return hr;
+}
+
+STDMETHODIMP HTMLContainer2::Finish(void)
+{
+	if (!pUnk) return S_OK;
+
+	AddRef();
+
+	UnadviseBrowserEvents();
+
+	IOleObject *pioo = NULL;
+    IOleInPlaceObject *pipo = NULL;
+	HRESULT hr = pUnk->QueryInterface(IID_IOleInPlaceObject, (PVOID*)&pipo);
+	if (SUCCEEDED(hr))
+	{
+		pipo->InPlaceDeactivate();
+		pipo->UIDeactivate();
+		pipo->Release();
+	}
+
+	hr = pUnk->QueryInterface(IID_IOleObject, (PVOID*)&pioo);
+	if (SUCCEEDED(hr))
+	{
+		pioo->Close(OLECLOSE_NOSAVE);
+		pioo->SetClientSite(NULL);
+		pioo->Release();
+	}
+
+	ULONG r = pUnk->Release();
+	pUnk = NULL;
+
+	Release();
+
+	return hr;
+}
+
+STDMETHODIMP HTMLContainer2::QueryInterface(REFIID riid, PVOID *ppvObject)
+{
+	if (!ppvObject)
+		return E_POINTER;
+
+	if (IsEqualIID(riid, IID_IOleClientSite))
+		*ppvObject = (IOleClientSite*)this;
+	else if (IsEqualIID(riid, IID_IOleInPlaceSite))
+		*ppvObject = (IOleInPlaceSite*)this;
+	else if (IsEqualIID(riid, IID_IOleInPlaceFrame))
+		*ppvObject = (IOleInPlaceFrame*)this;
+	else if (IsEqualIID(riid, IID_IOleInPlaceUIWindow))
+		*ppvObject = (IOleInPlaceUIWindow*)this;
+	else if (IsEqualIID(riid, IID_IOleControlSite))
+		*ppvObject = (IOleControlSite*)this;
+	else if (IsEqualIID(riid, IID_IOleWindow))
+		*ppvObject = reinterpret_cast<IOleWindow*>(this);
+	else if (IsEqualIID(riid, IID_IDispatch))
+		*ppvObject = (IDispatch*)this;
+	else if (IsEqualIID(riid, IID_IUnknown))
+		*ppvObject = reinterpret_cast<IUnknown*>(this);
+	else if (IsEqualIID(riid, IID_IDocHostUIHandler))
+		*ppvObject = (IDocHostUIHandler*)this;
+	else if (IsEqualIID(riid, IID_IDocHostUIHandler2))
+		*ppvObject = (IDocHostUIHandler2*)this;
+	else if (IsEqualIID(riid, IID_IDocHostShowUI))
+		*ppvObject = (IDocHostShowUI*)this;
+	else if (IsEqualIID(riid, IID_IOleCommandTarget))
+		*ppvObject = (IOleCommandTarget*)this;
+	else if (IsEqualIID(riid, IID_IServiceProvider))
+		*ppvObject = (IServiceProvider*)this;
+	else
+	{
+		*ppvObject = NULL;
+		return E_NOINTERFACE;
+	}
+
+	AddRef();
+	return S_OK;
+}
+
+ULONG HTMLContainer2::AddRef(void)
+{
+	return InterlockedIncrement(&ref);
+}
+
+ULONG HTMLContainer2::Release(void)
+{
+	if (0 == ref)
+		return ref;
+
+	LONG r = InterlockedDecrement(&ref);
+	if (0 == r)
+		delete(this);
+
+	return r;
+}
+
+STDMETHODIMP HTMLContainer2::SaveObject()
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER * ppMk)
+{
+	*ppMk = NULL;
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetContainer(LPOLECONTAINER * ppContainer)
+{
+	*ppContainer = NULL;
+	return E_NOINTERFACE;
+}
+
+STDMETHODIMP HTMLContainer2::ShowObject()
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::OnShowWindow(BOOL fShow)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::RequestNewObjectLayout()
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetWindow(HWND * lphwnd)
+{
+	if (NULL != hParent && IsWindow(hParent))
+	{
+		*lphwnd = hParent;
+		return S_OK;
+	}
+	else
+	{
+		*lphwnd = NULL;
+		return E_FAIL;
+	}
+}
+
+STDMETHODIMP HTMLContainer2::ContextSensitiveHelp(BOOL fEnterMode)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::CanInPlaceActivate(void)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::OnInPlaceActivate(void)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::OnUIActivate(void)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::GetWindowContext(IOleInPlaceFrame ** ppFrame, IOleInPlaceUIWindow ** ppIIPUIWin,
+											  LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
+{
+	if (FAILED(QueryInterface(IID_IOleInPlaceFrame, (void**)ppFrame))) 
+		*ppFrame = NULL;
+
+	*ppIIPUIWin = NULL;
+
+	CopyRect(lprcPosRect, &rect);
+	CopyRect(lprcClipRect, &rect);
+
+	lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
+	lpFrameInfo->fMDIApp = FALSE;
+	lpFrameInfo->hwndFrame = hParent;
+	lpFrameInfo->haccel = NULL;
+	lpFrameInfo->cAccelEntries = 0;
+
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::Scroll(SIZE scrollExtent)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::OnUIDeactivate(BOOL fUndoable)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::OnInPlaceDeactivate(void)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::DiscardUndoState(void)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::DeactivateAndUndo(void)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::OnPosRectChange(LPCRECT lprcPosRect)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::RemoveMenus(HMENU hmenuShared)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::SetStatusText(LPCOLESTR pszStatusText)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::TranslateAccelerator(LPMSG lpmsg, WORD wID)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::EnableModeless(BOOL fEnable)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::OnControlInfoChanged()
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::LockInPlaceActive(BOOL fLock)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetExtendedControl(IDispatch **ppDisp)
+{
+	if (ppDisp == NULL)
+		return E_INVALIDARG;
+
+	*ppDisp = (IDispatch *)this;
+	(*ppDisp)->AddRef();
+
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::TransformCoords(POINTL *pptlHimetric, POINTF *pptfContainer, DWORD dwFlags)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers)
+{
+	return S_FALSE;
+}
+
+STDMETHODIMP HTMLContainer2::OnFocus(BOOL fGotFocus)
+{
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::ShowPropertyFrame(void)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetIDsOfNames(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid)
+{
+	*rgdispid = DISPID_UNKNOWN;
+	return DISP_E_UNKNOWNNAME;
+}
+
+STDMETHODIMP HTMLContainer2::GetTypeInfo(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetTypeInfoCount(unsigned int FAR * pctinfo)
+{
+	return E_NOTIMPL;
+}
+
+static HRESULT HTMLContainer2_OnShowUiElementHelper(HTMLContainer2 *instance, UINT elementId, DISPPARAMS *pDispParams)
+{
+	if (NULL == pDispParams) return E_UNEXPECTED;
+	if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+	if (VT_BOOL != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+
+	instance->OnShowUiElement(elementId, pDispParams->rgvarg[0].boolVal);
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::Invoke(DISPID dispId, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pDispParams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr)
+{
+	if (fnBrwoserCB && fnBrwoserCB(this, dispId, pDispParams, userData)) 
+	{
+		return DISP_E_MEMBERNOTFOUND;
+	}
+
+	switch (dispId)
+	{
+		case DISPID_BEFORENAVIGATE2:
+			if(7 == pDispParams->cArgs) 
+			{
+				OnBeforeNavigate(pDispParams->rgvarg[6].pdispVal, pDispParams->rgvarg[5].pvarVal,
+								pDispParams->rgvarg[4].pvarVal, pDispParams->rgvarg[3].pvarVal,
+								pDispParams->rgvarg[2].pvarVal, pDispParams->rgvarg[1].pvarVal,
+								pDispParams->rgvarg[0].pboolVal);
+				return S_OK;
+			}
+			break;
+
+		case DISPID_NAVIGATEERROR:
+			if (200 == pDispParams->rgvarg[1].pvarVal->lVal)  
+			{
+				*pDispParams->rgvarg[0].pboolVal = VARIANT_TRUE;
+			}
+			if (5 == pDispParams->cArgs) 
+			{
+				OnNavigateError(pDispParams->rgvarg[4].pdispVal, pDispParams->rgvarg[3].pvarVal,
+								pDispParams->rgvarg[2].pvarVal, pDispParams->rgvarg[1].pvarVal,
+								pDispParams->rgvarg[0].pboolVal);
+				return S_OK;
+			}
+			break;
+
+		case DISPID_NAVIGATECOMPLETE2:
+			if (2 == pDispParams->cArgs)
+			{
+				OnNavigateComplete(pDispParams->rgvarg[1].pdispVal, pDispParams->rgvarg[0].pvarVal);
+				return S_OK;
+			}
+			break;
+
+		case DISPID_DOCUMENTCOMPLETE:
+			if (2 == pDispParams->cArgs) 
+			{
+				OnDocumentComplete(pDispParams->rgvarg[1].pdispVal, pDispParams->rgvarg[0].pvarVal);
+			}
+
+			if (NULL != pUnk)
+			{
+				IWebBrowser2 *pWeb1 = NULL, *pWeb2 = NULL;
+
+				if (FAILED(GetIWebBrowser2(&pWeb1)))
+					pWeb1 = NULL;
+
+				if (pDispParams->cArgs < 2 || 
+					NULL == pDispParams->rgvarg[1].pdispVal ||
+					FAILED(pDispParams->rgvarg[1].pdispVal->QueryInterface(IID_IWebBrowser2, (void**)&pWeb2)))
+				{
+					pWeb2 = NULL;
+				}
+
+				if (NULL != pWeb1) pWeb1->Release();
+				if (NULL != pWeb2) pWeb2->Release();
+
+				if (NULL != pWeb1 && pWeb1 == pWeb2) 
+					OnDocumentReady(pDispParams->rgvarg[1].pdispVal, pDispParams->rgvarg[0].pvarVal);
+			}
+			return S_OK;
+
+		case DISPID_DOWNLOADBEGIN:
+			OnDownloadBegin();
+			return S_OK;
+
+		case DISPID_DOWNLOADCOMPLETE:
+			OnDownloadComplete();
+			return S_OK;
+
+		case DISPID_FILEDOWNLOAD:
+			if (2 == pDispParams->cArgs)
+			{
+				OnFileDownload(pDispParams->rgvarg[1].pboolVal, 	pDispParams->rgvarg[0].pboolVal);
+				return S_OK;
+			}
+			break;
+
+		case DISPID_NEWWINDOW2:
+			if (2 == pDispParams->cArgs)
+			{
+				OnNewWindow2(pDispParams->rgvarg[1].ppdispVal, pDispParams->rgvarg[0].pboolVal);
+				return S_OK;
+			}
+			break;
+
+		case DISPID_NEWWINDOW3:
+			if (5 != pDispParams->cArgs) 
+				return DISP_E_BADPARAMCOUNT;
+
+			if ((VT_DISPATCH | VT_BYREF) != pDispParams->rgvarg[4].vt || 
+				(VT_BOOL | VT_BYREF) != pDispParams->rgvarg[3].vt || 
+				VT_I4 != pDispParams->rgvarg[2].vt || 
+				VT_BSTR != pDispParams->rgvarg[1].vt || 
+				VT_BSTR != pDispParams->rgvarg[0].vt)
+			{
+				return DISP_E_BADVARTYPE;
+			}
+
+			OnNewWindow3(pDispParams->rgvarg[4].ppdispVal, pDispParams->rgvarg[3].pboolVal, 
+						pDispParams->rgvarg[2].intVal, pDispParams->rgvarg[1].bstrVal, pDispParams->rgvarg[0].bstrVal);
+			return S_OK;
+
+		case DISPID_PROGRESSCHANGE:
+			if (2 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[1].vt || 
+				VT_I4 != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnProgressChange(pDispParams->rgvarg[1].lVal, pDispParams->rgvarg[0].lVal);
+			return S_OK;
+
+		case DISPID_STATUSTEXTCHANGE:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_BSTR != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnStatusTextChange(pDispParams->rgvarg[0].bstrVal);
+			return S_OK;
+
+		case DISPID_AMBIENT_USERAGENT:
+			pvarResult->vt = VT_BSTR;
+			pvarResult->bstrVal = SysAllocString(OnGetUserAgent());
+			if (NULL != pvarResult->bstrVal) 
+				return S_OK;
+			break;
+
+		case DISPID_AMBIENT_DLCONTROL:
+			pvarResult->vt = VT_I4;
+			pvarResult->lVal = OnGetDownlodFlags();
+			return S_OK;
+
+		case DISPID_COMMANDSTATECHANGE:
+			if (2 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[1].vt ||
+				VT_BOOL != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnCommandStateChange(pDispParams->rgvarg[1].lVal, pDispParams->rgvarg[0].boolVal);
+			return S_OK;
+
+		case DISPID_SETSECURELOCKICON:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnSetSecureLockIcon(pDispParams->rgvarg[0].lVal);
+			return S_OK;
+
+		case DISPID_TITLECHANGE:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_BSTR != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnTitleChange(pDispParams->rgvarg[0].bstrVal);
+			return S_OK;
+
+		case DISPID_ONVISIBLE:
+			if(1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_BOOL != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnVisibleChange(pDispParams->rgvarg[0].boolVal);
+			return S_OK;
+
+		case DISPID_WINDOWCLOSING:
+			if (2 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_BOOL != pDispParams->rgvarg[1].vt ||
+				(VT_BOOL|VT_BYREF) != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnWindowClosing(pDispParams->rgvarg[1].boolVal, pDispParams->rgvarg[0].pboolVal);
+			return S_OK;
+
+		case DISPID_ONTOOLBAR:			return HTMLContainer2_OnShowUiElementHelper(this, uiToolbar, pDispParams);
+		case DISPID_ONMENUBAR:			return HTMLContainer2_OnShowUiElementHelper(this, uiMenubar, pDispParams);
+		case DISPID_ONSTATUSBAR:		return HTMLContainer2_OnShowUiElementHelper(this, uiStatusbar, pDispParams);
+		case DISPID_ONADDRESSBAR:		return HTMLContainer2_OnShowUiElementHelper(this, uiAddressbar, pDispParams);
+
+		case DISPID_ONFULLSCREEN:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_BOOL != pDispParams->rgvarg[0].vt) DISP_E_BADVARTYPE;
+			OnEnableFullscreen(pDispParams->rgvarg[0].boolVal);
+			return S_OK;
+
+		case DISPID_WINDOWSETRESIZABLE:	
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_BOOL != pDispParams->rgvarg[0].vt) DISP_E_BADVARTYPE;
+			OnWindowSetResizable(pDispParams->rgvarg[0].boolVal);
+			return S_OK;
+
+		case DISPID_CLIENTTOHOSTWINDOW:
+			if (2 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if ((VT_BYREF|VT_I4) != pDispParams->rgvarg[1].vt ||
+				(VT_BYREF|VT_I4) != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnClientToHostWindow(pDispParams->rgvarg[1].plVal, pDispParams->rgvarg[0].plVal);
+			return S_OK;
+
+		case DISPID_WINDOWSETLEFT:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnSetWindowPos(wndLeft, pDispParams->rgvarg[0].lVal, 0, 0, 0);
+			return S_OK;
+
+		case DISPID_WINDOWSETTOP:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnSetWindowPos(wndTop, 0, pDispParams->rgvarg[0].lVal, 0, 0);
+			return S_OK;
+
+		case DISPID_WINDOWSETWIDTH:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnSetWindowPos(wndWidth, 0, 0, pDispParams->rgvarg[0].lVal, 0);
+			return S_OK;
+
+		case DISPID_WINDOWSETHEIGHT:
+			if (1 != pDispParams->cArgs) return DISP_E_BADPARAMCOUNT;
+			if (VT_I4 != pDispParams->rgvarg[0].vt) return DISP_E_BADVARTYPE;
+			OnSetWindowPos(wndHeight, 0, 0, 0, pDispParams->rgvarg[0].lVal);
+			return S_OK;
+	}
+
+	return DISP_E_MEMBERNOTFOUND;
+}
+
+STDMETHODIMP HTMLContainer2::SetLocation(int x, int y, int width, int height)
+{
+	if (!pUnk) return E_NOINTERFACE;
+
+	SetRect(&rect, x, y, x + width, y + height);
+
+	IOleInPlaceObject *pipo = NULL;
+	HRESULT hr = pUnk->QueryInterface(IID_IOleInPlaceObject, (PVOID*)&pipo);
+	if (SUCCEEDED(hr))
+	{			
+		hr = pipo->SetObjectRects(&rect, &rect);
+		pipo->Release();
+	}
+	return hr;
+}
+
+STDMETHODIMP HTMLContainer2::GetBorder(LPRECT lprectBorder)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::RequestBorderSpace(LPCBORDERWIDTHS lpborderwidths)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::SetBorderSpace(LPCBORDERWIDTHS lpborderwidths)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::SetActiveObject(IOleInPlaceActiveObject * pActiveObject, LPCOLESTR lpszObjName)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::SetFocus(BOOL fFocused)
+{	
+	if (NULL == pUnk) 
+		return E_NOINTERFACE;
+
+	if (FALSE != fFocused)
+	{
+		IOleObject *pioo = NULL;
+		if (SUCCEEDED(pUnk->QueryInterface(IID_IOleObject, (PVOID*)&pioo)))
+		{
+			pioo->DoVerb(OLEIVERB_UIACTIVATE, NULL, this, 0, hParent, &rect);
+			pioo->Release();
+		}
+	}
+	else
+	{
+		IOleInPlaceObject *pipo = NULL;
+		if (SUCCEEDED(pUnk->QueryInterface(IID_IOleInPlaceObject, (void**)&pipo)))
+		{
+			pipo->UIDeactivate();
+			pipo->Release();
+		}
+	}
+
+	return S_OK;
+}
+
+BOOL HTMLContainer2::TranslateKey(LPMSG pMsg)
+{
+	if (!pUnk) return FALSE;
+
+	IOleInPlaceActiveObject *pao = NULL;
+	HRESULT hr = pUnk->QueryInterface(IID_IOleInPlaceActiveObject, (PVOID*)&pao);
+	if (SUCCEEDED(hr))
+	{
+		hr = pao->TranslateAccelerator(pMsg);
+		pao->Release();
+	}
+
+	return (S_OK == hr);
+}
+
+STDMETHODIMP HTMLContainer2::ShowHelp(HWND hwnd, LPOLESTR pszHelpFile, UINT uCommand, DWORD dwData, POINT ptMouse, IDispatch *pDispatchObjectHit)
+{
+	return S_FALSE;
+}
+
+STDMETHODIMP HTMLContainer2::ShowMessage(HWND hwnd, LPOLESTR lpstrText, LPOLESTR lpstrCaption, DWORD dwType, LPOLESTR lpstrHelpFile, DWORD dwHelpContext, LRESULT *plResult)
+{
+	return S_FALSE;
+}
+
+// ***********************************************************************
+//  IDocHostUIHandler
+// ***********************************************************************
+
+STDMETHODIMP HTMLContainer2::ShowContextMenu(DWORD dwID, POINT __RPC_FAR *ppt, IUnknown __RPC_FAR *pcmdtReserved, IDispatch __RPC_FAR *pdispReserved)
+{
+	return S_FALSE;
+}
+
+STDMETHODIMP HTMLContainer2::GetHostInfo(DOCHOSTUIINFO __RPC_FAR *pInfo)
+{
+	pInfo->cbSize = sizeof(DOCHOSTUIINFO);
+	pInfo->dwFlags = OnGetHostInfoFlags();
+
+	pInfo->pchHostCss = OnGetHostCSS();
+	pInfo->pchHostNS = OnGetHostNamespace();
+
+	return S_OK;
+}
+
+STDMETHODIMP HTMLContainer2::ShowUI(DWORD dwID, IOleInPlaceActiveObject __RPC_FAR *pActiveObject, IOleCommandTarget __RPC_FAR *pCommandTarget, IOleInPlaceFrame __RPC_FAR *pFrame, IOleInPlaceUIWindow __RPC_FAR *pDoc)
+{
+	return S_FALSE;
+}
+
+STDMETHODIMP HTMLContainer2::HideUI(void)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::UpdateUI(void)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::OnDocWindowActivate(BOOL fActivate)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::OnFrameWindowActivate(BOOL fActivate)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow __RPC_FAR *pUIWindow, BOOL fRameWindow)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::TranslateAccelerator(LPMSG lpMsg, const GUID __RPC_FAR *pguidCmdGroup, DWORD nCmdID)
+{
+	if ((0x8000 & GetAsyncKeyState(VK_MENU)) || (0x8000 & GetAsyncKeyState(VK_CONTROL)))
+	{
+		if (NULL != hParent && IsWindow(hParent) && 
+			PostMessageW(hParent, lpMsg->message, lpMsg->wParam, lpMsg->lParam))
+		{
+			return S_OK;
+		}
+	}	
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetOptionKeyPath(LPOLESTR __RPC_FAR *pchKey, DWORD dw)
+{
+	*pchKey = NULL;
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetDropTarget(IDropTarget __RPC_FAR *pDropTarget, IDropTarget __RPC_FAR *__RPC_FAR *ppDropTarget)
+{
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::GetExternal(IDispatch __RPC_FAR *__RPC_FAR *ppDispatch)
+{
+	*ppDispatch = NULL;
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::TranslateUrl(DWORD dwTranslate, OLECHAR __RPC_FAR *pchURLIn, OLECHAR __RPC_FAR *__RPC_FAR *ppchURLOut)
+{
+	*ppchURLOut = NULL;
+	return E_NOTIMPL;
+}
+
+STDMETHODIMP HTMLContainer2::FilterDataObject(IDataObject __RPC_FAR *pDO, IDataObject __RPC_FAR *__RPC_FAR *ppDORet)
+{
+	*ppDORet = NULL;
+	return S_FALSE;
+}
+
+STDMETHODIMP HTMLContainer2::GetOverrideKeyPath(LPOLESTR __RPC_FAR *pchKey, DWORD dw)
+{
+	*pchKey = NULL;
+	return S_FALSE;
+}
+
+STDMETHODIMP HTMLContainer2::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
+{
+	return OLECMDERR_E_NOTSUPPORTED;
+}
+
+STDMETHODIMP HTMLContainer2::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdExecOpt, VARIANTARG *pvaIn, VARIANTARG *pvaOut)
+{	
+	return OLECMDERR_E_UNKNOWNGROUP;
+}
+
+STDMETHODIMP HTMLContainer2::QueryService(REFGUID guidService, REFIID riid, void **ppv)
+{
+	return E_NOINTERFACE;
+}
+
+HRESULT HTMLContainer2::GetIUnknown(IUnknown **ppUnk)
+{
+	if (!pUnk)
+	{
+		*ppUnk = NULL;
+		return E_NOINTERFACE;
+	}
+	pUnk->AddRef();
+	*ppUnk = pUnk;
+	return S_OK;
+}
+
+HRESULT HTMLContainer2::GetIDispatch(IDispatch **ppDisp)
+{
+	*ppDisp = NULL;
+	return (pUnk) ? pUnk->QueryInterface(IID_IDispatch, (PVOID*)ppDisp) : E_NOINTERFACE;
+}
+
+HRESULT HTMLContainer2::GetIWebBrowser2(IWebBrowser2 **ppWeb2)
+{
+	*ppWeb2 = NULL;
+	return (pUnk) ? pUnk->QueryInterface(IID_IWebBrowser2, (PVOID*)ppWeb2) : E_NOINTERFACE;
+}
+
+HWND HTMLContainer2::GetHostHWND(void)
+{	
+	if (NULL == pUnk) return NULL;
+
+	HWND hwndHost = NULL;
+	IOleInPlaceObject *pipo = NULL;
+	HRESULT hr = pUnk->QueryInterface(IID_IOleInPlaceObject, (PVOID *)&pipo);
+	if (SUCCEEDED(hr))
+	{			
+		hr = pipo->GetWindow(&hwndHost);
+		if (FAILED(hr)) hwndHost = NULL;
+		pipo->Release();
+	}
+
+	return hwndHost;
+}
+
+HWND HTMLContainer2::GetParentHWND(void)
+{
+	return hParent;
+}
+
+STDMETHODIMP HTMLContainer2::UnadviseBrowserEvents()
+{
+	if (0 == dwCookie)
+		return S_OK;
+
+	IConnectionPoint *pcp = NULL;
+	IConnectionPointContainer *pcpc = NULL;
+	HRESULT hr = pUnk->QueryInterface(IID_IConnectionPointContainer, (PVOID*)&pcpc);
+	if (SUCCEEDED (hr))
+	{
+		hr = pcpc->FindConnectionPoint(DIID_DWebBrowserEvents2, &pcp);
+		if (SUCCEEDED(hr))
+		{
+			hr = pcp->Unadvise(dwCookie);
+			if (SUCCEEDED(hr))
+			{
+				dwCookie = 0;
+			}
+			pcp->Release();
+		}
+		pcpc->Release();
+	}
+	return hr;
+}
+
+HRESULT HTMLContainer2::PostRedirectMessage(UINT messageId, LPARAM param)
+{
+	HWND hHost = GetHostHWND();
+	if (NULL == hHost) return E_HANDLE;
+	if (FALSE == SublassControl_IsAttached(hHost)) return E_NOTIMPL;
+
+	if (0 == WM_REDIRECTNAVIGATE)
+	{
+		WM_REDIRECTNAVIGATE = RegisterWindowMessageW(L"htmlContainterRedirectNavigate");
+		if (0 == WM_REDIRECTNAVIGATE) return E_UNEXPECTED;
+	}
+
+	if (FALSE == PostMessageW(hHost, WM_REDIRECTNAVIGATE, (WPARAM)messageId, param))
+	{
+		DWORD errorCode = GetLastError();
+		return HRESULT_FROM_WIN32(errorCode);
+	}
+
+	return S_OK;
+}
+
+HRESULT HTMLContainer2::NavigateEx(IWebBrowser2 *pWeb2, VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
+{
+	HRESULT	hr;
+	if (NULL == pWeb2) 
+		return E_NOINTERFACE;
+
+	pWeb2->AddRef();
+
+	VARIANT vtHeader;
+	BOOL performNavigate = TRUE;
+
+	VariantInit(&vtHeader);
+
+	LPCWSTR pszUserAgent = OnGetUserAgent();
+	if (!Headers && NULL != pszUserAgent && L'\0' != *pszUserAgent) 
+	{			
+		wchar_t szBuffer[256] = {0};
+		if (SUCCEEDED(StringCchPrintfW(szBuffer, ARRAYSIZE(szBuffer), L"User-Agent: %s", pszUserAgent)))
+		{
+			V_VT(&vtHeader) = VT_BSTR;
+			vtHeader.bstrVal = SysAllocString(szBuffer);
+			Headers = &vtHeader;
+		}
+	}
+
+	if (FALSE != ensureChakraLoaded)
+	{
+		if (NULL == GetModuleHandleW(L"mshtml.dll"))
+		{
+			HKEY hKey = NULL;
+			unsigned long disposition = 0;
+			long createResult = 0;
+			wchar_t processName[2*MAX_PATH] = {0};
+			HANDLE lock = CreateMutexW(NULL, FALSE, L"HTMLContainer2::ChakraEnabler");
+			if (NULL != lock)
+				WaitForSingleObject(lock, INFINITE);
+
+			createResult = RegCreateKeyExW(HKEY_CURRENT_USER, REGISTRY_FEATURE_USE_LEGACY_JSCRIPT,
+										   NULL, NULL, REG_OPTION_VOLATILE, KEY_SET_VALUE,
+										   NULL, &hKey, &disposition);
+
+			if (ERROR_SUCCESS == createResult)
+			{	
+				unsigned long featureEnabled = 0;
+				if (0 != GetModuleFileNameW(NULL, processName, ARRAYSIZE(processName)))
+				{
+					featureEnabled = 0;
+					PathStripPathW(processName);
+
+					RegSetValueExW(hKey, processName, 0, REG_DWORD, (const BYTE*)&featureEnabled, sizeof(unsigned long));
+
+					hr = pWeb2->Navigate2(URL, Flags, TargetFrameName, PostData, Headers);
+					performNavigate = FALSE;
+
+					RegDeleteValueW(hKey, processName);
+				}
+
+				RegCloseKey(hKey);
+			}
+
+			if (NULL != lock)
+			{
+				ReleaseMutex(lock);
+				CloseHandle(lock);
+			}
+		}
+		ensureChakraLoaded = FALSE;
+	}
+
+	if (FALSE != performNavigate)
+		hr = pWeb2->Navigate2(URL, Flags, TargetFrameName, PostData, Headers);
+
+	VariantClear(&vtHeader);
+	pWeb2->Release();
+	return hr;
+}
+
+HRESULT HTMLContainer2::Navigate2(VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
+{
+	if (NULL == pUnk) 
+		return E_NOINTERFACE;
+
+	IWebBrowser2 *pWeb2 = NULL;
+	HRESULT hr = pUnk->QueryInterface(IID_IWebBrowser2, (LPVOID*)&pWeb2);
+
+	if(SUCCEEDED(hr))
+	{
+		hr = NavigateEx(pWeb2, URL, Flags, TargetFrameName, PostData, Headers);
+		pWeb2->Release();
+	}
+	return hr;
+}
+
+HRESULT HTMLContainer2::PostNavigate2(VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
+{		
+	RMNAVIGATE2 *param = (RMNAVIGATE2*)calloc(1, sizeof(RMNAVIGATE2));
+	if (NULL == param) return E_OUTOFMEMORY;
+
+	VariantInit(&param->URL);
+	VariantInit(&param->Flags);
+	VariantInit(&param->TargetFrameName);
+	VariantInit(&param->PostData);
+	VariantInit(&param->Headers);
+
+	if (NULL != URL) VariantCopyInd(&param->URL, URL);
+	if (NULL != Flags) VariantCopyInd(&param->Flags, Flags);
+	if (NULL != TargetFrameName) VariantCopyInd(&param->TargetFrameName, TargetFrameName);
+	if (NULL != PostData) VariantCopyInd(&param->PostData, PostData);
+	if (NULL != Headers) VariantCopyInd(&param->Headers, Headers);
+
+	HRESULT hr = PostRedirectMessage(HTMLContainer2::msgNavigate2, (LPARAM)param);
+	if (FAILED(hr)) 
+	{
+		VariantClear(&param->URL);
+		VariantClear(&param->Flags);
+		VariantClear(&param->TargetFrameName);
+		VariantClear(&param->PostData);
+		VariantClear(&param->Headers);
+		free(param);
+	}
+	return hr;
+}
+
+HRESULT HTMLContainer2::NavigateToNameEx(IWebBrowser2 *pWeb2, LPCWSTR pszUrl, UINT fFlags)
+{
+	VARIANT	Flags;
+	VARIANT	URL;
+
+	if (NULL == pszUrl || L'\0' == *pszUrl)
+	{
+		pszUrl = L"about:blank";
+	}
+
+	VariantInit(&Flags);
+	V_VT(&Flags) = VT_I4;
+	V_I4(&Flags) = fFlags;
+
+	VariantInit(&URL);
+	V_VT(&URL) = VT_BSTR;
+	URL.bstrVal = SysAllocString(pszUrl);
+
+	HRESULT hr = (NULL != URL.bstrVal) ? NavigateEx(pWeb2, &URL, &Flags, NULL, NULL, NULL) : E_FAIL;
+
+	VariantClear(&URL);
+	VariantClear(&Flags);
+	return hr;
+}
+
+HRESULT HTMLContainer2::NavigateToName(LPCWSTR pszUrl, UINT fFlags)
+{
+	if (NULL == pUnk) 
+		return E_NOINTERFACE;
+
+	IWebBrowser2 *pWeb2 = NULL;
+	HRESULT	hr = pUnk->QueryInterface(IID_IWebBrowser2, (LPVOID*)&pWeb2);
+
+	if(SUCCEEDED(hr))
+	{
+		hr = NavigateToNameEx(pWeb2, pszUrl, fFlags);
+		pWeb2->Release();
+	}
+	return hr;
+}
+
+HRESULT HTMLContainer2::PostNavigateToName(LPCWSTR pszUrl, UINT fFlags)
+{
+	RMNAVIGATETONAME *param = (RMNAVIGATETONAME*)calloc(1, sizeof(RMNAVIGATETONAME));
+	if (NULL == param) return E_OUTOFMEMORY;
+
+	param->url = SysAllocString(pszUrl);
+	param->flags = fFlags;
+
+	HRESULT hr = PostRedirectMessage(HTMLContainer2::msgNavigateToName, (LPARAM)param);
+	if (FAILED(hr))
+	{
+		SysFreeString(param->url);
+		free(param);
+	}
+	return hr;
+}
+
+HRESULT HTMLContainer2::WriteHTML(LPCWSTR pszHTML)
+{
+	BSTR data = SysAllocString(pszHTML);
+	if (NULL == data && NULL != pszHTML)
+		return E_OUTOFMEMORY;
+
+	HRESULT hr = WriteDocument(data);
+	if (FAILED(hr)) 
+	{
+		SysFreeString(data);
+	}
+
+	return hr;
+}
+
+HRESULT HTMLContainer2::WriteDocument(BSTR data)
+{
+	IWebBrowser2 *pWeb2 = NULL;
+	HRESULT hr = GetIWebBrowser2(&pWeb2);
+	if (FAILED(hr)) return hr;
+
+	IDispatch *pDisp = NULL;
+	hr = pWeb2->get_Document(&pDisp);
+	if (S_OK == hr)
+	{
+		IHTMLDocument2 *pDoc = NULL;
+		hr = pDisp->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc);
+		if (SUCCEEDED(hr))
+		{	
+			SAFEARRAY *array = SafeArrayCreateVector(VT_VARIANT, 0, 1);
+			if (NULL != array)
+			{
+				VARIANT *item = NULL;
+				hr = SafeArrayAccessData(array, (void**)&item);
+				if (SUCCEEDED(hr))
+				{
+					VariantInit(item);
+					V_VT(item) = VT_BSTR;
+					V_BSTR(item) = data;
+
+					hr = pDoc->write(array);
+					pDoc->close();
+
+					if (FAILED(hr))
+                        V_BSTR(item) = NULL;
+
+					SafeArrayUnaccessData(array);
+				}
+				SafeArrayDestroy(array);
+			}
+			else 
+			{
+				hr = E_OUTOFMEMORY;
+			}
+
+			pDoc->Release();
+		}
+		pDisp->Release();
+	}
+	pWeb2->Release();
+	return hr;
+}
+
+COLORREF HTMLContainer2::OnGetHostBkColor(void)
+{
+	return DEFAULT_HOSTBKCOLOR;
+}
+
+DWORD HTMLContainer2::OnGetHostInfoFlags(void)
+{
+	return DEFAULT_DOCHOSTUIFLAGS;
+}
+
+OLECHAR *HTMLContainer2::OnGetHostCSS(void)
+{
+	return NULL;
+}
+
+OLECHAR *HTMLContainer2::OnGetHostNamespace(void)
+{
+	return NULL;
+}
+
+DWORD HTMLContainer2::OnGetDownlodFlags(void)
+{
+	return DEFAULT_DOWNLOADFLAGS;
+}
+
+LPCWSTR HTMLContainer2::OnGetUserAgent(void)
+{
+	return NULL;
+}
+
+HRESULT HTMLContainer2::InvokeScriptFunction(LPCWSTR pszFuncName, LCID lcid, DISPPARAMS FAR *pDispParams, VARIANT FAR *pVarResult, EXCEPINFO FAR *pExcepInfo, UINT FAR *puArgErr)
+{
+	IWebBrowser2 *pWeb2 = NULL;
+	IDispatch *pDisp = NULL;
+	IDispatch *pDispScript = NULL;
+	IHTMLDocument2 *pDoc = NULL;
+	DISPID dispid;
+
+	HRESULT hr = GetIWebBrowser2(&pWeb2);
+	if (SUCCEEDED(hr))
+	{
+		hr = pWeb2->get_Document(&pDisp);
+		if (SUCCEEDED(hr))
+		{
+			hr = pDisp->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc);
+			if (SUCCEEDED(hr))
+			{
+				hr = pDoc->get_Script(&pDispScript);
+				if (SUCCEEDED(hr))
+				{
+					hr = pDispScript->GetIDsOfNames(IID_NULL, (LPWSTR*)&pszFuncName, 1, lcid, &dispid);
+					if (SUCCEEDED(hr))
+					{
+						hr = pDispScript->Invoke(dispid, IID_NULL, lcid, DISPATCH_METHOD, pDispParams, pVarResult, pExcepInfo, puArgErr);
+					}
+					pDispScript->Release();
+				}
+				pDoc->Release();
+			}
+			pDisp->Release();
+		}
+		pWeb2->Release();
+	}
+	return hr;
+}
+
+BROWSERCB HTMLContainer2::RegisterBrowserEventCB(BROWSERCB fnBrowserCB, LPVOID pUserData)
+{
+	BROWSERCB fnTemp = this->fnBrwoserCB;
+	this->fnBrwoserCB = fnBrowserCB;
+	this->userData = pUserData;
+	return fnTemp;
+}
+
+DWORD HTMLContainer2::GetContainerStyle(void)
+{
+	return CSTYLE_NORMAL;
+}
+
+HRESULT HTMLContainer2::IsFrameset(IWebBrowser2 *pWeb2)
+{
+	if (NULL == pWeb2)
+		return E_INVALIDARG;
+
+	IDispatch *pDocDisp = NULL;
+	HRESULT hr = pWeb2->get_Document(&pDocDisp);
+	if (SUCCEEDED(hr) && NULL != pDocDisp)
+	{
+		IHTMLDocument2 *pDoc = NULL;
+		hr = pDocDisp->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc);
+		if (SUCCEEDED(hr) && NULL != pDoc)
+		{
+			IHTMLElement *pElement = NULL;
+			if (SUCCEEDED(pDoc->get_body(&pElement)) && NULL != pElement)
+			{
+				IHTMLBodyElement* pBodyElement = NULL;
+				if (SUCCEEDED(pElement->QueryInterface(IID_IHTMLBodyElement, (void**)&pBodyElement)))
+				{
+					hr = S_FALSE;
+				}
+				pElement->Release();
+			}
+			pDoc->Release();
+		}
+		pDocDisp->Release();
+	}
+	return hr;
+}
+
+HRESULT HTMLContainer2::GetFramesCount(IWebBrowser2 *pWeb2, INT *frameCount)
+{
+	if (NULL == frameCount)
+		return E_POINTER;
+
+	*frameCount = 0;
+
+	if(NULL == pWeb2)
+		return E_INVALIDARG;
+
+	IDispatch *pDocDisp = NULL;
+	HRESULT hr = pWeb2->get_Document(&pDocDisp);
+	if (SUCCEEDED(hr) && NULL != pDocDisp)
+	{
+		IOleContainer *pContainer = NULL;
+		hr = pDocDisp->QueryInterface(IID_IOleContainer, (void**)&pContainer);
+		if (SUCCEEDED(hr))
+		{
+			IEnumUnknown* pEnumerator = NULL;
+			hr = pContainer->EnumObjects(OLECONTF_EMBEDDINGS, &pEnumerator);
+			if (SUCCEEDED(hr))
+			{
+				IUnknown* pUnknown = NULL;
+				ULONG uFetched = 0;
+				for (UINT i = 0; S_OK == pEnumerator->Next(1, &pUnknown, &uFetched); i++)
+				{
+					IWebBrowser2* pBrowser = NULL;
+					if (SUCCEEDED(pUnknown->QueryInterface(IID_IWebBrowser2, (void**)&pBrowser)))
+					{
+						if (S_OK == IsFrameset(pBrowser))
+						{
+							INT f = 0;
+							if (SUCCEEDED(GetFramesCount(pBrowser, &f)))
+								*frameCount += f;
+						}
+						else
+						{
+							(*frameCount)++;
+						}
+						pBrowser->Release();
+					}
+					pUnknown->Release();
+				}
+				pEnumerator->Release();
+			}
+			pContainer->Release();
+		}
+		pDocDisp->Release();
+	}
+	return hr;
+}
+
+BOOL HTMLContainer2::ValidateURLHost(LPCWSTR pszUrl)
+{
+	if (NULL == libWininet.InternetCrackUrl)
+	{
+		HTMLContainer2_LoadLibray((LIBHDR*)&libWininet);
+		if (NULL == libWininet.InternetCrackUrl)
+		{			
+			return TRUE;
+		}
+	}
+
+	if (NULL == pszUrl || L'\0' == *pszUrl)
+		return FALSE;
+
+	URL_COMPONENTSW uc;
+	WCHAR szHost[2048] = {0};
+
+	ZeroMemory(&uc, sizeof(URL_COMPONENTSW));
+	uc.dwStructSize = sizeof(URL_COMPONENTSW);
+	uc.lpszHostName = szHost;
+	uc.dwHostNameLength = ARRAYSIZE(szHost);
+
+	if (FALSE == libWininet.InternetCrackUrl(pszUrl, 0, NULL, &uc))
+	{
+		// ERROR_INTERNET_INVALID_URL
+		DWORD error = GetLastError();
+
+		BSTR version = NULL;
+		if (SUCCEEDED(GetAppVersion(&version)) && NULL != version)
+		{				
+			if (NULL != StrStrIW(version, L"MSIE 6.0"))
+			{
+				LPCWSTR c = pszUrl;
+				while(c && L'\0' != *c)
+				{
+					if (L'?' == *c)
+					{
+						WCHAR szTemp[2048] = {0};
+						if (SUCCEEDED(StringCchCopyNW(szTemp, ARRAYSIZE(szTemp), pszUrl, (c - pszUrl))) &&
+							FALSE != libWininet.InternetCrackUrl(szTemp, 0, NULL, &uc))
+						{
+							error = ERROR_SUCCESS;
+						}
+						break;
+					}
+					c++;
+				}
+			}
+
+			SysFreeString(version);
+		}
+		if (ERROR_SUCCESS != error)
+			return FALSE;
+	}
+
+	if (0 == uc.dwHostNameLength)
+		return TRUE;
+
+	switch(uc.nScheme)
+	{
+		case INTERNET_SCHEME_PARTIAL:
+		case INTERNET_SCHEME_DEFAULT:
+		case INTERNET_SCHEME_FTP:
+		case INTERNET_SCHEME_GOPHER:
+		case INTERNET_SCHEME_HTTP:
+		case INTERNET_SCHEME_HTTPS:
+			{
+				LPCWSTR block = uc.lpszHostName;
+				LPCWSTR end = block + uc.dwHostNameLength;
+				LPCWSTR cursor = block;
+
+				for(;;)
+				{
+					if (cursor == end || L'.' == *cursor)
+					{
+						if (block == cursor && end != cursor)
+							return FALSE;
+
+						if (end == cursor)
+							return TRUE;
+					}
+					cursor++;
+				}
+			}
+			break;
+		case INTERNET_SCHEME_RES:
+		case INTERNET_SCHEME_FILE:
+			if (CSTR_EQUAL == CompareStringW(CSTR_INVARIANT, 0, L"shdoclc", -1, uc.lpszHostName, -1))
+			{
+				if (NULL != StrStrIW(pszUrl, L"syntax.htm"))
+				{
+					return FALSE;
+				}
+			}
+			break;
+	}
+	return TRUE;
+}
+
+HRESULT HTMLContainer2::GetAppVersion(BSTR *p)
+{
+	if (NULL == p)
+		return E_POINTER;
+
+	IWebBrowser2 *pWeb2 = NULL;
+	HRESULT hr = GetIWebBrowser2(&pWeb2);
+	if (FAILED(hr)) return hr;
+
+	IDispatch *pDispatch = NULL;
+	hr = pWeb2->get_Document(&pDispatch);
+	if (NULL == pDispatch) hr = E_FAIL;
+	if (SUCCEEDED(hr))
+	{
+		IHTMLDocument2 *pDoc = NULL;
+		hr = pDispatch->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc);
+		if (SUCCEEDED(hr))
+		{
+			IHTMLWindow2 *pWnd = NULL;
+			hr = pDoc->get_parentWindow(&pWnd);
+			if (NULL == pWnd) hr = E_FAIL;
+			if (SUCCEEDED(hr))
+			{
+				IOmNavigator *pNavigator = NULL;
+				hr = pWnd->get_navigator(&pNavigator);
+				if (NULL == pNavigator) hr = E_FAIL;
+				if (SUCCEEDED(hr))
+				{
+					hr = pNavigator->get_appVersion(p);
+					pNavigator->Release();
+				}
+				pWnd->Release();
+			}
+			pDoc->Release();
+		}
+		pDispatch->Release();
+	}
+
+	pWeb2->Release();
+	return hr;
+}
+
+HRESULT HTMLContainer2::GetUserAgent(BSTR *p)
+{
+	if (NULL == p)
+		return E_POINTER;
+
+	IWebBrowser2 *pWeb2 = NULL;
+	HRESULT hr = GetIWebBrowser2(&pWeb2);
+	if (FAILED(hr)) return hr;
+
+	IDispatch *pDispatch = NULL;
+	hr = pWeb2->get_Document(&pDispatch);
+	if (NULL == pDispatch) hr = E_FAIL;
+	if (SUCCEEDED(hr))
+	{
+		IHTMLDocument2 *pDoc = NULL;
+		hr = pDispatch->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc);
+		if (SUCCEEDED(hr))
+		{
+			IHTMLWindow2 *pWnd = NULL;
+			hr = pDoc->get_parentWindow(&pWnd);
+			if (NULL == pWnd) hr = E_FAIL;
+			if (SUCCEEDED(hr))
+			{
+				IOmNavigator *pNavigator = NULL;
+				hr = pWnd->get_navigator(&pNavigator);
+				if (NULL == pNavigator) hr = E_FAIL;
+				if (SUCCEEDED(hr))
+				{
+					hr = pNavigator->get_userAgent(p);
+					pNavigator->Release();
+				}
+				pWnd->Release();
+			}
+			pDoc->Release();
+		}
+		pDispatch->Release();
+	}
+
+	pWeb2->Release();
+	return hr;
+}
+
+void HTMLContainer2::OnBeforeNavigate(IDispatch *pDispatch, VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers, VARIANT_BOOL *Cancel)
+{
+	if (0 == (CF_DISABLEBEFORENAVFILTER & dwFlags))
+	{
+		// follow the Winamp internet preferences options
+		if (!SendMessageW(winampWindow, WM_WA_IPC, 0, IPC_INETAVAILABLE))
+		{
+			LPCWSTR pszTemplate = L"res://";
+			LPCWSTR pszEntry = StrStrIW(URL->bstrVal, pszTemplate);
+			if (NULL == pszEntry)
+			{
+				if (StrCmpNIW(URL->bstrVal, L"about:blank", 11) && StrCmpNIW(URL->bstrVal, L"javascript:", 11))
+				{
+					*Cancel = ((VARIANT_BOOL)-2);
+					dwFlags |= CF_DISABLEBEFORENAVFILTER;
+					OnNavigateCancelled(NULL, Cancel);
+					dwFlags &= ~CF_DISABLEBEFORENAVFILTER;
+					if (NULL != Cancel && VARIANT_TRUE == *Cancel)
+						return;
+				}
+			}
+		}
+
+		if (FALSE == ValidateURLHost(URL->bstrVal))
+		{
+			VARIANT StatusCode;
+			VariantInit(&StatusCode);
+			V_VT(&StatusCode) = VT_I4;
+			V_I4(&StatusCode) = INET_E_INVALID_URL;
+
+			dwFlags |= CF_DISABLEBEFORENAVFILTER;
+
+			*Cancel = VARIANT_TRUE;
+			OnNavigateError(pDispatch, URL, TargetFrameName, &StatusCode, Cancel);
+			Navigate2(URL, NULL, TargetFrameName, NULL, NULL);
+
+			dwFlags &= ~CF_DISABLEBEFORENAVFILTER;
+			if (NULL != Cancel && VARIANT_TRUE == *Cancel)
+				return;
+		}
+
+		IWebBrowser2 *pWebMine = NULL, *pWebFrame = NULL;
+		if (FAILED(GetIWebBrowser2(&pWebMine)))
+			pWebMine = NULL;
+
+		if (NULL == pDispatch ||
+			FAILED(pDispatch->QueryInterface(IID_IWebBrowser2, (void**)&pWebFrame)))
+		{
+			pWebFrame = NULL;
+		}
+
+		if (NULL != pWebMine) pWebMine->Release();
+		if (NULL != pWebFrame) pWebFrame->Release();
+
+		if (NULL != pWebMine && pWebMine == pWebFrame && NULL != URL && VT_BSTR == URL->vt && NULL != URL->bstrVal)
+		{
+			LPCWSTR pszTemplate = L"navcancl.htm#";
+			LPCWSTR pszEntry = StrStrIW(URL->bstrVal, pszTemplate);
+			if (NULL != pszEntry)
+			{
+				dwFlags |= CF_DISABLEBEFORENAVFILTER;
+				OnNavigateCancelled(pszEntry + lstrlenW(pszTemplate), Cancel);
+				dwFlags &= ~CF_DISABLEBEFORENAVFILTER;
+
+				if (NULL != Cancel && VARIANT_TRUE == *Cancel)
+					return;
+			}
+		}
+	}
+}
+
+STDMETHODIMP HTMLContainer2::RegisterBrowserCursor(INT nSysCurID, HCURSOR hCurToUse)
+{
+	IECURSOR *pCursor = (IECURSOR*)hCursors;
+	if (pCursor)
+	{
+		for (int i =0; i < nCursors; i++)
+		{
+			if (pCursor[i].nSysId == nSysCurID)
+			{
+				if (pCursor[i].hUser) DestroyCursor(pCursor[i].hUser);
+				pCursor[i].hSys = NULL;
+				if (hCurToUse) pCursor[i].hUser = hCurToUse;
+				else
+				{
+					MoveMemory(&pCursor[i], &pCursor[i + 1], sizeof(IECURSOR)*(nCursors - i - 1));
+					nCursors--;
+					if (!nCursors)
+					{
+						free(hCursors);
+						hCursors = NULL;
+					}
+
+					VOID* data = realloc(hCursors, sizeof(IECURSOR)*nCursors);
+					if (data) hCursors = data;
+					else return E_OUTOFMEMORY;
+				}
+				return S_OK;	
+			}
+		}
+	}
+
+	if (hCurToUse)
+	{
+		VOID *data = realloc(hCursors, sizeof(IECURSOR)*(nCursors + 1));
+		if (!data) return E_OUTOFMEMORY;
+		hCursors = data;
+		pCursor = (IECURSOR*)hCursors;
+		pCursor[nCursors].nSysId = nSysCurID;
+		pCursor[nCursors].hSys = NULL;
+		pCursor[nCursors].hUser = hCurToUse;
+		nCursors++;
+	}
+	return S_OK;
+}
+
+HRESULT HTMLContainer2::InternetSetFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, BOOL fEnable)
+{
+	if (NULL == libUrlmon.CoInternetSetFeatureEnabled)
+	{
+		HTMLContainer2_LoadLibray((LIBHDR*)&libUrlmon);
+		if (NULL == libUrlmon.CoInternetSetFeatureEnabled)
+		{			
+			return E_FAIL;
+		}
+	}
+	return libUrlmon.CoInternetSetFeatureEnabled(FeatureEntry, dwFlags, fEnable);
+}
+
+HRESULT HTMLContainer2::InternetIsFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags)
+{
+	if (NULL == libUrlmon.CoInternetIsFeatureEnabled)
+	{
+		HTMLContainer2_LoadLibray((LIBHDR*)&libUrlmon);
+		if (NULL == libUrlmon.CoInternetIsFeatureEnabled)
+		{			
+			return E_FAIL;
+		}
+	}
+	return libUrlmon.CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
+}
+
+void HTMLContainer2::ProcessRedirectedMessage(HWND hwnd, UINT messageId, LPARAM param)
+{
+	switch(messageId)
+	{
+		case HTMLContainer2::msgNavigate2:
+			{
+				RMNAVIGATE2 *pnp = (RMNAVIGATE2*)param;
+				if (NULL != pnp)
+				{
+					Navigate2(&pnp->URL, &pnp->Flags, NULL, NULL, &pnp->Headers);
+					VariantClear(&pnp->URL);
+					VariantClear(&pnp->Flags);
+					VariantClear(&pnp->TargetFrameName);
+					VariantClear(&pnp->PostData);
+					VariantClear(&pnp->Headers);
+					free(pnp);
+				}
+			}
+			break;
+
+		case HTMLContainer2::msgNavigateToName:
+			{
+				RMNAVIGATETONAME *pntn = (RMNAVIGATETONAME*)param;
+				if (NULL != pntn)
+				{
+					NavigateToName(pntn->url, pntn->flags);
+					free(pntn);
+				}
+			}
+			break;
+	}
+}
+
+#define SUBCLASS_UNKNOWN		0
+#define SUBCLASS_EMBED			1
+#define SUBCLASS_DOCOBJECT		2
+#define SUBCLASS_IESERVER		3
+
+typedef struct __SUBCLASSCTRL
+{
+	UINT	type;
+	WNDPROC originalProc;
+	HTMLContainer2 *container;
+} SUBCLASSCTRL;
+
+static LRESULT SubclassControl_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	SUBCLASSCTRL *psc = (SUBCLASSCTRL*)GetPropW(hwnd, WNDPROP_SCCTRLW);
+	if (NULL == psc || NULL == psc->originalProc)
+		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+
+	switch(uMsg)
+	{
+		case WM_NCDESTROY:
+		case WM_DESTROY: // detach
+			RemovePropW(hwnd, WNDPROP_SCCTRLW);
+			SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONGX86)(LONG_PTR)psc->originalProc);
+			CallWindowProcW(psc->originalProc, hwnd, uMsg, wParam, lParam);
+			free(psc);
+			return 0;
+
+		case WM_ERASEBKGND: 
+			if(	NULL != wParam &&
+				NULL != psc->container &&
+				(SUBCLASS_EMBED == psc->type || SUBCLASS_DOCOBJECT == psc->type))
+			{				
+				HWND hChild = GetWindow(hwnd, GW_CHILD);
+				if (NULL == hChild || 0 == (WS_VISIBLE & GetWindowLongPtrW(hChild, GWL_STYLE)))
+				{						
+					RECT paintRect;
+					if (FALSE != GetUpdateRect(hwnd, &paintRect, FALSE) ||
+						FALSE != GetClientRect(hwnd, &paintRect))
+					{
+						SetBkColor((HDC)wParam, psc->container->OnGetHostBkColor());
+						ExtTextOutW((HDC)wParam, 0, 0, ETO_OPAQUE, &paintRect, NULL, 0, NULL);
+					}
+				}
+			}
+			return 1;
+
+		case WM_SETFOCUS:
+			if (SUBCLASS_IESERVER == psc->type)
+			{	
+				if (NULL != psc->container)
+					psc->container->SetFocus(TRUE);
+			}
+			else
+			{
+				HWND hFocus = (HWND)wParam;
+				if (NULL != hFocus && IsWindowEnabled(hFocus))
+				{
+					HWND hRoot = GetAncestor(hwnd, GA_ROOT);
+					if (hFocus == hRoot || IsChild(hRoot, hFocus))
+					{
+						SetFocus(hFocus);
+						return 0;
+					}
+				}
+			}
+			break;
+
+		case WM_KILLFOCUS:
+			if (SUBCLASS_IESERVER == psc->type && NULL != psc->container)
+			{	
+				psc->container->SetFocus(FALSE);
+			}
+			break;
+
+		case WM_PARENTNOTIFY:
+			if ((SUBCLASS_EMBED == psc->type || SUBCLASS_DOCOBJECT == psc->type) &&
+				WM_CREATE == LOWORD(wParam) && 0L != lParam)
+			{				
+				SubclassControl_Attach((HWND)lParam,  psc->container);
+			}
+
+			if (SUBCLASS_EMBED == psc->type && WM_DESTROY == LOWORD(wParam) && NULL != lParam)
+			{
+				HWND hChild = (HWND)lParam;
+				WCHAR szClass[64] = {0};
+				if (0 != GetClassNameW(hChild, szClass, ARRAYSIZE(szClass)) &&
+					IS_EQUALCLASS(szClass, L"Shell DocObject View"))
+				{
+					HWND hPrimary = FindWindowExW(hwnd, NULL, L"Shell DocObject View", NULL);
+					if (hPrimary != NULL && hPrimary != hChild)
+					{
+						if(NULL != psc->container)
+							psc->container->OnClosePopupInternal();
+					}
+				}
+			}
+			break;
+
+		case WM_SETCURSOR:
+			if (SUBCLASS_IESERVER == psc->type && FALSE == bIsVistaOrHigher && 
+				NULL != psc->container && psc->container->nCursors)
+			{
+				ShowCursor(FALSE);
+				CallWindowProcW(psc->originalProc, hwnd, uMsg, wParam, lParam);
+
+				HCURSOR hCur = GetCursor();
+				IECURSOR *pCur = (IECURSOR*)(psc->container->hCursors);
+				for( int i= psc->container->nCursors -1; i > -1 ; i--)
+				{	
+					if (NULL == pCur[i].hSys)
+						pCur[i].hSys = LoadCursor(NULL, MAKEINTRESOURCE(pCur[i].nSysId));
+
+					if (pCur[i].hSys == hCur)
+					{
+						if (NULL != pCur[i].hUser)
+							SetCursor(pCur[i].hUser);
+						break;
+					}
+				}
+
+				ShowCursor(TRUE);
+
+				return TRUE;
+			}
+			break;
+		
+		case WM_CONTEXTMENU:
+			if (NULL != psc->container)
+			{
+				HANDLE hook = psc->container->InitializePopupHook(hwnd, uMsg, wParam, lParam);
+				if (NULL != hook)
+				{
+					LRESULT result = CallWindowProcW(psc->originalProc, hwnd, uMsg, wParam, lParam);
+					psc->container->DeletePopupHook(hook);
+					return result;
+				}
+			}
+			break;
+
+		case WM_INITMENUPOPUP:
+			if (NULL != psc->container)
+			{
+				psc->container->InitializeMenuPopup(hwnd, (HMENU)wParam, LOWORD(lParam), HIWORD(lParam));
+			}
+			break;
+
+		case WM_INPUTLANGCHANGEREQUEST:
+			if (SUBCLASS_IESERVER == psc->type && 
+				NULL != psc->container &&
+				FALSE != psc->container->InputLangChangeRequest(hwnd, (UINT)wParam, (HKL)lParam))
+			{
+				return 0;
+			}
+			break;
+
+		case WM_INPUTLANGCHANGE:
+			if (SUBCLASS_IESERVER == psc->type && NULL != psc->container)
+				psc->container->InputLangChange((UINT)wParam, (HKL)lParam);
+			break;
+	}
+
+	if (0 != WM_REDIRECTNAVIGATE && WM_REDIRECTNAVIGATE == uMsg)
+	{
+		if(SUBCLASS_EMBED == psc->type && NULL != psc->container)
+			psc->container->ProcessRedirectedMessage(hwnd, (UINT)wParam, lParam);
+		return TRUE;
+	}
+
+	if (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg && 
+		WM_NULL != WINAMP_WM_DIRECT_MOUSE_WHEEL)
+	{
+		ReplyMessage(TRUE);
+		SendMessageW(hwnd, WM_MOUSEWHEEL, wParam, lParam);
+		return TRUE;
+	}
+
+	return CallWindowProcW(psc->originalProc, hwnd, uMsg, wParam, lParam);
+}
+
+static BOOL SublassControl_IsAttached(HWND hwnd)
+{
+	SUBCLASSCTRL *psc = (SUBCLASSCTRL*)GetPropW(hwnd, WNDPROP_SCCTRLW);
+	return (NULL != psc);
+}
+
+static BOOL SubclassControl_Attach(HWND hControl, HTMLContainer2 *pContainer)
+{
+	if (NULL == hControl || FALSE == IsWindow(hControl))
+		return FALSE;
+
+	SUBCLASSCTRL *psc = (SUBCLASSCTRL*)GetPropW(hControl, WNDPROP_SCCTRLW);
+	if (NULL != psc) return TRUE;
+
+	UINT controlType = SUBCLASS_UNKNOWN;
+
+	if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
+		WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");
+
+	WCHAR szClass[128] = {0};
+	if (!GetClassNameW(hControl, szClass, ARRAYSIZE(szClass)))
+		return FALSE;
+
+	if (IS_EQUALCLASS(szClass, L"Shell Embedding")) controlType = SUBCLASS_EMBED;
+	else if (IS_EQUALCLASS(szClass, L"Shell DocObject View")) controlType = SUBCLASS_DOCOBJECT;
+	else if (IS_EQUALCLASS(szClass, L"Internet Explorer_Server")) controlType = SUBCLASS_IESERVER;
+
+	if (SUBCLASS_UNKNOWN == controlType)
+		return FALSE;
+
+	if (SUBCLASS_IESERVER != controlType)
+	{
+		DWORD styleEx = GetWindowStyleEx(hControl);
+		SetWindowLongPtrW(hControl, GWL_EXSTYLE, styleEx | WS_EX_CONTROLPARENT);
+	}
+	else
+	{
+		DWORD style = GetWindowStyle(hControl);
+		SetWindowLongPtrW(hControl, GWL_STYLE, style | WS_TABSTOP);
+	}
+
+	psc = (SUBCLASSCTRL*)calloc(1, sizeof(SUBCLASSCTRL));
+	if (NULL == psc) return FALSE;
+
+	psc->container = pContainer;
+	psc->type = controlType;
+	psc->originalProc = (WNDPROC)(LONG_PTR)SetWindowLongPtrW(hControl, GWLP_WNDPROC, (LONGX86)(LONG_PTR)SubclassControl_WindowProc);
+
+	if (NULL == psc->originalProc ||
+		FALSE == SetPropW(hControl, WNDPROP_SCCTRLW, psc))
+	{
+		if (NULL != psc->originalProc) 
+			SetWindowLongPtrW(hControl, GWLP_WNDPROC, (LONGX86)(LONG_PTR)psc->originalProc);
+		free(psc);
+		return FALSE;
+	}
+
+	return TRUE;
+}
\ No newline at end of file