system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-05 18:01:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/dlls/mshtml/tests/activex.c
Eric Pouech e06b668f40 mshtml/tests: Enable compilation with long types. 
Signed-off-by: Eric Pouech <eric.pouech@gmail.com>
Signed-off-by: Jacek Caban <jacek@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2022-03-02 20:17:25 +01:00

2803 lines
83 KiB
C
Raw Blame History

/*
* Copyright 2010 Jacek Caban for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#define CONST_VTABLE
#include <wine/test.h>
#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "ole2.h"
#include "mshtml.h"
#include "docobj.h"
#include "hlink.h"
#include "dispex.h"
#include "mshtmhst.h"
#include "activscp.h"
#include "objsafe.h"
#include "mshtmdid.h"
#include "mshtml_test.h"
#include "initguid.h"
#include "test_tlb.h"
#define DEFINE_EXPECT(func) \
static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
#define SET_EXPECT(func) \
do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
#define CHECK_EXPECT2(func) \
do { \
ok(expect_ ##func, "unexpected call " #func "\n"); \
called_ ## func = TRUE; \
}while(0)
#define CHECK_EXPECT(func) \
do { \
CHECK_EXPECT2(func); \
expect_ ## func = FALSE; \
}while(0)
#define CHECK_CALLED(func) \
do { \
ok(called_ ## func, "expected " #func "\n"); \
expect_ ## func = called_ ## func = FALSE; \
}while(0)
#define CLEAR_CALLED(func) \
expect_ ## func = called_ ## func = FALSE
#undef GetClassInfo
DEFINE_EXPECT(CreateInstance);
DEFINE_EXPECT(FreezeEvents_TRUE);
DEFINE_EXPECT(FreezeEvents_FALSE);
DEFINE_EXPECT(QuickActivate);
DEFINE_EXPECT(IPersistPropertyBag_InitNew);
DEFINE_EXPECT(IPersistPropertyBag_Load);
DEFINE_EXPECT(Invoke_READYSTATE);
DEFINE_EXPECT(Invoke_ENABLED);
DEFINE_EXPECT(Invoke_VALID);
DEFINE_EXPECT(Invoke_SECURITYCTX);
DEFINE_EXPECT(Invoke_SCRIPTPROP);
DEFINE_EXPECT(Invoke_SCRIPTCALL);
DEFINE_EXPECT(GetIDsOfNames_scriptprop);
DEFINE_EXPECT(DoVerb);
DEFINE_EXPECT(SetExtent);
DEFINE_EXPECT(GetExtent);
DEFINE_EXPECT(SetClientSite);
DEFINE_EXPECT(SetClientSite_NULL);
DEFINE_EXPECT(Close);
DEFINE_EXPECT(InPlaceObject_GetWindow);
DEFINE_EXPECT(SetObjectRects);
DEFINE_EXPECT(InPlaceDeactivate);
DEFINE_EXPECT(UIDeactivate);
DEFINE_EXPECT(QueryService_TestActiveX);
DEFINE_EXPECT(GetMiscStatus);
DEFINE_EXPECT(SetAdvise);
DEFINE_EXPECT(GetViewStatus);
DEFINE_EXPECT(QI_ITestActiveX);
DEFINE_EXPECT(wrapped_AddRef);
DEFINE_EXPECT(wrapped_Release);
DEFINE_EXPECT(wrapped_func);
DEFINE_EXPECT(OnAmbientPropertyChange_UNKNOWN);
DEFINE_EXPECT(GetTypeInfo);
DEFINE_EXPECT(GetClassInfo);
DEFINE_EXPECT(FindConnectionPoint);
DEFINE_EXPECT(Advise);
DEFINE_EXPECT(Unadvise);
#define DISPID_SCRIPTPROP 1000
#define DISPID_SCRIPTCALL 1001
enum {
TEST_FLASH,
TEST_NOQUICKACT,
TEST_DISPONLY
};
static ITypeInfo *actxtest_typeinfo, *class_typeinfo;
static HWND container_hwnd, plugin_hwnd;
static int plugin_behavior;
static BOOL no_quickact;
static LONG activex_refcnt;
#define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
static const GUID CLSID_TestActiveX =
{0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
static const GUID IID_ITestActiveX =
{0x178fc663,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
static const char object_ax_str[] =
"<html><head></head><body>"
"<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
"<param name=\"param_name\" value=\"param_value\">"
"<param name=\"num_param\" value=\"3\">"
"</object>"
"<script>"
"objid.scriptCall();"
"</script>"
"</body></html>";
static const char event_binding_str[] =
"<html><head></head><body>"
"<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
"<param name=\"param_name\" value=\"param_value\">"
"<param name=\"num_param\" value=\"3\">"
"</object>"
"<script for=\"objid\" event=\"testfunc\">return 6;</script>"
"<script for=\"objid\" event=\"testfunc2(x,y)\">return x+2*y;</script>"
"</body></html>";
static REFIID pluginhost_iids[] = {
&IID_IOleClientSite,
&IID_IAdviseSink,
&IID_IAdviseSinkEx,
&IID_IPropertyNotifySink,
&IID_IDispatch,
&IID_IOleWindow,
&IID_IOleInPlaceSite,
&IID_IOleInPlaceSiteEx,
&IID_IOleControlSite,
&IID_IBindHost,
&IID_IServiceProvider,
NULL
};
static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
{
IUnknown *unk1, *unk2;
if(iface1 == iface2)
return TRUE;
IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
IUnknown_Release(unk1);
IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
IUnknown_Release(unk2);
return unk1 == unk2;
}
#define test_ifaces(i,ids) _test_ifaces(__LINE__,i,ids)
static void _test_ifaces(unsigned line, IUnknown *iface, REFIID *iids)
{
const IID * const *piid;
IUnknown *unk;
HRESULT hres;
for(piid = iids; *piid; piid++) {
hres = IUnknown_QueryInterface(iface, *piid, (void**)&unk);
ok_(__FILE__,line) (hres == S_OK, "Could not get %s interface: %08lx\n", wine_dbgstr_guid(*piid), hres);
if(SUCCEEDED(hres))
IUnknown_Release(unk);
}
}
static IOleClientSite *client_site;
static IDispatch *sink_disp;
static READYSTATE plugin_readystate = READYSTATE_UNINITIALIZED;
static BOOL have_container;
static void set_plugin_readystate(READYSTATE state)
{
IPropertyNotifySink *prop_notif;
HRESULT hres;
plugin_readystate = state;
hres = IOleClientSite_QueryInterface(client_site, &IID_IPropertyNotifySink, (void**)&prop_notif);
ok(hres == S_OK, "Could not get IPropertyNotifySink iface: %08lx\n", hres);
hres = IPropertyNotifySink_OnChanged(prop_notif, DISPID_READYSTATE);
ok(hres == S_OK, "OnChanged(DISPID_READYSTATE) failed: %08lx\n", hres);
IPropertyNotifySink_Release(prop_notif);
}
static void test_mon_displayname(IMoniker *mon, const WCHAR *exname, const WCHAR *broken_name)
{
LPOLESTR display_name;
DWORD mksys;
HRESULT hres;
hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
ok(hres == S_OK, "GetDisplayName failed: %08lx\n", hres);
ok(!lstrcmpW(display_name, exname) || broken(broken_name && !lstrcmpW(display_name, broken_name)),
"display_name = %s\n", wine_dbgstr_w(display_name));
CoTaskMemFree(display_name);
hres = IMoniker_IsSystemMoniker(mon, &mksys);
ok(hres == S_OK, "IsSystemMoniker failed: %08lx\n", hres);
ok(mksys == MKSYS_URLMONIKER, "mksys = %ld\n", mksys);
}
static LRESULT WINAPI plugin_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg) {
case WM_PAINT: {
PAINTSTRUCT ps;
HBRUSH brush;
RECT rect;
HDC dc;
GetClientRect(hwnd, &rect);
dc = BeginPaint(hwnd, &ps);
brush = CreateSolidBrush(RGB(255,0,0));
SelectObject(dc, brush);
Rectangle(dc, rect.left, rect.top, rect.right, rect.bottom);
DeleteObject(brush);
EndPaint(hwnd, &ps);
break;
}
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
static void create_plugin_window(HWND parent, const RECT *rect)
{
static const WCHAR plugin_testW[] =
{'p','l','u','g','i','n',' ','t','e','s','t',0};
static WNDCLASSEXW wndclass = {
sizeof(WNDCLASSEXW),
0,
plugin_proc,
0, 0, NULL, NULL, NULL, NULL, NULL,
plugin_testW,
NULL
};
RegisterClassExW(&wndclass);
plugin_hwnd = CreateWindowW(plugin_testW, plugin_testW,
WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, rect->left, rect->top,
rect->right-rect->left, rect->bottom-rect->top, parent, NULL, NULL, NULL);
}
static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface, REFIID riid, void **ppv)
{
ok(0, "unexpected QI call %s\n", wine_dbgstr_guid(riid));
return E_NOINTERFACE;
}
static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
{
return 2;
}
static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
{
return 1;
}
static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
IConnectionPointContainer **ppCPC)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink, DWORD *pdwCookie)
{
DispActiveXTest *ax_test;
IDispatchEx *dispex;
HRESULT hres;
CHECK_EXPECT(Advise);
hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink_disp);
ok(hres == S_OK, "Could not get IDispatch iface: %08lx\n", hres);
hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatchEx, (void**)&dispex);
ok(hres == E_NOINTERFACE, "QueryInterface(IID_IDispatchEx) returned: %08lx\n", hres);
hres = IUnknown_QueryInterface(pUnkSink, &DIID_DispActiveXTest, (void**)&ax_test);
ok(hres == S_OK, "Could not get DispActiveXTest iface: %08lx\n", hres);
DispActiveXTest_Release(ax_test);
*pdwCookie = 0xdeadbeef;
return S_OK;
}
static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
{
CHECK_EXPECT(Unadvise);
ok(dwCookie == 0xdeadbeef, "dwCookie = %lx\n", dwCookie);
if(sink_disp) {
IDispatch_Release(sink_disp);
sink_disp = NULL;
}
return S_OK;
}
static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface, IEnumConnections **ppEnum)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IConnectionPointVtbl ConnectionPointVtbl = {
ConnectionPoint_QueryInterface,
ConnectionPoint_AddRef,
ConnectionPoint_Release,
ConnectionPoint_GetConnectionInterface,
ConnectionPoint_GetConnectionPointContainer,
ConnectionPoint_Advise,
ConnectionPoint_Unadvise,
ConnectionPoint_EnumConnections
};
static IConnectionPoint ConnectionPoint = { &ConnectionPointVtbl };
static HRESULT ax_qi(REFIID,void**);
static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI OleControl_Release(IOleControl *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
{
switch(dispID) {
case DISPID_UNKNOWN:
CHECK_EXPECT2(OnAmbientPropertyChange_UNKNOWN);
break;
default:
ok(0, "unexpected call %ld\n", dispID);
}
return S_OK;
}
static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
{
if(bFreeze)
CHECK_EXPECT2(FreezeEvents_TRUE);
else
CHECK_EXPECT2(FreezeEvents_FALSE);
return S_OK;
}
static const IOleControlVtbl OleControlVtbl = {
OleControl_QueryInterface,
OleControl_AddRef,
OleControl_Release,
OleControl_GetControlInfo,
OleControl_OnMnemonic,
OleControl_OnAmbientPropertyChange,
OleControl_FreezeEvents
};
static IOleControl OleControl = { &OleControlVtbl };
static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
{
CHECK_EXPECT(QuickActivate);
ok(container != NULL, "container == NULL\n");
ok(container->cbSize == sizeof(*container), "container->cbSize = %ld\n", container->cbSize);
ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
"container->dwAmbientFlags = %lx\n", container->dwAmbientFlags);
if(have_container)
ok(!container->colorFore, "container->colorFore = %ld\n", container->colorFore); /* FIXME */
todo_wine
ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
if(have_container)
todo_wine ok(container->pFont != NULL, "container->pFont == NULL\n");
else
ok(!container->pFont, "container->pFont = %p\n", container->pFont);
todo_wine
ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
ok(!container->dwAppearance, "container->dwAppearance = %lx\n", container->dwAppearance);
if(have_container)
ok(!container->lcid, "container->lcid = %lx\n", container->lcid);
ok(!container->hpal, "container->hpal = %p\n", container->hpal);
ok(!container->pBindHost, "container->pBindHost != NULL\n");
ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
ok(control->cbSize == sizeof(*control), "control->cbSize = %ld\n", control->cbSize);
ok(!control->dwMiscStatus, "control->dwMiscStatus = %lx\n", control->dwMiscStatus);
ok(!control->dwViewStatus, "control->dwViewStatus = %lx\n", control->dwViewStatus);
ok(!control->dwEventCookie, "control->dwEventCookie = %lx\n", control->dwEventCookie);
ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %lx\n", control->dwPropNotifyCookie);
ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %lx\n", control->dwPointerActivationPolicy);
ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
"container->pClientSite != container->pAdviseSink\n");
ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pPropertyNotifySink),
"container->pClientSite != container->pPropertyNotifySink\n");
test_ifaces((IUnknown*)container->pClientSite, pluginhost_iids);
IOleClientSite_AddRef(container->pClientSite);
client_site = container->pClientSite;
control->dwMiscStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
|OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
control->dwViewStatus = 0x18;
control->dwPropNotifyCookie = 1;
return S_OK;
}
static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IQuickActivateVtbl QuickActivateVtbl = {
QuickActivate_QueryInterface,
QuickActivate_AddRef,
QuickActivate_Release,
QuickActivate_QuickActivate,
QuickActivate_GetContentExtent,
QuickActivate_SetContentExtent
};
static IQuickActivate QuickActivate = { &QuickActivateVtbl };
static HRESULT WINAPI PersistPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI PersistPropertyBag_AddRef(IPersistPropertyBag *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI PersistPropertyBag_Release(IPersistPropertyBag *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI PersistPropertyBag_GetClassID(IPersistPropertyBag *face, CLSID *pClassID)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI PersistPropertyBag_InitNew(IPersistPropertyBag *face)
{
CHECK_EXPECT(IPersistPropertyBag_InitNew);
return S_OK;
}
static HRESULT WINAPI PersistPropertyBag_Load(IPersistPropertyBag *face, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
{
IBindHost *bind_host, *bind_host2;
IServiceProvider *sp;
IMoniker *mon;
VARIANT v;
HRESULT hres;
static const WCHAR param_nameW[] = {'p','a','r','a','m','_','n','a','m','e',0};
static const WCHAR num_paramW[] = {'n','u','m','_','p','a','r','a','m',0};
static const WCHAR no_paramW[] = {'n','o','_','p','a','r','a','m',0};
static WCHAR test_swfW[] = {'t','e','s','t','.','s','w','f',0};
static const IID *propbag_ifaces[] = {
&IID_IPropertyBag,
&IID_IPropertyBag2,
NULL
};
CHECK_EXPECT(IPersistPropertyBag_Load);
ok(pPropBag != NULL, "pPropBag == NULL\n");
ok(!pErrorLog, "pErrorLog != NULL\n");
test_ifaces((IUnknown*)pPropBag, propbag_ifaces);
V_VT(&v) = VT_BSTR;
hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
ok(hres == S_OK, "Read failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), L"param_value"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
V_VT(&v) = VT_I4;
V_I4(&v) = 0xdeadbeef;
hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
ok(hres == DISP_E_TYPEMISMATCH, "Read failed: %08lx, expected DISP_E_TYPEMISMATCH\n", hres);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0xdeadbeef, "V_I4(v) = %lx\n", V_I4(&v));
V_VT(&v) = VT_BSTR;
hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
ok(hres == S_OK, "Read failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), L"3"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
SysFreeString(V_BSTR(&v));
V_VT(&v) = VT_I4;
V_I4(&v) = 0xdeadbeef;
hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
ok(hres == S_OK, "Read failed: %08lx\n", hres);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 3, "V_I4(v) = %lx\n", V_I4(&v));
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = (BSTR)0xdeadbeef;
hres = IPropertyBag_Read(pPropBag, no_paramW, &v, NULL);
ok(hres == E_INVALIDARG, "Read failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_BSTR(&v) == (BSTR)0xdeadbeef, "V_BSTR(v) = %p\n", V_BSTR(&v));
set_plugin_readystate(READYSTATE_INTERACTIVE);
hres = IOleClientSite_QueryInterface(client_site, &IID_IBindHost, (void**)&bind_host);
ok(hres == S_OK, "Could not get IBindHost iface: %08lx\n", hres);
hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&sp);
ok(hres == S_OK, "Could not get IServiceProvider iface: %08lx\n", hres);
hres = IServiceProvider_QueryService(sp, &SID_SBindHost, &IID_IBindHost, (void**)&bind_host2);
ok(hres == S_OK, "QueryService(SID_SBindHost) failed: %08lx\n", hres);
IServiceProvider_Release(sp);
ok(iface_cmp((IUnknown*)bind_host, (IUnknown*)bind_host2), "bind_host != bind_host2\n");
IBindHost_Release(bind_host2);
mon = NULL;
hres = IBindHost_CreateMoniker(bind_host, test_swfW, NULL, &mon, 0);
ok(hres == S_OK, "CreateMoniker failed: %08lx\n", hres);
ok(mon != NULL, "mon == NULL\n");
test_mon_displayname(mon, L"about:test.swf", L"about:blanktest.swf");
IMoniker_Release(mon);
IBindHost_Release(bind_host);
mon = NULL;
hres = IOleClientSite_GetMoniker(client_site, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &mon);
ok(hres == S_OK, "GetMoniker failed: %08lx\n", hres);
ok(mon != NULL, "mon == NULL\n");
test_mon_displayname(mon, L"about:blank", NULL);
IMoniker_Release(mon);
set_plugin_readystate(READYSTATE_COMPLETE);
return S_OK;
}
static HRESULT WINAPI PersistPropertyBag_Save(IPersistPropertyBag *face, IPropertyBag *pPropBag, BOOL fClearDisrty, BOOL fSaveAllProperties)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
PersistPropertyBag_QueryInterface,
PersistPropertyBag_AddRef,
PersistPropertyBag_Release,
PersistPropertyBag_GetClassID,
PersistPropertyBag_InitNew,
PersistPropertyBag_Load,
PersistPropertyBag_Save
};
static IPersistPropertyBag PersistPropertyBag = { &PersistPropertyBagVtbl };
static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI Dispatch_Release(IDispatch *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
ITypeInfo **ppTInfo)
{
CHECK_EXPECT(GetTypeInfo);
ITypeInfo_AddRef(actxtest_typeinfo);
*ppTInfo = actxtest_typeinfo;
return S_OK;
}
static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
UINT cNames, LCID lcid, DISPID *rgDispId)
{
ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", wine_dbgstr_guid(riid));
ok(cNames == 1, "cNames = %d\n", cNames);
ok(rgszNames != NULL, "rgszNames == NULL\n");
ok(rgDispId != NULL, "rgDispId == NULL\n");
if(!lstrcmpW(rgszNames[0], L"scriptprop")) {
CHECK_EXPECT(GetIDsOfNames_scriptprop);
*rgDispId = DISPID_SCRIPTPROP;
}else if(!lstrcmpW(rgszNames[0], L"scriptCall")) {
*rgDispId = DISPID_SCRIPTCALL;
}else {
ok(0, "rgszNames[0] = %s\n", wine_dbgstr_w(rgszNames[0]));
}
return S_OK;
}
static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", wine_dbgstr_guid(riid));
ok(pDispParams != NULL, "pDispParams == NULL\n");
ok(!pDispParams->cNamedArgs, "pDispParams->cNamedArgs = %d\n", pDispParams->cNamedArgs);
ok(!pDispParams->rgdispidNamedArgs, "pDispParams->rgdispidNamedArgs != NULL\n");
switch(dispIdMember) {
case DISPID_READYSTATE:
CHECK_EXPECT2(Invoke_READYSTATE);
ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
ok(!pExcepInfo, "pExcepInfo != NULL\n");
ok(puArgErr != NULL, "puArgErr == NULL\n");
ok(pVarResult != NULL, "pVarResult == NULL\n");
V_VT(pVarResult) = VT_I4;
V_I4(pVarResult) = plugin_readystate;
return S_OK;
case DISPID_ENABLED:
CHECK_EXPECT2(Invoke_ENABLED);
ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
ok(!pExcepInfo, "pExcepInfo != NULL\n");
ok(puArgErr != NULL, "puArgErr == NULL\n");
ok(pVarResult != NULL, "pVarResult == NULL\n");
return DISP_E_MEMBERNOTFOUND;
case DISPID_VALID:
CHECK_EXPECT(Invoke_VALID);
ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
ok(!pExcepInfo, "pExcepInfo != NULL\n");
ok(puArgErr != NULL, "puArgErr == NULL\n");
ok(pVarResult != NULL, "pVarResult == NULL\n");
return DISP_E_MEMBERNOTFOUND;
case DISPID_SECURITYCTX:
CHECK_EXPECT(Invoke_SECURITYCTX);
ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
ok(!pExcepInfo, "pExcepInfo != NULL\n");
ok(puArgErr != NULL, "puArgErr == NULL\n");
ok(pVarResult != NULL, "pVarResult == NULL\n");
return DISP_E_MEMBERNOTFOUND;
case DISPID_SCRIPTPROP:
CHECK_EXPECT(Invoke_SCRIPTPROP);
ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
ok(!puArgErr, "puArgErr != NULL\n");
ok(pVarResult != NULL, "pVarResult == NULL\n");
V_VT(pVarResult) = VT_I4;
V_I4(pVarResult) = 4;
return S_OK;
case DISPID_SCRIPTCALL:
CHECK_EXPECT(Invoke_SCRIPTCALL);
ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
ok(!puArgErr, "puArgErr != NULL\n");
ok(!pVarResult, "pVarResult != NULL\n");
/*
V_VT(pVarResult) = VT_I4;
V_I4(pVarResult) = 4;
*/
return S_OK;
default:
ok(0, "unexpected call %ld\n", dispIdMember);
}
return E_NOTIMPL;
}
static const IDispatchVtbl DispatchVtbl = {
Dispatch_QueryInterface,
Dispatch_AddRef,
Dispatch_Release,
Dispatch_GetTypeInfoCount,
Dispatch_GetTypeInfo,
Dispatch_GetIDsOfNames,
Dispatch_Invoke
};
static IDispatch Dispatch = { &DispatchVtbl };
static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo *iface, ITypeInfo **ppTI)
{
CHECK_EXPECT(GetClassInfo);
ITypeInfo_AddRef(class_typeinfo);
*ppTI = class_typeinfo;
return S_OK;
}
static const IProvideClassInfoVtbl ProvideClassInfoVtbl = {
ProvideClassInfo_QueryInterface,
ProvideClassInfo_AddRef,
ProvideClassInfo_Release,
ProvideClassInfo_GetClassInfo
};
static IProvideClassInfo ProvideClassInfo = { &ProvideClassInfoVtbl };
static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
IEnumConnectionPoints **ppEnum)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
REFIID riid, IConnectionPoint **ppCP)
{
if(IsEqualGUID(riid, &IID_IPropertyNotifySink)) {
/* TODO */
trace("FindConnectionPoint(IID_IPropertyNotifySink)\n");
return CONNECT_E_NOCONNECTION;
}
CHECK_EXPECT(FindConnectionPoint);
ok(IsEqualGUID(riid, &DIID_DispActiveXTest), "riid = %s\n", wine_dbgstr_guid(riid));
IConnectionPoint_AddRef(&ConnectionPoint);
*ppCP = &ConnectionPoint;
return S_OK;
}
static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
ConnectionPointContainer_QueryInterface,
ConnectionPointContainer_AddRef,
ConnectionPointContainer_Release,
ConnectionPointContainer_EnumConnectionPoints,
ConnectionPointContainer_FindConnectionPoint
};
static IConnectionPointContainer ConnectionPointContainer = { &ConnectionPointContainerVtbl };
static HRESULT WINAPI ViewObjectEx_QueryInterface(IViewObjectEx *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI ViewObjectEx_AddRef(IViewObjectEx *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI ViewObjectEx_Release(IViewObjectEx *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI ViewObjectEx_Draw(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBoungs, BOOL (WINAPI*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_GetColorSet(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
HDC hicTargetDev, LOGPALETTE **ppColorSet)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_Freeze(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_Unfreeze(IViewObjectEx *iface, DWORD dwFreeze)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_SetAdvise(IViewObjectEx *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
{
CHECK_EXPECT(SetAdvise);
ok(aspects == DVASPECT_CONTENT, "aspects = %lx\n", aspects);
ok(!advf, "advf = %lx\n", advf);
ok(pAdvSink != NULL, "pAdvSink = NULL\n");
return S_OK;
}
static HRESULT WINAPI ViewObjectEx_GetAdvise(IViewObjectEx *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_GetExtent(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_GetRect(IViewObjectEx *iface, DWORD dwAspect, LPRECTL pRect)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_GetViewStatus(IViewObjectEx *iface, DWORD *pdwStatus)
{
CHECK_EXPECT(GetViewStatus);
*pdwStatus = VIEWSTATUS_OPAQUE|VIEWSTATUS_SOLIDBKGND;
return S_OK;
}
static HRESULT WINAPI ViewObjectEx_QueryHitPoint(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc,
LONG lCloseHint, DWORD *pHitResult)
{
trace("QueryHitPoint call ignored\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_QueryHitRect(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc,
LONG lCloseHint, DWORD *pHitResult)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ViewObjectEx_GetNaturalExtent(IViewObjectEx *iface, DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd,
HDC hicTargetDev, DVEXTENTINFO *pExtentIngo, LPSIZEL pSizel)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IViewObjectExVtbl ViewObjectExVtbl = {
ViewObjectEx_QueryInterface,
ViewObjectEx_AddRef,
ViewObjectEx_Release,
ViewObjectEx_Draw,
ViewObjectEx_GetColorSet,
ViewObjectEx_Freeze,
ViewObjectEx_Unfreeze,
ViewObjectEx_SetAdvise,
ViewObjectEx_GetAdvise,
ViewObjectEx_GetExtent,
ViewObjectEx_GetRect,
ViewObjectEx_GetViewStatus,
ViewObjectEx_QueryHitPoint,
ViewObjectEx_QueryHitRect,
ViewObjectEx_GetNaturalExtent
};
static IViewObjectEx ViewObjectEx = { &ViewObjectExVtbl };
static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI OleObject_Release(IOleObject *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
{
if(!pClientSite) {
CHECK_EXPECT(SetClientSite_NULL);
return S_OK;
}
CHECK_EXPECT(SetClientSite);
IOleClientSite_AddRef(pClientSite);
client_site = pClientSite;
return S_OK;
}
static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
{
CHECK_EXPECT(Close);
ok(dwSaveOption == OLECLOSE_NOSAVE, "dwSaveOption = %ld\n", dwSaveOption);
return S_OK;
}
static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
DWORD dwReserved)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
{
OLEINPLACEFRAMEINFO frame_info = {0xdeadbeef};
IOleInPlaceUIWindow *ip_uiwindow;
IOleInPlaceFrame *ip_frame;
IOleInPlaceSiteEx *ip_site;
RECT pos_rect, clip_rect;
BOOL no_redraw;
HWND hwnd;
HRESULT hres;
CHECK_EXPECT(DoVerb);
ok(iVerb == OLEIVERB_INPLACEACTIVATE, "iVerb = %ld\n", iVerb);
ok(!lpmsg, "lpmsg != NULL\n");
ok(pActiveSite != NULL, "pActiveSite == NULL\n");
ok(!lindex, "lindex = %ld\n", lindex);
ok(hwndParent != NULL, "hwndParent == NULL\n");
ok(lprcPosRect != NULL, "lprcPosRect == NULL\n");
hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleInPlaceSiteEx, (void**)&ip_site);
ok(hres == S_OK, "Could not get IOleInPlaceSiteEx iface: %08lx\n", hres);
hres = IOleInPlaceSiteEx_CanInPlaceActivate(ip_site);
ok(hres == S_OK, "CanInPlaceActivate failed: %08lx\n", hres);
SET_EXPECT(InPlaceObject_GetWindow);
no_redraw = 0xdeadbeef;
hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
ok(hres == S_OK, "InPlaceActivateEx failed: %08lx\n", hres);
ok(!no_redraw, "no_redraw = %x\n", no_redraw);
CHECK_CALLED(InPlaceObject_GetWindow);
no_redraw = 0xdeadbeef;
hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
ok(hres == S_OK, "InPlaceActivateEx failed: %08lx\n", hres);
ok(no_redraw == 0xdeadbeef, "no_redraw = %x\n", no_redraw);
hwnd = NULL;
hres = IOleInPlaceSiteEx_GetWindow(ip_site, &hwnd);
ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
ok(hwnd != NULL, "hwnd == NULL\n");
ok(hwnd == hwndParent, "hwnd != hwndParent\n");
create_plugin_window(hwnd, lprcPosRect);
ip_frame = NULL;
ip_uiwindow = NULL;
frame_info.cb = sizeof(OLEINPLACEFRAMEINFO);
hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
ok(hres == S_OK, "GetWindowContext failed: %08lx\n", hres);
ok(ip_frame != NULL, "ip_frame == NULL\n");
ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
ok(EqualRect(&pos_rect, lprcPosRect), "pos_rect != lpecPosRect\n");
ok(EqualRect(&clip_rect, lprcPosRect), "clip_rect != lpecPosRect\n");
ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
ok(!frame_info.haccel, "frame_info.haccel != 0\n");
ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
IOleInPlaceFrame_Release(ip_frame);
IOleInPlaceUIWindow_Release(ip_uiwindow);
IOleInPlaceSiteEx_Release(ip_site);
hres = IOleClientSite_ShowObject(client_site);
ok(hres == S_OK, "ShowObject failed: %08lx\n", hres);
SET_EXPECT(InPlaceObject_GetWindow);
SET_EXPECT(SetObjectRects);
return S_OK;
}
static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_Update(IOleObject *iface)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
{
CHECK_EXPECT(SetExtent);
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
{
CHECK_EXPECT(GetExtent);
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
{
CHECK_EXPECT(GetMiscStatus);
ok(dwAspect == DVASPECT_CONTENT, "dwAspect = %ld\n", dwAspect);
ok(pdwStatus != NULL, "pdwStatus == NULL\n");
*pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE
|OLEMISC_INSIDEOUT|OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
return S_OK;
}
static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IOleObjectVtbl OleObjectVtbl = {
OleObject_QueryInterface,
OleObject_AddRef,
OleObject_Release,
OleObject_SetClientSite,
OleObject_GetClientSite,
OleObject_SetHostNames,
OleObject_Close,
OleObject_SetMoniker,
OleObject_GetMoniker,
OleObject_InitFromData,
OleObject_GetClipboardData,
OleObject_DoVerb,
OleObject_EnumVerbs,
OleObject_Update,
OleObject_IsUpToDate,
OleObject_GetUserClassID,
OleObject_GetUserType,
OleObject_SetExtent,
OleObject_GetExtent,
OleObject_Advise,
OleObject_Unadvise,
OleObject_EnumAdvise,
OleObject_GetMiscStatus,
OleObject_SetColorScheme
};
static IOleObject OleObject = { &OleObjectVtbl };
static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
REFIID riid, void **ppv)
{
return ax_qi(riid, ppv);
}
static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
{
return ++activex_refcnt;
}
static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
{
return --activex_refcnt;
}
static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
HWND *phwnd)
{
CHECK_EXPECT2(InPlaceObject_GetWindow);
ok(phwnd != NULL, "phwnd == NULL\n");
*phwnd = plugin_hwnd;
return *phwnd ? S_OK : E_UNEXPECTED;
}
static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
BOOL fEnterMode)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
{
IOleInPlaceSite *ip_site;
HRESULT hres;
CHECK_EXPECT(InPlaceDeactivate);
hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08lx\n", hres);
hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
ok(hres == S_OK, "OnInPlaceDeactivate failed: %08lx\n", hres);
IOleInPlaceSite_Release(ip_site);
return S_OK;
}
static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
{
CHECK_EXPECT2(UIDeactivate);
return S_OK;
}
static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
LPCRECT lprcPosRect, LPCRECT lprcClipRect)
{
CHECK_EXPECT2(SetObjectRects);
return S_OK;
}
static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
IDropTarget **ppDropTarget)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
OleInPlaceObject_QueryInterface,
OleInPlaceObject_AddRef,
OleInPlaceObject_Release,
OleInPlaceObject_GetWindow,
OleInPlaceObject_ContextSensitiveHelp,
OleInPlaceObject_InPlaceDeactivate,
OleInPlaceObject_UIDeactivate,
OleInPlaceObject_SetObjectRects,
OleInPlaceObjectWindowless_ReactivateAndUndo,
OleInPlaceObjectWindowless_OnWindowMessage,
OleInPlaceObjectWindowless_GetDropTarget
};
static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
static void *wrapped_iface_vtbl[100];
static IUnknown wrapped_iface = { (IUnknownVtbl*)wrapped_iface_vtbl };
static HRESULT WINAPI wrapped_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
{
ok(0, "unexpected wrapped_QueryInterface call\n");
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI wrapped_AddRef(IUnknown *iface)
{
CHECK_EXPECT(wrapped_AddRef);
return 2;
}
static ULONG WINAPI wrapped_Release(IUnknown *iface)
{
CHECK_EXPECT(wrapped_Release);
return 1;
}
static HRESULT WINAPI wrapped_func_nocall(IUnknown *iface, int i, double d)
{
ok(0, "unexpected call\n");
return E_FAIL;
}
static HRESULT WINAPI wrapped_func(IUnknown *iface, int i, double d)
{
CHECK_EXPECT(wrapped_func);
ok(iface == &wrapped_iface, "iface != wrapped_iface\n");
ok(i == 10, "i = %d\n", i);
ok(d == 32.0, "d = %lf\n", d);
return S_OK;
}
static void init_wrapped_iface(void)
{
unsigned i;
wrapped_iface_vtbl[0] = wrapped_QueryInterface;
wrapped_iface_vtbl[1] = wrapped_AddRef;
wrapped_iface_vtbl[2] = wrapped_Release;
for(i=3; i<100; i++)
wrapped_iface_vtbl[i] = wrapped_func_nocall;
wrapped_iface_vtbl[63] = wrapped_func;
}
static HRESULT ax_qi(REFIID riid, void **ppv)
{
if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
*ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleControl;
}else if(IsEqualGUID(riid, &IID_IQuickActivate)) {
*ppv = no_quickact ? NULL : &QuickActivate;
}else if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
*ppv = no_quickact ? NULL : &PersistPropertyBag;
}else if(IsEqualGUID(riid, &IID_IDispatch)) {
*ppv = &Dispatch;
}else if(IsEqualGUID(riid, &IID_IProvideClassInfo)) {
*ppv = &ProvideClassInfo;
}else if(IsEqualGUID(riid, &IID_IConnectionPointContainer)) {
*ppv = plugin_behavior != TEST_DISPONLY ? &ConnectionPointContainer : NULL;
}else if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2)
|| IsEqualGUID(riid, &IID_IViewObjectEx)) {
*ppv = plugin_behavior == TEST_DISPONLY ? NULL : &ViewObjectEx;
}else if(IsEqualGUID(riid, &IID_IOleObject)) {
*ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleObject;
}else if(IsEqualGUID(riid, &IID_ITestActiveX)) {
CHECK_EXPECT(QI_ITestActiveX);
*ppv = &wrapped_iface;
return S_OK;
}else if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
|| IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
*ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleInPlaceObjectWindowless;
}else {
trace("QI %s\n", wine_dbgstr_guid(riid));
*ppv = NULL;
}
if(!*ppv)
return E_NOINTERFACE;
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
{
*ppv = NULL;
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
*ppv = iface;
return S_OK;
}
if(IsEqualGUID(&IID_IMarshal, riid))
return E_NOINTERFACE;
if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
return E_NOINTERFACE;
if(IsEqualGUID(&IID_IClassFactoryEx, riid))
return E_NOINTERFACE; /* TODO */
ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
return E_NOTIMPL;
}
static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
{
return 2;
}
static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
{
return 1;
}
static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
{
CHECK_EXPECT(CreateInstance);
ok(!outer, "outer = %p\n", outer);
ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", wine_dbgstr_guid(riid));
activex_refcnt++;
*ppv = &OleControl;
return S_OK;
}
static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
{
ok(0, "unexpected call\n");
return S_OK;
}
static const IClassFactoryVtbl ClassFactoryVtbl = {
ClassFactory_QueryInterface,
ClassFactory_AddRef,
ClassFactory_Release,
ClassFactory_CreateInstance,
ClassFactory_LockServer
};
static IClassFactory activex_cf = { &ClassFactoryVtbl };
static void test_elem_dispex(IDispatchEx *dispex)
{
DISPPARAMS dp;
EXCEPINFO ei;
VARIANT v;
DISPID id;
BSTR str;
HRESULT hres;
str = SysAllocString(L"scriptprop");
SET_EXPECT(GetIDsOfNames_scriptprop);
hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
CHECK_CALLED(GetIDsOfNames_scriptprop);
SysFreeString(str);
ok(hres == S_OK, "GetDispID failed: %08lx\n", hres);
todo_wine
ok(id == DISPID_SCRIPTPROP, "id = %ld\n", id);
SET_EXPECT(Invoke_SECURITYCTX);
SET_EXPECT(Invoke_SCRIPTPROP);
memset(&dp, 0, sizeof(dp));
memset(&ei, 0, sizeof(ei));
V_VT(&v) = VT_EMPTY;
hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08lx\n", hres);
ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 4, "V_I4(v) = %ld\n", V_I4(&v));
CHECK_CALLED(Invoke_SECURITYCTX);
CHECK_CALLED(Invoke_SCRIPTPROP);
}
static void test_iface_wrapping(IHTMLObjectElement *elem)
{
IHTMLObjectElement *elem2;
IUnknown *unk, *unk2;
ULONG ref;
void **vtbl;
HRESULT hres;
SET_EXPECT(QI_ITestActiveX);
SET_EXPECT(wrapped_AddRef);
SET_EXPECT(wrapped_Release);
unk = (void*)0xdeadbeef;
hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk);
ok(hres == S_OK, "QueryInterface(IID_ITestActiveX failed: %08lx\n", hres);
CHECK_CALLED(QI_ITestActiveX);
CHECK_CALLED(wrapped_AddRef);
CHECK_CALLED(wrapped_Release);
/* See dlls/mshtml/ifacewrap.c */
ok(unk != &wrapped_iface, "Unexpected unk %p, expected %p (%p, %p)\n", unk, &ViewObjectEx, unk->lpVtbl, &ViewObjectExVtbl);
ok(unk->lpVtbl != wrapped_iface.lpVtbl, "unk->lpVtbl == wrapped_iface->lpVtbl\n");
ok(unk->lpVtbl->QueryInterface != wrapped_QueryInterface, "QueryInterface not wrapped\n");
ok(unk->lpVtbl->AddRef != wrapped_AddRef, "AddRef not wrapped\n");
ok(unk->lpVtbl->Release != wrapped_Release, "Release not wrapped\n");
vtbl = (void**)unk->lpVtbl;
ok(vtbl[4] != wrapped_func_nocall, "func not wrapped\n");
ok(vtbl[63] != wrapped_func, "func not wrapped\n");
SET_EXPECT(wrapped_func);
hres = ((HRESULT (WINAPI*)(IUnknown*,int,double))vtbl[63])(unk, 10, 32.0);
ok(hres == S_OK, "wrapped_func returned %08lx\n", hres);
CHECK_CALLED(wrapped_func);
hres = IUnknown_QueryInterface(unk, &IID_IHTMLObjectElement, (void**)&elem2);
ok(hres == S_OK, "Could not get IHTMLObjectElement from wrapped iface: %08lx\n", hres);
ok(iface_cmp((IUnknown*)elem2, (IUnknown*)elem), "elem2 != elem\n");
IHTMLObjectElement_Release(elem2);
SET_EXPECT(wrapped_Release);
ref = IUnknown_Release(unk);
ok(!ref, "ref=%ld\n", ref);
CHECK_CALLED(wrapped_Release);
SET_EXPECT(QI_ITestActiveX);
SET_EXPECT(wrapped_AddRef);
SET_EXPECT(wrapped_Release);
unk = (void*)0xdeadbeef;
hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk2);
ok(hres == S_OK, "QueryInterface(IID_ITestActiveX failed: %08lx\n", hres);
CHECK_CALLED(QI_ITestActiveX);
CHECK_CALLED(wrapped_AddRef);
CHECK_CALLED(wrapped_Release);
ok(unk != unk2, "unk == unk2\n");
SET_EXPECT(wrapped_Release);
ref = IUnknown_Release(unk2);
ok(!ref, "ref=%ld\n", ref);
CHECK_CALLED(wrapped_Release);
}
static void test_object_elem(IHTMLDocument2 *doc)
{
IHTMLObjectElement *objelem;
IHTMLDocument3 *doc3;
IDispatchEx *dispex;
IHTMLElement *elem;
IDispatch *disp;
VARIANT v;
BSTR str;
HRESULT hres;
hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08lx\n", hres);
str = SysAllocString(L"objid");
elem = (void*)0xdeadbeef;
hres = IHTMLDocument3_getElementById(doc3, str, &elem);
IHTMLDocument3_Release(doc3);
SysFreeString(str);
ok(hres == S_OK, "getElementById failed: %08lx\n", hres);
ok(elem != NULL, "elem == NULL\n");
hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
IHTMLElement_Release(elem);
ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08lx\n", hres);
SET_EXPECT(Invoke_SECURITYCTX);
hres = IHTMLObjectElement_get_object(objelem, &disp);
ok(hres == S_OK, "get_object failed: %08lx\n", hres);
ok(disp == &Dispatch, "disp != Dispatch\n");
CHECK_CALLED(Invoke_SECURITYCTX);
hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
ok(hres == S_OK, "QueryInterface failed: %08lx\n", hres);
test_elem_dispex(dispex);
IDispatchEx_Release(dispex);
test_iface_wrapping(objelem);
hres = IHTMLObjectElement_get_width(objelem, &v);
ok(hres == S_OK, "get_width failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), L"300"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
hres = IHTMLObjectElement_get_height(objelem, &v);
ok(hres == S_OK, "get_height failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), L"200"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
V_VT(&v) = VT_I4;
V_I4(&v) = 400;
SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
SET_EXPECT(Invoke_ENABLED);
hres = IHTMLObjectElement_put_width(objelem, v);
ok(hres == S_OK, "put_width failed: %08lx\n", hres);
CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
hres = IHTMLObjectElement_get_width(objelem, &v);
ok(hres == S_OK, "get_width failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), L"400"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
V_VT(&v) = VT_I4;
V_I4(&v) = 250;
SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
SET_EXPECT(Invoke_ENABLED);
hres = IHTMLObjectElement_put_height(objelem, v);
ok(hres == S_OK, "put_height failed: %08lx\n", hres);
CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
hres = IHTMLObjectElement_get_height(objelem, &v);
ok(hres == S_OK, "get_height failed: %08lx\n", hres);
ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), L"250"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
IHTMLObjectElement_Release(objelem);
}
static void test_container(IHTMLDocument2 *doc_obj)
{
IHTMLWindow2 *parent_window, *html_window;
IServiceProvider *serv_prov;
IOleContainer *container;
IHTMLDocument2 *doc;
IUnknown *unk;
HRESULT hres;
container = NULL;
hres = IOleClientSite_GetContainer(client_site, &container);
ok(hres == S_OK, "GetContainer failed: %08lx\n", hres);
ok(container != NULL, "container == NULL\n");
hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
ok(hres == S_OK, "get_parentWindow failed: %08lx\n", hres);
ok(parent_window != NULL, "parentWindow == NULL\n");
hres = IHTMLWindow2_get_document(parent_window, &doc);
ok(hres == S_OK, "get_document failed: %08lx\n", hres);
ok(doc != NULL, "doc == NULL\n");
ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
IHTMLDocument2_Release(doc);
hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
ok(hres == S_OK, "Could not get IServiceProvider iface: %08lx\n", hres);
hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08lx\n", hres);
todo_wine
ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
IHTMLWindow2_Release(html_window);
SET_EXPECT(QueryService_TestActiveX);
hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08lx\n", hres);
ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
CHECK_CALLED(QueryService_TestActiveX);
IUnknown_Release(unk);
IServiceProvider_Release(serv_prov);
IHTMLWindow2_Release(parent_window);
IOleContainer_Release(container);
}
static void test_ui_activate(void)
{
IOleInPlaceSite *ip_site;
HRESULT hres;
hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08lx\n", hres);
SET_EXPECT(Invoke_ENABLED);
hres = IOleInPlaceSite_OnUIActivate(ip_site);
ok(hres == S_OK, "OnUIActivate failed: %08lx\n", hres);
CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
IOleInPlaceSite_Release(ip_site);
}
static HRESULT cs_qi(REFIID,void **);
static IOleDocumentView *view;
static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
{
static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
if(!IsEqualGUID(&undocumented_frame_iid, riid))
ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
{
return 2;
}
static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
{
return 1;
}
static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
LPCBORDERWIDTHS pborderwidths)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
LPCBORDERWIDTHS pborderwidths)
{
return S_OK;
}
static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
{
return S_OK;
}
static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
{
return S_OK;
}
static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
LPOLEMENUGROUPWIDTHS lpMenuWidths)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
HOLEMENU holemenu, HWND hwndActiveObject)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
{
return S_OK;
}
static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
InPlaceFrame_QueryInterface,
InPlaceFrame_AddRef,
InPlaceFrame_Release,
InPlaceFrame_GetWindow,
InPlaceFrame_ContextSensitiveHelp,
InPlaceFrame_GetBorder,
InPlaceFrame_RequestBorderSpace,
InPlaceFrame_SetBorderSpace,
InPlaceFrame_SetActiveObject,
InPlaceFrame_InsertMenus,
InPlaceFrame_SetMenu,
InPlaceFrame_RemoveMenus,
InPlaceFrame_SetStatusText,
InPlaceFrame_EnableModeless,
InPlaceFrame_TranslateAccelerator
};
static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
InPlaceFrame_QueryInterface,
InPlaceFrame_AddRef,
InPlaceFrame_Release,
InPlaceFrame_GetWindow,
InPlaceFrame_ContextSensitiveHelp,
InPlaceFrame_GetBorder,
InPlaceFrame_RequestBorderSpace,
InPlaceFrame_SetBorderSpace,
InPlaceUIWindow_SetActiveObject,
};
static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
{
return cs_qi(riid, ppv);
}
static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
{
return 2;
}
static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
{
return 1;
}
static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
{
*phwnd = container_hwnd;
return S_OK;
}
static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
{
return S_OK;
}
static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
{
return S_OK;
}
static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
{
return S_OK;
}
static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
{
static const RECT rect = {0,0,500,500};
*ppFrame = &InPlaceFrame;
*ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
*lprcPosRect = rect;
*lprcClipRect = rect;
lpFrameInfo->fMDIApp = FALSE;
lpFrameInfo->hwndFrame = container_hwnd;
lpFrameInfo->haccel = NULL;
lpFrameInfo->cAccelEntries = 0;
return S_OK;
}
static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
{
return S_OK;
}
static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
{
return S_OK;
}
static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
{
return E_NOTIMPL;
}
static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
{
return E_NOTIMPL;
}
static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
InPlaceSite_QueryInterface,
InPlaceSite_AddRef,
InPlaceSite_Release,
InPlaceSite_GetWindow,
InPlaceSite_ContextSensitiveHelp,
InPlaceSite_CanInPlaceActivate,
InPlaceSite_OnInPlaceActivate,
InPlaceSite_OnUIActivate,
InPlaceSite_GetWindowContext,
InPlaceSite_Scroll,
InPlaceSite_OnUIDeactivate,
InPlaceSite_OnInPlaceDeactivate,
InPlaceSite_DiscardUndoState,
InPlaceSite_DeactivateAndUndo,
InPlaceSite_OnPosRectChange,
};
static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
{
return cs_qi(riid, ppv);
}
static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
{
return 2;
}
static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
{
return 1;
}
static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
IMoniker **ppmon)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
{
return E_NOTIMPL;
}
static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static const IOleClientSiteVtbl ClientSiteVtbl = {
ClientSite_QueryInterface,
ClientSite_AddRef,
ClientSite_Release,
ClientSite_SaveObject,
ClientSite_GetMoniker,
ClientSite_GetContainer,
ClientSite_ShowObject,
ClientSite_OnShowWindow,
ClientSite_RequestNewObjectLayout
};
static IOleClientSite ClientSite = { &ClientSiteVtbl };
static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
{
return cs_qi(riid, ppv);
}
static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
{
return 2;
}
static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
{
return 1;
}
static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
{
RECT rect = {0,0,400,500};
IOleDocument *document;
HRESULT hres;
hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
ok(hres == S_OK, "could not get IOleDocument: %08lx\n", hres);
hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
IOleDocument_Release(document);
ok(hres == S_OK, "CreateView failed: %08lx\n", hres);
hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
hres = IOleDocumentView_UIActivate(view, TRUE);
ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
hres = IOleDocumentView_SetRect(view, &rect);
ok(hres == S_OK, "SetRect failed: %08lx\n", hres);
hres = IOleDocumentView_Show(view, TRUE);
ok(hres == S_OK, "Show failed: %08lx\n", hres);
return S_OK;
}
static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
DocumentSite_QueryInterface,
DocumentSite_AddRef,
DocumentSite_Release,
DocumentSite_ActivateMe
};
static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
REFIID riid, void **ppv)
{
return cs_qi(riid, ppv);
}
static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
{
return 2;
}
static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
{
return 1;
}
static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
REFIID riid, void **ppv)
{
if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
CHECK_EXPECT(QueryService_TestActiveX);
ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
*ppv = &OleObject;
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
static const IServiceProviderVtbl ServiceProviderVtbl = {
ServiceProvider_QueryInterface,
ServiceProvider_AddRef,
ServiceProvider_Release,
ServiceProvider_QueryService
};
static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
static HRESULT cs_qi(REFIID riid, void **ppv)
{
*ppv = NULL;
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
*ppv = &ClientSite;
else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
*ppv = &DocumentSite;
else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
*ppv = &InPlaceSite;
else if(IsEqualGUID(riid, &IID_IServiceProvider))
*ppv = &ServiceProvider;
return *ppv ? S_OK : E_NOINTERFACE;
}
static IHTMLDocument2 *notif_doc;
static BOOL doc_complete;
static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
REFIID riid, void**ppv)
{
if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
*ppv = iface;
return S_OK;
}
ok(0, "unexpected call\n");
return E_NOINTERFACE;
}
static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
{
return 2;
}
static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
{
return 1;
}
static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
{
if(dispID == DISPID_READYSTATE){
BSTR state;
HRESULT hres;
static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
hres = IHTMLDocument2_get_readyState(notif_doc, &state);
ok(hres == S_OK, "get_readyState failed: %08lx\n", hres);
if(!lstrcmpW(state, completeW))
doc_complete = TRUE;
SysFreeString(state);
}
return S_OK;
}
static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
}
static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
PropertyNotifySink_QueryInterface,
PropertyNotifySink_AddRef,
PropertyNotifySink_Release,
PropertyNotifySink_OnChanged,
PropertyNotifySink_OnRequestEdit
};
static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
static void doc_load_string(IHTMLDocument2 *doc, const char *str)
{
IPersistStreamInit *init;
IStream *stream;
HGLOBAL mem;
SIZE_T len;
HRESULT hr;
notif_doc = doc;
doc_complete = FALSE;
len = strlen(str);
mem = GlobalAlloc(0, len);
memcpy(mem, str, len);
hr = CreateStreamOnHGlobal(mem, TRUE, &stream);
ok(hr == S_OK, "Failed to create a stream, hr %#lx.\n", hr);
hr = IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
ok(hr == S_OK, "Failed to get IPersistStreamInit, hr %#lx.\n", hr);
IPersistStreamInit_Load(init, stream);
IPersistStreamInit_Release(init);
IStream_Release(stream);
}
static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
{
IConnectionPointContainer *container;
IConnectionPoint *cp;
DWORD cookie;
HRESULT hres;
hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08lx\n", hres);
hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
IConnectionPointContainer_Release(container);
ok(hres == S_OK, "FindConnectionPoint failed: %08lx\n", hres);
hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
IConnectionPoint_Release(cp);
ok(hres == S_OK, "Advise failed: %08lx\n", hres);
}
static void set_client_site(IHTMLDocument2 *doc, BOOL set)
{
IOleObject *oleobj;
HRESULT hres;
if(!set && view) {
IOleDocumentView_Show(view, FALSE);
IOleDocumentView_CloseView(view, 0);
IOleDocumentView_SetInPlaceSite(view, NULL);
IOleDocumentView_Release(view);
view = NULL;
}
hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
ok(hres == S_OK, "Could not et IOleObject: %08lx\n", hres);
hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
if(set) {
IHlinkTarget *hlink;
hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
ok(hres == S_OK, "Could not get IHlinkTarget iface: %08lx\n", hres);
hres = IHlinkTarget_Navigate(hlink, 0, NULL);
ok(hres == S_OK, "Navgate failed: %08lx\n", hres);
IHlinkTarget_Release(hlink);
}
IOleObject_Release(oleobj);
}
static IHTMLDocument2 *create_document(void)
{
IHTMLDocument2 *doc;
HRESULT hres;
hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IHTMLDocument2, (void**)&doc);
ok(hres == S_OK, "CoCreateInstance failed: %08lx\n", hres);
return doc;
}
static IHTMLDocument2 *create_doc(const char *str)
{
IHTMLDocument2 *doc;
MSG msg;
doc = create_document();
set_client_site(doc, TRUE);
doc_load_string(doc, str);
do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
while(!doc_complete && GetMessageW(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
return doc;
}
static void release_doc(IHTMLDocument2 *doc)
{
ULONG ref;
set_client_site(doc, FALSE);
ref = IHTMLDocument2_Release(doc);
ok(!ref || broken(ref == 1) /* Vista */, "ref = %ld\n", ref);
if(client_site) {
IOleClientSite_Release(client_site);
client_site = NULL;
}
if(plugin_hwnd) {
DestroyWindow(plugin_hwnd);
plugin_hwnd = NULL;
}
ok(!activex_refcnt, "activex_refcnt = %ld\n", activex_refcnt);
}
static void init_test(int behavior)
{
plugin_behavior = behavior;
activex_refcnt = 0;
no_quickact = behavior == TEST_NOQUICKACT || behavior == TEST_DISPONLY;
have_container = TRUE;
}
static void test_event_call(void)
{
VARIANT res, args[2];
DISPPARAMS dp = {args};
EXCEPINFO ei = {0};
HRESULT hres;
V_VT(&res) = VT_EMPTY;
hres = IDispatch_Invoke(sink_disp, 1, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
ok(hres == S_OK, "Invoke failed: %08lx\n", hres);
ok(V_VT(&res) == VT_I4 && V_I4(&res) == 6, "unexpected result\n");
V_VT(args) = VT_I4;
V_I4(args) = 2;
V_VT(args+1) = VT_I4;
V_I4(args+1) = 3;
dp.cArgs = 2;
V_VT(&res) = VT_EMPTY;
hres = IDispatch_Invoke(sink_disp, 2, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
ok(hres == S_OK, "Invoke failed: %08lx\n", hres);
ok(V_VT(&res) == VT_I4 && V_I4(&res) == 7, "unexpected result: %ld\n", V_I4(&res));
V_VT(&res) = VT_ERROR;
hres = IDispatch_Invoke(sink_disp, 10, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
ok(hres == S_OK, "Invoke failed: %08lx\n", hres);
ok(V_VT(&res) == VT_EMPTY, "V_VT(res) = %d\n", V_VT(&res));
}
static void test_flash_ax(void)
{
IHTMLDocument2 *doc;
IOleClientSite *cs;
init_test(TEST_FLASH);
SET_EXPECT(CreateInstance);
SET_EXPECT(FreezeEvents_TRUE);
SET_EXPECT(QuickActivate);
SET_EXPECT(FreezeEvents_FALSE);
SET_EXPECT(IPersistPropertyBag_Load);
SET_EXPECT(Invoke_READYSTATE);
SET_EXPECT(Invoke_SECURITYCTX);
SET_EXPECT(Invoke_SCRIPTCALL);
SET_EXPECT(SetExtent);
SET_EXPECT(GetExtent);
SET_EXPECT(DoVerb);
doc = create_doc(object_ax_str);
CHECK_CALLED(CreateInstance);
todo_wine
CHECK_CALLED(FreezeEvents_TRUE);
CHECK_CALLED(QuickActivate);
todo_wine
CHECK_CALLED(FreezeEvents_FALSE);
CHECK_CALLED(IPersistPropertyBag_Load);
CHECK_CALLED(Invoke_READYSTATE);
CHECK_CALLED(Invoke_SECURITYCTX);
CHECK_CALLED(Invoke_SCRIPTCALL);
todo_wine
CHECK_CALLED(SetExtent);
todo_wine
CHECK_CALLED(GetExtent);
CHECK_CALLED(DoVerb);
/* Set in DoVerb */
CHECK_CALLED(InPlaceObject_GetWindow);
CHECK_CALLED(SetObjectRects);
test_ui_activate();
test_container(notif_doc);
test_object_elem(notif_doc);
IOleClientSite_AddRef(client_site);
cs = client_site;
SET_EXPECT(UIDeactivate);
SET_EXPECT(Invoke_ENABLED);
SET_EXPECT(Invoke_VALID);
SET_EXPECT(InPlaceDeactivate);
SET_EXPECT(Close);
SET_EXPECT(SetClientSite_NULL);
release_doc(doc);
CHECK_CALLED(UIDeactivate);
CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
todo_wine
CHECK_CALLED(Invoke_VALID);
CHECK_CALLED(InPlaceDeactivate);
CHECK_CALLED(Close);
CHECK_CALLED(SetClientSite_NULL);
IOleClientSite_Release(cs);
}
static void test_noquickact_ax(void)
{
IHTMLDocument2 *doc;
init_test(TEST_NOQUICKACT);
SET_EXPECT(CreateInstance);
SET_EXPECT(FreezeEvents_TRUE);
SET_EXPECT(GetMiscStatus);
SET_EXPECT(SetClientSite);
SET_EXPECT(SetAdvise);
SET_EXPECT(GetViewStatus);
SET_EXPECT(FreezeEvents_FALSE);
SET_EXPECT(Invoke_READYSTATE);
SET_EXPECT(Invoke_SECURITYCTX);
SET_EXPECT(Invoke_SCRIPTCALL);
SET_EXPECT(SetExtent);
SET_EXPECT(GetExtent);
SET_EXPECT(DoVerb);
doc = create_doc(object_ax_str);
CHECK_CALLED(CreateInstance);
todo_wine CHECK_CALLED(FreezeEvents_TRUE);
CHECK_CALLED(GetMiscStatus);
CHECK_CALLED(SetClientSite);
CHECK_CALLED(SetAdvise);
CHECK_CALLED(GetViewStatus);
todo_wine CHECK_CALLED(FreezeEvents_FALSE);
CHECK_CALLED(Invoke_READYSTATE);
CHECK_CALLED(Invoke_SECURITYCTX);
CHECK_CALLED(Invoke_SCRIPTCALL);
todo_wine CHECK_CALLED(SetExtent);
todo_wine CHECK_CALLED(GetExtent);
CHECK_CALLED(DoVerb);
/* Set in DoVerb */
CHECK_CALLED(InPlaceObject_GetWindow);
CHECK_CALLED(SetObjectRects);
SET_EXPECT(InPlaceDeactivate);
SET_EXPECT(Close);
SET_EXPECT(SetClientSite_NULL);
release_doc(doc);
CHECK_CALLED(InPlaceDeactivate);
CHECK_CALLED(Close);
CHECK_CALLED(SetClientSite_NULL);
}
static void test_event_binding(void)
{
IHTMLDocument2 *doc;
init_test(TEST_FLASH);
SET_EXPECT(CreateInstance);
SET_EXPECT(FreezeEvents_TRUE);
SET_EXPECT(QuickActivate);
SET_EXPECT(FreezeEvents_FALSE);
SET_EXPECT(IPersistPropertyBag_Load);
SET_EXPECT(Invoke_READYSTATE);
SET_EXPECT(SetExtent);
SET_EXPECT(GetExtent);
SET_EXPECT(DoVerb);
SET_EXPECT(GetClassInfo);
SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
SET_EXPECT(FindConnectionPoint);
SET_EXPECT(Advise);
doc = create_doc(event_binding_str);
CHECK_CALLED(CreateInstance);
todo_wine
CHECK_CALLED(FreezeEvents_TRUE);
CHECK_CALLED(QuickActivate);
todo_wine
CHECK_CALLED(FreezeEvents_FALSE);
CHECK_CALLED(IPersistPropertyBag_Load);
CHECK_CALLED(Invoke_READYSTATE);
todo_wine
CHECK_CALLED(SetExtent);
todo_wine
CHECK_CALLED(GetExtent);
CHECK_CALLED(DoVerb);
/* Set in DoVerb */
CHECK_CALLED(InPlaceObject_GetWindow);
CHECK_CALLED(SetObjectRects);
CHECK_CALLED(GetClassInfo);
todo_wine
CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
CHECK_CALLED(FindConnectionPoint);
CHECK_CALLED(Advise);
test_event_call();
SET_EXPECT(InPlaceDeactivate);
SET_EXPECT(Close);
SET_EXPECT(SetClientSite_NULL);
SET_EXPECT(FindConnectionPoint);
SET_EXPECT(Unadvise);
release_doc(doc);
CHECK_CALLED(InPlaceDeactivate);
CHECK_CALLED(Close);
CHECK_CALLED(SetClientSite_NULL);
CHECK_CALLED(FindConnectionPoint);
CHECK_CALLED(Unadvise);
}
static void test_nooleobj_ax(void)
{
IHTMLDocument2 *doc;
init_test(TEST_DISPONLY);
SET_EXPECT(CreateInstance);
SET_EXPECT(Invoke_READYSTATE);
SET_EXPECT(Invoke_SECURITYCTX);
SET_EXPECT(Invoke_SCRIPTCALL);
doc = create_doc(object_ax_str);
CHECK_CALLED(CreateInstance);
CHECK_CALLED(Invoke_READYSTATE);
CHECK_CALLED(Invoke_SECURITYCTX);
CHECK_CALLED(Invoke_SCRIPTCALL);
release_doc(doc);
}
static void test_exec_script(IHTMLDocument2 *doc, const WCHAR *codew, const WCHAR *langw)
{
IHTMLWindow2 *window;
BSTR code, lang;
VARIANT v;
HRESULT hres;
hres = IHTMLDocument2_get_parentWindow(doc, &window);
ok(hres == S_OK, "get_parentWindow failed: %08lx\n", hres);
code = SysAllocString(codew);
lang = SysAllocString(langw);
hres = IHTMLWindow2_execScript(window, code, lang, &v);
ok(hres == S_OK, "execScript failed: %08lx\n", hres);
SysFreeString(lang);
VariantClear(&v);
IHTMLWindow2_Release(window);
}
static void test_create_element(void)
{
IHTMLDocument2 *doc;
init_test(TEST_FLASH);
doc = create_doc("<html></html>");
have_container = FALSE;
SET_EXPECT(CreateInstance);
SET_EXPECT(FreezeEvents_TRUE);
SET_EXPECT(QuickActivate);
SET_EXPECT(IPersistPropertyBag_InitNew);
SET_EXPECT(Invoke_READYSTATE);
SET_EXPECT(FreezeEvents_FALSE);
test_exec_script(doc,
L"var test_elem = document.createElement('object');"
"test_elem.classid = 'CLSID:178fc163-f585-4e24-9c13-4bb7f6680746';",
L"javascript");
CHECK_CALLED(CreateInstance);
todo_wine CHECK_CALLED(FreezeEvents_TRUE);
CHECK_CALLED(QuickActivate);
CHECK_CALLED(IPersistPropertyBag_InitNew);
CHECK_CALLED(Invoke_READYSTATE);
todo_wine CHECK_CALLED(FreezeEvents_FALSE);
have_container = TRUE;
SET_EXPECT(DoVerb);
test_exec_script(doc,
L"document.body.appendChild(test_elem);",
L"javascript");
todo_wine CHECK_CALLED(DoVerb);
SET_EXPECT(InPlaceDeactivate);
SET_EXPECT(Close);
SET_EXPECT(SetClientSite_NULL);
release_doc(doc);
todo_wine CHECK_CALLED(InPlaceDeactivate);
CHECK_CALLED(Close);
CHECK_CALLED(SetClientSite_NULL);
}
static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
static HWND create_container_window(void)
{
static const WCHAR html_document_testW[] =
{'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
static WNDCLASSEXW wndclass = {
sizeof(WNDCLASSEXW),
0,
wnd_proc,
0, 0, NULL, NULL, NULL, NULL, NULL,
html_document_testW,
NULL
};
RegisterClassExW(&wndclass);
return CreateWindowW(html_document_testW, html_document_testW,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
515, 530, NULL, NULL, NULL, NULL);
}
static void load_typelib(void)
{
WCHAR path[MAX_PATH];
ITypeLib *typelib;
HRESULT hres;
GetModuleFileNameW(NULL, path, MAX_PATH);
hres = LoadTypeLib(path, &typelib);
ok(hres == S_OK, "LoadTypeLib failed: %08lx\n", hres);
hres = ITypeLib_GetTypeInfoOfGuid(typelib, &DIID_DispActiveXTest, &actxtest_typeinfo);
ok(hres == S_OK, "GetTypeInfoOfGuid(DIID_DispActiveXTest) failed: %08lx\n", hres);
hres = ITypeLib_GetTypeInfoOfGuid(typelib, &CLSID_ActiveXTest, &class_typeinfo);
ok(hres == S_OK, "GetTypeInfoOfGuid(CLSID_ActiveXTest) failed: %08lx\n", hres);
ITypeLib_Release(typelib);
}
static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
{
HKEY hkey;
DWORD res;
if(!init) {
RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
return TRUE;
}
res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
if(res != ERROR_SUCCESS)
return FALSE;
if(def_value)
res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
RegCloseKey(hkey);
return res == ERROR_SUCCESS;
}
static BOOL init_registry(BOOL init)
{
return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
&& init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
NULL, init)
&& init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
NULL, init);
}
static BOOL register_activex(void)
{
DWORD regid;
HRESULT hres;
if(!init_registry(TRUE)) {
init_registry(FALSE);
return FALSE;
}
hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
ok(hres == S_OK, "Could not register control: %08lx\n", hres);
return TRUE;
}
static BOOL check_ie(void)
{
IHTMLDocument5 *doc;
HRESULT hres;
hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IHTMLDocument5, (void**)&doc);
if(FAILED(hres))
return FALSE;
IHTMLDocument5_Release(doc);
return TRUE;
}
START_TEST(activex)
{
CoInitialize(NULL);
if(!check_ie()) {
CoUninitialize();
win_skip("Too old IE\n");
return;
}
if(is_ie_hardened()) {
CoUninitialize();
win_skip("IE running in Enhanced Security Configuration\n");
return;
}
init_wrapped_iface();
load_typelib();
container_hwnd = create_container_window();
ShowWindow(container_hwnd, SW_SHOW);
if(register_activex()) {
trace("Testing emulated flash embedding...\n");
test_flash_ax();
trace("Testing plugin without IQuickActivate iface...\n");
test_noquickact_ax();
trace("Testing plugin with IDispatch iface only...\n");
test_nooleobj_ax();
trace("Testing event object binding...\n");
test_event_binding();
trace("Testing createElement(object)...\n");
test_create_element();
init_registry(FALSE);
}else {
skip("Could not register ActiveX\n");
}
if(actxtest_typeinfo)
ITypeInfo_Release(actxtest_typeinfo);
if(class_typeinfo)
ITypeInfo_Release(class_typeinfo);
DestroyWindow(container_hwnd);
CoUninitialize();
}
Reference in a new issue View git blame Copy permalink