826 lines
21 KiB
C
826 lines
21 KiB
C
/*
|
|
* 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 "mshtmhst.h"
|
|
#include "mshtml_test.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_EXPECT(CreateInstance);
|
|
|
|
static HWND container_hwnd;
|
|
|
|
#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 char *debugstr_guid(REFIID riid)
|
|
{
|
|
static char buf[50];
|
|
|
|
sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
|
|
riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
|
|
riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
|
|
riid->Data4[5], riid->Data4[6], riid->Data4[7]);
|
|
|
|
return buf;
|
|
}
|
|
|
|
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\">"
|
|
"</object>"
|
|
"</body></html>";
|
|
|
|
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", debugstr_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", debugstr_guid(riid));
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
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 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", debugstr_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->cb = sizeof(*lpFrameInfo);
|
|
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: %08x\n", hres);
|
|
|
|
hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
|
|
IOleDocument_Release(document);
|
|
ok(hres == S_OK, "CreateView failed: %08x\n", hres);
|
|
|
|
hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
|
|
ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
|
|
|
|
hres = IOleDocumentView_UIActivate(view, TRUE);
|
|
ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
|
|
|
|
hres = IOleDocumentView_SetRect(view, &rect);
|
|
ok(hres == S_OK, "SetRect failed: %08x\n", hres);
|
|
|
|
hres = IOleDocumentView_Show(view, TRUE);
|
|
ok(hres == S_OK, "Show failed: %08x\n", hres);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
|
|
DocumentSite_QueryInterface,
|
|
DocumentSite_AddRef,
|
|
DocumentSite_Release,
|
|
DocumentSite_ActivateMe
|
|
};
|
|
|
|
static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
|
|
|
|
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;
|
|
|
|
return *ppv ? S_OK : E_NOINTERFACE;
|
|
}
|
|
|
|
static IClassFactory activex_cf = { &ClassFactoryVtbl };
|
|
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: %08x\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;
|
|
|
|
notif_doc = doc;
|
|
|
|
doc_complete = FALSE;
|
|
len = strlen(str);
|
|
mem = GlobalAlloc(0, len);
|
|
memcpy(mem, str, len);
|
|
CreateStreamOnHGlobal(mem, TRUE, &stream);
|
|
|
|
IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
|
|
|
|
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: %08x\n", hres);
|
|
|
|
hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
|
|
IConnectionPointContainer_Release(container);
|
|
ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
|
|
|
|
hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
|
|
IConnectionPoint_Release(cp);
|
|
ok(hres == S_OK, "Advise failed: %08x\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: %08x\n", hres);
|
|
|
|
hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
|
|
ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
|
|
|
|
if(set) {
|
|
IHlinkTarget *hlink;
|
|
|
|
hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
|
|
ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
|
|
|
|
hres = IHlinkTarget_Navigate(hlink, 0, NULL);
|
|
ok(hres == S_OK, "Navgate failed: %08x\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: %08x\n", hres);
|
|
|
|
return doc;
|
|
}
|
|
|
|
static IHTMLDocument2 *create_doc(const char *str, BOOL *b)
|
|
{
|
|
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 || (b && !*b)) && GetMessage(&msg, NULL, 0, 0)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
return doc;
|
|
}
|
|
|
|
static void release_doc(IHTMLDocument2 *doc)
|
|
{
|
|
ULONG ref;
|
|
|
|
set_client_site(doc, FALSE);
|
|
ref = IHTMLDocument2_Release(doc);
|
|
ok(!ref, "ref = %d\n", ref);
|
|
}
|
|
|
|
static void test_object_ax(void)
|
|
{
|
|
IHTMLDocument2 *doc;
|
|
|
|
/*
|
|
* We pump messages until both document is loaded and plugin instance is created.
|
|
* Pumping until document is loaded should be enough, but Gecko loads plugins
|
|
* asynchronously and until we'll work around it, we need this hack.
|
|
*/
|
|
SET_EXPECT(CreateInstance);
|
|
doc = create_doc(object_ax_str, &called_CreateInstance);
|
|
CHECK_CALLED(CreateInstance);
|
|
|
|
release_doc(doc);
|
|
}
|
|
|
|
static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return DefWindowProc(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 BOOL init_key(const char *key_name, const char *def_value, BOOL init)
|
|
{
|
|
HKEY hkey;
|
|
DWORD res;
|
|
|
|
if(!init) {
|
|
RegDeleteKey(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, ®id);
|
|
ok(hres == S_OK, "Could not register control: %08x\n", hres);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL check_ie(void)
|
|
{
|
|
IHTMLDocument5 *doc;
|
|
HRESULT hres;
|
|
|
|
static const WCHAR xW[] = {'x',0};
|
|
static const WCHAR yW[] = {'y',0};
|
|
|
|
if(!lstrcmpW(xW, yW))
|
|
return FALSE;
|
|
|
|
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;
|
|
}
|
|
|
|
container_hwnd = create_container_window();
|
|
ShowWindow(container_hwnd, SW_SHOW);
|
|
|
|
if(register_activex()) {
|
|
test_object_ax();
|
|
init_registry(FALSE);
|
|
}else {
|
|
skip("Could not register ActiveX\n");
|
|
}
|
|
|
|
DestroyWindow(container_hwnd);
|
|
CoUninitialize();
|
|
}
|