random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/nu/HTMLContainer2.cpp

2108 lines
52 KiB
C++
Raw Blame History

#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;
}
Reference in New Issue View Git Blame Copy Permalink