1 /*
2 * Copyright 2010 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #define COBJMACROS
20 #define CONST_VTABLE
21
22 #include <wine/test.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "ole2.h"
29 #include "mshtml.h"
30 #include "docobj.h"
31 #include "hlink.h"
32 #include "dispex.h"
33 #include "mshtmhst.h"
34 #include "activscp.h"
35 #include "objsafe.h"
36 #include "mshtmdid.h"
37 #include "mshtml_test.h"
38
39 #define DEFINE_EXPECT(func) \
40 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
41
42 #define SET_EXPECT(func) \
43 do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
44
45 #define CHECK_EXPECT2(func) \
46 do { \
47 ok(expect_ ##func, "unexpected call " #func "\n"); \
48 called_ ## func = TRUE; \
49 }while(0)
50
51 #define CHECK_EXPECT(func) \
52 do { \
53 CHECK_EXPECT2(func); \
54 expect_ ## func = FALSE; \
55 }while(0)
56
57 #define CHECK_CALLED(func) \
58 do { \
59 ok(called_ ## func, "expected " #func "\n"); \
60 expect_ ## func = called_ ## func = FALSE; \
61 }while(0)
62
63 DEFINE_EXPECT(CreateInstance);
64 DEFINE_EXPECT(FreezeEvents_TRUE);
65 DEFINE_EXPECT(FreezeEvents_FALSE);
66 DEFINE_EXPECT(QuickActivate);
67 DEFINE_EXPECT(IPersistPropertyBag_InitNew);
68 DEFINE_EXPECT(IPersistPropertyBag_Load);
69 DEFINE_EXPECT(Invoke_READYSTATE);
70 DEFINE_EXPECT(Invoke_ENABLED);
71 DEFINE_EXPECT(Invoke_VALID);
72 DEFINE_EXPECT(Invoke_SECURITYCTX);
73 DEFINE_EXPECT(Invoke_SCRIPTPROP);
74 DEFINE_EXPECT(GetIDsOfNames_scriptprop);
75 DEFINE_EXPECT(DoVerb);
76 DEFINE_EXPECT(SetExtent);
77 DEFINE_EXPECT(GetExtent);
78 DEFINE_EXPECT(SetClientSite);
79 DEFINE_EXPECT(SetClientSite_NULL);
80 DEFINE_EXPECT(Close);
81 DEFINE_EXPECT(InPlaceObject_GetWindow);
82 DEFINE_EXPECT(SetObjectRects);
83 DEFINE_EXPECT(InPlaceDeactivate);
84 DEFINE_EXPECT(UIDeactivate);
85 DEFINE_EXPECT(QueryService_TestActiveX);
86
87 #define DISPID_SCRIPTPROP 1000
88
89 static HWND container_hwnd, plugin_hwnd;
90
91 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
92
93 static const GUID CLSID_TestActiveX =
94 {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
95
96 static const char object_ax_str[] =
97 "<html><head></head><body>"
98 "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
99 "<param name=\"param_name\" value=\"param_value\">"
100 "<param name=\"num_param\" value=\"3\">"
101 "</object>"
102 "</body></html>";
103
104 static REFIID pluginhost_iids[] = {
105 &IID_IOleClientSite,
106 &IID_IAdviseSink,
107 &IID_IAdviseSinkEx,
108 &IID_IPropertyNotifySink,
109 &IID_IDispatch,
110 &IID_IOleWindow,
111 &IID_IOleInPlaceSite,
112 &IID_IOleInPlaceSiteEx,
113 &IID_IOleControlSite,
114 &IID_IBindHost,
115 &IID_IServiceProvider,
116 NULL
117 };
118
119 static const char *debugstr_guid(REFIID riid)
120 {
121 static char buf[50];
122
123 sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
124 riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
125 riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
126 riid->Data4[5], riid->Data4[6], riid->Data4[7]);
127
128 return buf;
129 }
130
131 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
132 {
133 IUnknown *unk1, *unk2;
134
135 if(iface1 == iface2)
136 return TRUE;
137
138 IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
139 IUnknown_Release(unk1);
140 IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
141 IUnknown_Release(unk2);
142
143 return unk1 == unk2;
144 }
145
146 #define test_ifaces(i,ids) _test_ifaces(__LINE__,i,ids)
147 static void _test_ifaces(unsigned line, IUnknown *iface, REFIID *iids)
148 {
149 const IID * const *piid;
150 IUnknown *unk;
151 HRESULT hres;
152
153 for(piid = iids; *piid; piid++) {
154 hres = IDispatch_QueryInterface(iface, *piid, (void**)&unk);
155 ok_(__FILE__,line) (hres == S_OK, "Could not get %s interface: %08x\n", debugstr_guid(*piid), hres);
156 if(SUCCEEDED(hres))
157 IUnknown_Release(unk);
158 }
159 }
160
161 static int strcmp_wa(LPCWSTR strw, const char *stra)
162 {
163 CHAR buf[512];
164 WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
165 return lstrcmpA(stra, buf);
166 }
167
168 static BSTR a2bstr(const char *str)
169 {
170 BSTR ret;
171 int len;
172
173 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
174 ret = SysAllocStringLen(NULL, len);
175 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
176
177 return ret;
178 }
179
180 static IOleClientSite *client_site;
181 static READYSTATE plugin_readystate = READYSTATE_UNINITIALIZED;
182
183 static void set_plugin_readystate(READYSTATE state)
184 {
185 IPropertyNotifySink *prop_notif;
186 HRESULT hres;
187
188 plugin_readystate = state;
189
190 hres = IOleClientSite_QueryInterface(client_site, &IID_IPropertyNotifySink, (void**)&prop_notif);
191 ok(hres == S_OK, "Could not get IPropertyNotifySink iface: %08x\n", hres);
192
193 hres = IPropertyNotifySink_OnChanged(prop_notif, DISPID_READYSTATE);
194 ok(hres == S_OK, "OnChanged(DISPID_READYSTATE) failed: %08x\n", hres);
195
196 IPropertyNotifySink_Release(prop_notif);
197 }
198
199 static void test_mon_displayname(IMoniker *mon, const char *exname, const char *broken_name)
200 {
201 LPOLESTR display_name;
202 DWORD mksys;
203 HRESULT hres;
204
205 hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
206 ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
207 ok(!strcmp_wa(display_name, exname) || broken(broken_name && !strcmp_wa(display_name, broken_name)),
208 "display_name = %s\n", wine_dbgstr_w(display_name));
209 CoTaskMemFree(display_name);
210
211 hres = IMoniker_IsSystemMoniker(mon, &mksys);
212 ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
213 ok(mksys == MKSYS_URLMONIKER, "mksys = %d\n", mksys);
214 }
215
216 static LRESULT WINAPI plugin_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
217 {
218 switch(msg) {
219 case WM_PAINT: {
220 PAINTSTRUCT ps;
221 HBRUSH brush;
222 RECT rect;
223 HDC dc;
224
225 GetClientRect(hwnd, &rect);
226
227 dc = BeginPaint(hwnd, &ps);
228 brush = CreateSolidBrush(RGB(255,0,0));
229 SelectObject(dc, brush);
230 Rectangle(dc, rect.left, rect.top, rect.right, rect.bottom);
231 DeleteObject(brush);
232 EndPaint(hwnd, &ps);
233 break;
234 }
235 }
236
237 return DefWindowProc(hwnd, msg, wParam, lParam);
238 }
239
240 static void create_plugin_window(HWND parent, const RECT *rect)
241 {
242 static const WCHAR plugin_testW[] =
243 {'p','l','u','g','i','n',' ','t','e','s','t',0};
244 static WNDCLASSEXW wndclass = {
245 sizeof(WNDCLASSEXW),
246 0,
247 plugin_proc,
248 0, 0, NULL, NULL, NULL, NULL, NULL,
249 plugin_testW,
250 NULL
251 };
252
253 RegisterClassExW(&wndclass);
254 plugin_hwnd = CreateWindowW(plugin_testW, plugin_testW,
255 WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, rect->left, rect->top,
256 rect->right-rect->left, rect->bottom-rect->top, parent, NULL, NULL, NULL);
257 }
258
259 static HRESULT ax_qi(REFIID,void**);
260
261 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
262 {
263 return ax_qi(riid, ppv);
264 }
265
266 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
267 {
268 return 2;
269 }
270
271 static ULONG WINAPI OleControl_Release(IOleControl *iface)
272 {
273 return 1;
274 }
275
276 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
277 {
278 ok(0, "unexpected call\n");
279 return E_NOTIMPL;
280 }
281
282 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
283 {
284 ok(0, "unexpected call\n");
285 return E_NOTIMPL;
286 }
287
288 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
289 {
290 ok(0, "unexpected call\n");
291 return E_NOTIMPL;
292 }
293
294 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
295 {
296 if(bFreeze)
297 CHECK_EXPECT2(FreezeEvents_TRUE);
298 else
299 CHECK_EXPECT2(FreezeEvents_FALSE);
300 return S_OK;
301 }
302
303 static const IOleControlVtbl OleControlVtbl = {
304 OleControl_QueryInterface,
305 OleControl_AddRef,
306 OleControl_Release,
307 OleControl_GetControlInfo,
308 OleControl_OnMnemonic,
309 OleControl_OnAmbientPropertyChange,
310 OleControl_FreezeEvents
311 };
312
313 static IOleControl OleControl = { &OleControlVtbl };
314
315 static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
316 {
317 return ax_qi(riid, ppv);
318 }
319
320 static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
321 {
322 return 2;
323 }
324
325 static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
326 {
327 return 1;
328 }
329
330 static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
331 {
332 CHECK_EXPECT(QuickActivate);
333
334 ok(container != NULL, "container == NULL\n");
335 ok(container->cbSize == sizeof(*container), "container->cbSize = %d\n", container->cbSize);
336 ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
337 ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
338 ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
339 ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
340 ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
341 "container->dwAmbientFlags = %x\n", container->dwAmbientFlags);
342 ok(!container->colorFore, "container->colorFore == 0\n"); /* FIXME */
343 todo_wine
344 ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
345 todo_wine
346 ok(container->pFont != NULL, "container->pFont == NULL\n");
347 todo_wine
348 ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
349 ok(!container->dwAppearance, "container->dwAppearance = %x\n", container->dwAppearance);
350 ok(!container->lcid, "container->lcid = %x\n", container->lcid);
351 ok(!container->hpal, "container->hpal = %p\n", container->hpal);
352 ok(!container->pBindHost, "container->pBindHost != NULL\n");
353 ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
354 ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
355
356 ok(control->cbSize == sizeof(*control), "control->cbSize = %d\n", control->cbSize);
357 ok(!control->dwMiscStatus, "control->dwMiscStatus = %x\n", control->dwMiscStatus);
358 ok(!control->dwViewStatus, "control->dwViewStatus = %x\n", control->dwViewStatus);
359 ok(!control->dwEventCookie, "control->dwEventCookie = %x\n", control->dwEventCookie);
360 ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %x\n", control->dwPropNotifyCookie);
361 ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %x\n", control->dwPointerActivationPolicy);
362
363 ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
364 "container->pClientSite != container->pAdviseSink\n");
365 ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pPropertyNotifySink),
366 "container->pClientSite != container->pPropertyNotifySink\n");
367 test_ifaces((IUnknown*)container->pClientSite, pluginhost_iids);
368
369 IOleClientSite_AddRef(container->pClientSite);
370 client_site = container->pClientSite;
371
372 control->dwMiscStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
373 |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
374 control->dwViewStatus = 0x18;
375 control->dwPropNotifyCookie = 1;
376
377 return S_OK;
378 }
379
380 static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
381 {
382 ok(0, "unexpected call\n");
383 return E_NOTIMPL;
384 }
385
386 static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
387 {
388 ok(0, "unexpected call\n");
389 return E_NOTIMPL;
390 }
391
392 static const IQuickActivateVtbl QuickActivateVtbl = {
393 QuickActivate_QueryInterface,
394 QuickActivate_AddRef,
395 QuickActivate_Release,
396 QuickActivate_QuickActivate,
397 QuickActivate_GetContentExtent,
398 QuickActivate_SetContentExtent
399 };
400
401 static IQuickActivate QuickActivate = { &QuickActivateVtbl };
402
403 static HRESULT WINAPI PersistPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
404 {
405 return ax_qi(riid, ppv);
406 }
407
408 static ULONG WINAPI PersistPropertyBag_AddRef(IPersistPropertyBag *iface)
409 {
410 return 2;
411 }
412
413 static ULONG WINAPI PersistPropertyBag_Release(IPersistPropertyBag *iface)
414 {
415 return 1;
416 }
417
418 static HRESULT WINAPI PersistPropertyBag_GetClassID(IPersistPropertyBag *face, CLSID *pClassID)
419 {
420 ok(0, "unexpected call\n");
421 return E_NOTIMPL;
422 }
423
424 static HRESULT WINAPI PersistPropertyBag_InitNew(IPersistPropertyBag *face)
425 {
426 CHECK_EXPECT(IPersistPropertyBag_InitNew);
427 return S_OK;
428 }
429
430 static HRESULT WINAPI PersistPropertyBag_Load(IPersistPropertyBag *face, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
431 {
432 IBindHost *bind_host, *bind_host2;
433 IServiceProvider *sp;
434 IMoniker *mon;
435 VARIANT v;
436 HRESULT hres;
437
438 static const WCHAR param_nameW[] = {'p','a','r','a','m','_','n','a','m','e',0};
439 static const WCHAR num_paramW[] = {'n','u','m','_','p','a','r','a','m',0};
440 static const WCHAR no_paramW[] = {'n','o','_','p','a','r','a','m',0};
441 static WCHAR test_swfW[] = {'t','e','s','t','.','s','w','f',0};
442
443 static const IID *propbag_ifaces[] = {
444 &IID_IPropertyBag,
445 &IID_IPropertyBag2,
446 NULL
447 };
448
449 CHECK_EXPECT(IPersistPropertyBag_Load);
450
451 ok(pPropBag != NULL, "pPropBag == NULL\n");
452 ok(!pErrorLog, "pErrorLog != NULL\n");
453
454 test_ifaces((IUnknown*)pPropBag, propbag_ifaces);
455
456 V_VT(&v) = VT_BSTR;
457 hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
458 ok(hres == S_OK, "Read failed: %08x\n", hres);
459 ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
460 ok(!strcmp_wa(V_BSTR(&v), "param_value"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
461
462 V_VT(&v) = VT_I4;
463 V_I4(&v) = 0xdeadbeef;
464 hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
465 ok(hres == DISP_E_TYPEMISMATCH, "Read failed: %08x, expected DISP_E_TYPEMISMATCH\n", hres);
466 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
467 ok(V_I4(&v) == 0xdeadbeef, "V_I4(v) = %x\n", V_I4(&v));
468
469 V_VT(&v) = VT_BSTR;
470 hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
471 ok(hres == S_OK, "Read failed: %08x\n", hres);
472 ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
473 ok(!strcmp_wa(V_BSTR(&v), "3"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
474 SysFreeString(V_BSTR(&v));
475
476 V_VT(&v) = VT_I4;
477 V_I4(&v) = 0xdeadbeef;
478 hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
479 ok(hres == S_OK, "Read failed: %08x\n", hres);
480 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
481 ok(V_I4(&v) == 3, "V_I4(v) = %x\n", V_I4(&v));
482
483 V_VT(&v) = VT_BSTR;
484 V_BSTR(&v) = (BSTR)0xdeadbeef;
485 hres = IPropertyBag_Read(pPropBag, no_paramW, &v, NULL);
486 ok(hres == E_INVALIDARG, "Read failed: %08x\n", hres);
487 ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
488 ok(V_BSTR(&v) == (BSTR)0xdeadbeef, "V_BSTR(v) = %p\n", V_BSTR(&v));
489
490 set_plugin_readystate(READYSTATE_INTERACTIVE);
491
492 hres = IOleClientSite_QueryInterface(client_site, &IID_IBindHost, (void**)&bind_host);
493 ok(hres == S_OK, "Could not get IBindHost iface: %08x\n", hres);
494
495 hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&sp);
496 ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
497
498 hres = IServiceProvider_QueryService(sp, &SID_SBindHost, &IID_IBindHost, (void**)&bind_host2);
499 ok(hres == S_OK, "QueryService(SID_SBindHost) failed: %08x\n", hres);
500 IServiceProvider_Release(sp);
501
502 ok(iface_cmp((IUnknown*)bind_host, (IUnknown*)bind_host2), "bind_host != bind_host2\n");
503 IBindHost_Release(bind_host2);
504
505 mon = NULL;
506 hres = IBindHost_CreateMoniker(bind_host, test_swfW, NULL, &mon, 0);
507 ok(hres == S_OK, "CreateMoniker failed: %08x\n", hres);
508 ok(mon != NULL, "mon == NULL\n");
509 test_mon_displayname(mon, "about:test.swf", "about:blanktest.swf");
510 IMoniker_Release(mon);
511
512 IBindHost_Release(bind_host);
513
514 mon = NULL;
515 hres = IOleClientSite_GetMoniker(client_site, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &mon);
516 ok(hres == S_OK, "GetMoniker failed: %08x\n", hres);
517 ok(mon != NULL, "mon == NULL\n");
518 test_mon_displayname(mon, "about:blank", NULL);
519 IMoniker_Release(mon);
520
521 set_plugin_readystate(READYSTATE_COMPLETE);
522
523 return S_OK;
524 }
525
526 static HRESULT WINAPI PersistPropertyBag_Save(IPersistPropertyBag *face, IPropertyBag *pPropBag, BOOL fClearDisrty, BOOL fSaveAllProperties)
527 {
528 ok(0, "unexpected call\n");
529 return E_NOTIMPL;
530 }
531
532 static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
533 PersistPropertyBag_QueryInterface,
534 PersistPropertyBag_AddRef,
535 PersistPropertyBag_Release,
536 PersistPropertyBag_GetClassID,
537 PersistPropertyBag_InitNew,
538 PersistPropertyBag_Load,
539 PersistPropertyBag_Save
540
541 };
542
543 static IPersistPropertyBag PersistPropertyBag = { &PersistPropertyBagVtbl };
544
545 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
546 {
547 return ax_qi(riid, ppv);
548 }
549
550 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
551 {
552 return 2;
553 }
554
555 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
556 {
557 return 1;
558 }
559
560 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
561 {
562 ok(0, "unexpected call\n");
563 return E_NOTIMPL;
564 }
565
566 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
567 ITypeInfo **ppTInfo)
568 {
569 ok(0, "unexpected call\n");
570 return E_NOTIMPL;
571 }
572
573 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
574 UINT cNames, LCID lcid, DISPID *rgDispId)
575 {
576 CHECK_EXPECT(GetIDsOfNames_scriptprop);
577 ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", debugstr_guid(riid));
578 ok(cNames == 1, "cNames = %d\n", cNames);
579 ok(rgszNames != NULL, "rgszNames == NULL\n");
580 ok(!strcmp_wa(rgszNames[0], "scriptprop"), "rgszNames[0] = %s\n", wine_dbgstr_w(rgszNames[0]));
581 ok(rgDispId != NULL, "rgDispId == NULL\n");
582
583 *rgDispId = DISPID_SCRIPTPROP;
584 return S_OK;
585 }
586
587 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
588 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
589 EXCEPINFO *pExcepInfo, UINT *puArgErr)
590 {
591 ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", debugstr_guid(riid));
592 ok(pDispParams != NULL, "pDispParams == NULL\n");
593 ok(!pDispParams->cNamedArgs, "pDispParams->cNamedArgs = %d\n", pDispParams->cNamedArgs);
594 ok(!pDispParams->rgdispidNamedArgs, "pDispParams->rgdispidNamedArgs != NULL\n");
595 ok(pVarResult != NULL, "pVarResult == NULL\n");
596
597 switch(dispIdMember) {
598 case DISPID_READYSTATE:
599 CHECK_EXPECT2(Invoke_READYSTATE);
600 ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
601 ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
602 ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
603 ok(!pExcepInfo, "pExcepInfo != NULL\n");
604 ok(puArgErr != NULL, "puArgErr == NULL\n");
605
606 V_VT(pVarResult) = VT_I4;
607 V_I4(pVarResult) = plugin_readystate;
608 return S_OK;
609 case DISPID_ENABLED:
610 CHECK_EXPECT2(Invoke_ENABLED);
611 ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
612 ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
613 ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
614 ok(!pExcepInfo, "pExcepInfo != NULL\n");
615 ok(puArgErr != NULL, "puArgErr == NULL\n");
616 return DISP_E_MEMBERNOTFOUND;
617 case DISPID_VALID:
618 CHECK_EXPECT(Invoke_VALID);
619 ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
620 ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
621 ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
622 ok(!pExcepInfo, "pExcepInfo != NULL\n");
623 ok(puArgErr != NULL, "puArgErr == NULL\n");
624 return DISP_E_MEMBERNOTFOUND;
625 case DISPID_SECURITYCTX:
626 CHECK_EXPECT(Invoke_SECURITYCTX);
627 ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
628 ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
629 ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
630 ok(!pExcepInfo, "pExcepInfo != NULL\n");
631 ok(puArgErr != NULL, "puArgErr == NULL\n");
632 return DISP_E_MEMBERNOTFOUND;
633 case DISPID_SCRIPTPROP:
634 CHECK_EXPECT(Invoke_SCRIPTPROP);
635 ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
636 ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
637 ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
638 ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
639 ok(!puArgErr, "puArgErr != NULL\n");
640
641 V_VT(pVarResult) = VT_I4;
642 V_I4(pVarResult) = 4;
643 return S_OK;
644 default:
645 ok(0, "unexpected call %d\n", dispIdMember);
646 }
647
648 return E_NOTIMPL;
649 }
650
651 static const IDispatchVtbl DispatchVtbl = {
652 Dispatch_QueryInterface,
653 Dispatch_AddRef,
654 Dispatch_Release,
655 Dispatch_GetTypeInfoCount,
656 Dispatch_GetTypeInfo,
657 Dispatch_GetIDsOfNames,
658 Dispatch_Invoke
659 };
660
661 static IDispatch Dispatch = { &DispatchVtbl };
662
663 static HRESULT WINAPI ViewObjectEx_QueryInterface(IViewObjectEx *iface, REFIID riid, void **ppv)
664 {
665 return ax_qi(riid, ppv);
666 }
667
668 static ULONG WINAPI ViewObjectEx_AddRef(IViewObjectEx *iface)
669 {
670 return 2;
671 }
672
673 static ULONG WINAPI ViewObjectEx_Release(IViewObjectEx *iface)
674 {
675 return 1;
676 }
677
678 static HRESULT WINAPI ViewObjectEx_Draw(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
679 HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBoungs, BOOL (WINAPI*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
680 {
681 ok(0, "unexpected call\n");
682 return E_NOTIMPL;
683 }
684
685 static HRESULT WINAPI ViewObjectEx_GetColorSet(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
686 HDC hicTargetDev, LOGPALETTE **ppColorSet)
687 {
688 ok(0, "unexpected call\n");
689 return E_NOTIMPL;
690 }
691
692 static HRESULT WINAPI ViewObjectEx_Freeze(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
693 {
694 ok(0, "unexpected call\n");
695 return E_NOTIMPL;
696 }
697
698 static HRESULT WINAPI ViewObjectEx_Unfreeze(IViewObjectEx *iface, DWORD dwFreeze)
699 {
700 ok(0, "unexpected call\n");
701 return E_NOTIMPL;
702 }
703
704 static HRESULT WINAPI ViewObjectEx_SetAdvise(IViewObjectEx *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
705 {
706 ok(0, "unexpected call\n");
707 return E_NOTIMPL;
708 }
709
710 static HRESULT WINAPI ViewObjectEx_GetAdvise(IViewObjectEx *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
711 {
712 ok(0, "unexpected call\n");
713 return E_NOTIMPL;
714 }
715
716 static HRESULT WINAPI ViewObjectEx_GetExtent(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
717 {
718 ok(0, "unexpected call\n");
719 return E_NOTIMPL;
720 }
721
722 static HRESULT WINAPI ViewObjectEx_GetRect(IViewObjectEx *iface, DWORD dwAspect, LPRECTL pRect)
723 {
724 ok(0, "unexpected call\n");
725 return E_NOTIMPL;
726 }
727
728 static HRESULT WINAPI ViewObjectEx_GetViewStatus(IViewObjectEx *iface, DWORD *pdwStatus)
729 {
730 ok(0, "unexpected call\n");
731 return E_NOTIMPL;
732 }
733
734 static HRESULT WINAPI ViewObjectEx_QueryHitPoint(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc,
735 LONG lCloseHint, DWORD *pHitResult)
736 {
737 ok(0, "unexpected call\n");
738 return E_NOTIMPL;
739 }
740
741 static HRESULT WINAPI ViewObjectEx_QueryHitRect(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc,
742 LONG lCloseHint, DWORD *pHitResult)
743 {
744 ok(0, "unexpected call\n");
745 return E_NOTIMPL;
746 }
747
748 static HRESULT WINAPI ViewObjectEx_GetNaturalExtent(IViewObjectEx *iface, DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd,
749 HDC hicTargetDev, DVEXTENTINFO *pExtentIngo, LPSIZEL pSizel)
750 {
751 ok(0, "unexpected call\n");
752 return E_NOTIMPL;
753 }
754
755 static const IViewObjectExVtbl ViewObjectExVtbl = {
756 ViewObjectEx_QueryInterface,
757 ViewObjectEx_AddRef,
758 ViewObjectEx_Release,
759 ViewObjectEx_Draw,
760 ViewObjectEx_GetColorSet,
761 ViewObjectEx_Freeze,
762 ViewObjectEx_Unfreeze,
763 ViewObjectEx_SetAdvise,
764 ViewObjectEx_GetAdvise,
765 ViewObjectEx_GetExtent,
766 ViewObjectEx_GetRect,
767 ViewObjectEx_GetViewStatus,
768 ViewObjectEx_QueryHitPoint,
769 ViewObjectEx_QueryHitRect,
770 ViewObjectEx_GetNaturalExtent
771 };
772
773 static IViewObjectEx ViewObjectEx = { &ViewObjectExVtbl };
774
775 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
776 {
777 return ax_qi(riid, ppv);
778 }
779
780 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
781 {
782 return 2;
783 }
784
785 static ULONG WINAPI OleObject_Release(IOleObject *iface)
786 {
787 return 1;
788 }
789
790 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
791 {
792 if(!pClientSite) {
793 CHECK_EXPECT(SetClientSite_NULL);
794 return S_OK;
795 }
796
797 CHECK_EXPECT(SetClientSite);
798 return E_NOTIMPL;
799 }
800
801 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
802 {
803 ok(0, "unexpected call\n");
804 return E_NOTIMPL;
805 }
806
807 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
808 {
809 ok(0, "unexpected call\n");
810 return E_NOTIMPL;
811 }
812
813 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
814 {
815 CHECK_EXPECT(Close);
816
817 ok(dwSaveOption == OLECLOSE_NOSAVE, "dwSaveOption = %d\n", dwSaveOption);
818 return S_OK;
819 }
820
821 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
822 {
823 ok(0, "unexpected call\n");
824 return E_NOTIMPL;
825 }
826
827 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
828 {
829 ok(0, "unexpected call\n");
830 return E_NOTIMPL;
831 }
832
833 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
834 DWORD dwReserved)
835 {
836 ok(0, "unexpected call\n");
837 return E_NOTIMPL;
838 }
839
840 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
841 {
842 ok(0, "unexpected call\n");
843 return E_NOTIMPL;
844 }
845
846 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
847 LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
848 {
849 OLEINPLACEFRAMEINFO frame_info = {0xdeadbeef};
850 IOleInPlaceUIWindow *ip_uiwindow;
851 IOleInPlaceFrame *ip_frame;
852 IOleInPlaceSiteEx *ip_site;
853 RECT pos_rect, clip_rect;
854 BOOL no_redraw;
855 HWND hwnd;
856 HRESULT hres;
857
858 CHECK_EXPECT(DoVerb);
859
860 ok(iVerb == OLEIVERB_INPLACEACTIVATE, "iVerb = %d\n", iVerb);
861 ok(!lpmsg, "lpmsg != NULL\n");
862 ok(pActiveSite != NULL, "pActiveSite == NULL\n");
863 ok(!lindex, "lindex = %d\n", lindex);
864 ok(hwndParent != NULL, "hwndParent == NULL\n");
865 ok(lprcPosRect != NULL, "lprcPosRect == NULL\n");
866
867 hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleInPlaceSiteEx, (void**)&ip_site);
868 ok(hres == S_OK, "Could not get IOleInPlaceSiteEx iface: %08x\n", hres);
869
870 SET_EXPECT(InPlaceObject_GetWindow);
871 no_redraw = 0xdeadbeef;
872 hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
873 ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
874 ok(!no_redraw, "no_redraw = %x\n", no_redraw);
875 CHECK_CALLED(InPlaceObject_GetWindow);
876
877 no_redraw = 0xdeadbeef;
878 hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
879 ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
880 ok(no_redraw == 0xdeadbeef, "no_redraw = %x\n", no_redraw);
881
882 hwnd = NULL;
883 hres = IOleInPlaceSiteEx_GetWindow(ip_site, &hwnd);
884 ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
885 ok(hwnd != NULL, "hwnd == NULL\n");
886 ok(hwnd == hwndParent, "hwnd != hwndParent\n");
887
888 create_plugin_window(hwnd, lprcPosRect);
889
890 ip_frame = NULL;
891 ip_uiwindow = NULL;
892 frame_info.cb = sizeof(OLEINPLACEFRAMEINFO);
893 hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
894 ok(hres == S_OK, "GetWindowContext failed: %08x\n", hres);
895 ok(ip_frame != NULL, "ip_frame == NULL\n");
896 ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
897 ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
898 ok(!memcmp(&pos_rect, lprcPosRect, sizeof(RECT)), "pos_rect != lpecPosRect\n");
899 ok(!memcmp(&clip_rect, lprcPosRect, sizeof(RECT)), "clip_rect != lpecPosRect\n");
900 ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
901 ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
902 ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
903 ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
904 ok(!frame_info.haccel, "frame_info.haccel != 0\n");
905 ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
906
907 IOleInPlaceFrame_Release(ip_frame);
908 IOleInPlaceUIWindow_Release(ip_uiwindow);
909
910
911 IOleInPlaceSiteEx_Release(ip_site);
912
913 hres = IOleClientSite_ShowObject(client_site);
914 ok(hres == S_OK, "ShowObject failed: %08x\n", hres);
915
916 SET_EXPECT(InPlaceObject_GetWindow);
917 SET_EXPECT(SetObjectRects);
918
919 return S_OK;
920 }
921
922 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
923 {
924 ok(0, "unexpected call\n");
925 return E_NOTIMPL;
926 }
927
928 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
929 {
930 ok(0, "unexpected call\n");
931 return E_NOTIMPL;
932 }
933
934 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
935 {
936 ok(0, "unexpected call\n");
937 return E_NOTIMPL;
938 }
939
940 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
941 {
942 ok(0, "unexpected call\n");
943 return E_NOTIMPL;
944 }
945
946 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
947 {
948 ok(0, "unexpected call\n");
949 return E_NOTIMPL;
950 }
951
952 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
953 {
954 CHECK_EXPECT(SetExtent);
955 return E_NOTIMPL;
956 }
957
958 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
959 {
960 CHECK_EXPECT(GetExtent);
961 return E_NOTIMPL;
962 }
963
964 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
965 {
966 ok(0, "unexpected call\n");
967 return E_NOTIMPL;
968 }
969
970 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
971 {
972 ok(0, "unexpected call\n");
973 return E_NOTIMPL;
974 }
975
976 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
977 {
978 ok(0, "unexpected call\n");
979 return E_NOTIMPL;
980 }
981
982 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
983 {
984 ok(0, "unexpected call\n");
985 return E_NOTIMPL;
986 }
987
988 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
989 {
990 ok(0, "unexpected call\n");
991 return E_NOTIMPL;
992 }
993
994 static const IOleObjectVtbl OleObjectVtbl = {
995 OleObject_QueryInterface,
996 OleObject_AddRef,
997 OleObject_Release,
998 OleObject_SetClientSite,
999 OleObject_GetClientSite,
1000 OleObject_SetHostNames,
1001 OleObject_Close,
1002 OleObject_SetMoniker,
1003 OleObject_GetMoniker,
1004 OleObject_InitFromData,
1005 OleObject_GetClipboardData,
1006 OleObject_DoVerb,
1007 OleObject_EnumVerbs,
1008 OleObject_Update,
1009 OleObject_IsUpToDate,
1010 OleObject_GetUserClassID,
1011 OleObject_GetUserType,
1012 OleObject_SetExtent,
1013 OleObject_GetExtent,
1014 OleObject_Advise,
1015 OleObject_Unadvise,
1016 OleObject_EnumAdvise,
1017 OleObject_GetMiscStatus,
1018 OleObject_SetColorScheme
1019 };
1020
1021 static IOleObject OleObject = { &OleObjectVtbl };
1022
1023 static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
1024 REFIID riid, void **ppv)
1025 {
1026 return ax_qi(riid, ppv);
1027 }
1028
1029 static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
1030 {
1031 return 2;
1032 }
1033
1034 static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
1035 {
1036 return 1;
1037 }
1038
1039 static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
1040 HWND *phwnd)
1041 {
1042 CHECK_EXPECT2(InPlaceObject_GetWindow);
1043
1044 ok(phwnd != NULL, "phwnd == NULL\n");
1045
1046 *phwnd = plugin_hwnd;
1047 return *phwnd ? S_OK : E_UNEXPECTED;
1048 }
1049
1050 static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
1051 BOOL fEnterMode)
1052 {
1053 ok(0, "unexpected call\n");
1054 return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
1058 {
1059 IOleInPlaceSite *ip_site;
1060 HRESULT hres;
1061
1062 CHECK_EXPECT(InPlaceDeactivate);
1063
1064 hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1065 ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1066
1067 hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
1068 ok(hres == S_OK, "OnInPlaceDeactivate failed: %08x\n", hres);
1069
1070 IOleInPlaceSite_Release(ip_site);
1071 return S_OK;
1072 }
1073
1074 static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
1075 {
1076 CHECK_EXPECT2(UIDeactivate);
1077 return S_OK;
1078 }
1079
1080 static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
1081 LPCRECT lprcPosRect, LPCRECT lprcClipRect)
1082 {
1083 CHECK_EXPECT(SetObjectRects);
1084 return S_OK;
1085 }
1086
1087 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
1088 {
1089 ok(0, "unexpected call\n");
1090 return E_NOTIMPL;
1091 }
1092
1093 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
1094 UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
1095 {
1096 ok(0, "unexpected call\n");
1097 return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
1101 IDropTarget **ppDropTarget)
1102 {
1103 ok(0, "unexpected call\n");
1104 return E_NOTIMPL;
1105 }
1106
1107 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
1108 OleInPlaceObject_QueryInterface,
1109 OleInPlaceObject_AddRef,
1110 OleInPlaceObject_Release,
1111 OleInPlaceObject_GetWindow,
1112 OleInPlaceObject_ContextSensitiveHelp,
1113 OleInPlaceObject_InPlaceDeactivate,
1114 OleInPlaceObject_UIDeactivate,
1115 OleInPlaceObject_SetObjectRects,
1116 OleInPlaceObjectWindowless_ReactivateAndUndo,
1117 OleInPlaceObjectWindowless_OnWindowMessage,
1118 OleInPlaceObjectWindowless_GetDropTarget
1119 };
1120
1121 static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
1122
1123 static HRESULT ax_qi(REFIID riid, void **ppv)
1124 {
1125 if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
1126 *ppv = &OleControl;
1127 return S_OK;
1128 }
1129
1130 if(IsEqualGUID(riid, &IID_IQuickActivate)) {
1131 *ppv = &QuickActivate;
1132 return S_OK;
1133 }
1134
1135 if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
1136 *ppv = &PersistPropertyBag;
1137 return S_OK;
1138 }
1139
1140 if(IsEqualGUID(riid, &IID_IDispatch)) {
1141 *ppv = &Dispatch;
1142 return S_OK;
1143 }
1144
1145 if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2) || IsEqualGUID(riid, &IID_IViewObjectEx)) {
1146 *ppv = &ViewObjectEx;
1147 return S_OK;
1148 }
1149
1150 if(IsEqualGUID(riid, &IID_IOleObject)) {
1151 *ppv = &OleObject;
1152 return S_OK;
1153 }
1154
1155 if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
1156 || IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
1157 *ppv = &OleInPlaceObjectWindowless;
1158 return S_OK;
1159 }
1160
1161 *ppv = NULL;
1162 return E_NOINTERFACE;
1163 }
1164
1165 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1166 {
1167 *ppv = NULL;
1168
1169 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1170 *ppv = iface;
1171 return S_OK;
1172 }
1173
1174 if(IsEqualGUID(&IID_IMarshal, riid))
1175 return E_NOINTERFACE;
1176 if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1177 return E_NOINTERFACE;
1178 if(IsEqualGUID(&IID_IClassFactoryEx, riid))
1179 return E_NOINTERFACE; /* TODO */
1180
1181 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1182 return E_NOTIMPL;
1183 }
1184
1185 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1186 {
1187 return 2;
1188 }
1189
1190 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1191 {
1192 return 1;
1193 }
1194
1195 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1196 {
1197 CHECK_EXPECT(CreateInstance);
1198
1199 ok(!outer, "outer = %p\n", outer);
1200 ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", debugstr_guid(riid));
1201
1202 *ppv = &OleControl;
1203 return S_OK;
1204 }
1205
1206 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1207 {
1208 ok(0, "unexpected call\n");
1209 return S_OK;
1210 }
1211
1212 static const IClassFactoryVtbl ClassFactoryVtbl = {
1213 ClassFactory_QueryInterface,
1214 ClassFactory_AddRef,
1215 ClassFactory_Release,
1216 ClassFactory_CreateInstance,
1217 ClassFactory_LockServer
1218 };
1219
1220 static IClassFactory activex_cf = { &ClassFactoryVtbl };
1221
1222 static void test_elem_dispex(IDispatchEx *dispex)
1223 {
1224 DISPPARAMS dp;
1225 EXCEPINFO ei;
1226 VARIANT v;
1227 DISPID id;
1228 BSTR str;
1229 HRESULT hres;
1230
1231 str = a2bstr("scriptprop");
1232 SET_EXPECT(GetIDsOfNames_scriptprop);
1233 hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
1234 CHECK_CALLED(GetIDsOfNames_scriptprop);
1235 SysFreeString(str);
1236 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1237 todo_wine
1238 ok(id == DISPID_SCRIPTPROP, "id = %d\n", id);
1239
1240 SET_EXPECT(Invoke_SECURITYCTX);
1241 SET_EXPECT(Invoke_SCRIPTPROP);
1242 memset(&dp, 0, sizeof(dp));
1243 memset(&ei, 0, sizeof(ei));
1244 V_VT(&v) = VT_EMPTY;
1245 hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
1246 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1247 ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
1248 ok(V_I4(&v) == 4, "V_I4(v) = %d\n", V_I4(&v));
1249 CHECK_CALLED(Invoke_SECURITYCTX);
1250 CHECK_CALLED(Invoke_SCRIPTPROP);
1251 }
1252
1253 static void test_object_elem(IHTMLDocument2 *doc)
1254 {
1255 IHTMLObjectElement *objelem;
1256 IHTMLDocument3 *doc3;
1257 IDispatchEx *dispex;
1258 IHTMLElement *elem;
1259 IDispatch *disp;
1260 BSTR str;
1261 HRESULT hres;
1262
1263 hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1264 ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
1265
1266 str = a2bstr("objid");
1267 elem = (void*)0xdeadbeef;
1268 hres = IHTMLDocument3_getElementById(doc3, str, &elem);
1269 IHTMLDocument3_Release(doc3);
1270 SysFreeString(str);
1271 ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1272 ok(elem != NULL, "elem == NULL\n");
1273
1274 hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
1275 IHTMLElement_Release(elem);
1276 ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08x\n", hres);
1277
1278 SET_EXPECT(Invoke_SECURITYCTX);
1279 hres = IHTMLObjectElement_get_object(objelem, &disp);
1280 ok(hres == S_OK, "get_object failed: %08x\n", hres);
1281 ok(disp == &Dispatch, "disp != Dispatch\n");
1282 CHECK_CALLED(Invoke_SECURITYCTX);
1283
1284 hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
1285 ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
1286 test_elem_dispex(dispex);
1287 IDispatchEx_Release(dispex);
1288
1289 IHTMLObjectElement_Release(objelem);
1290 }
1291
1292 static void test_container(IHTMLDocument2 *doc_obj)
1293 {
1294 IHTMLWindow2 *parent_window, *html_window;
1295 IServiceProvider *serv_prov;
1296 IOleContainer *container;
1297 IHTMLDocument2 *doc;
1298 IUnknown *unk;
1299 HRESULT hres;
1300
1301 container = NULL;
1302 hres = IOleClientSite_GetContainer(client_site, &container);
1303 ok(hres == S_OK, "GetContainer failed: %08x\n", hres);
1304 ok(container != NULL, "container == NULL\n");
1305
1306 hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
1307 ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1308 ok(parent_window != NULL, "parentWindow == NULL\n");
1309
1310 hres = IHTMLWindow2_get_document(parent_window, &doc);
1311 ok(hres == S_OK, "get_document failed: %08x\n", hres);
1312 ok(doc != NULL, "doc == NULL\n");
1313 ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
1314 IHTMLDocument2_Release(doc);
1315
1316 hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
1317 ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1318
1319 hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
1320 ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08x\n", hres);
1321 todo_wine
1322 ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
1323 IHTMLWindow2_Release(html_window);
1324
1325 SET_EXPECT(QueryService_TestActiveX);
1326 hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
1327 ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08x\n", hres);
1328 ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
1329 CHECK_CALLED(QueryService_TestActiveX);
1330
1331 IServiceProvider_Release(serv_prov);
1332
1333 IHTMLWindow2_Release(parent_window);
1334 IOleContainer_Release(container);
1335 }
1336
1337 static void test_ui_activate(void)
1338 {
1339 IOleInPlaceSite *ip_site;
1340 HRESULT hres;
1341
1342 hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1343 ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1344
1345 SET_EXPECT(Invoke_ENABLED);
1346 hres = IOleInPlaceSite_OnUIActivate(ip_site);
1347 ok(hres == S_OK, "OnUIActivate failed: %08x\n", hres);
1348 CHECK_CALLED(Invoke_ENABLED);
1349
1350 IOleInPlaceSite_Release(ip_site);
1351 }
1352
1353 static HRESULT cs_qi(REFIID,void **);
1354 static IOleDocumentView *view;
1355
1356 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1357 {
1358 static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1359
1360 if(!IsEqualGUID(&undocumented_frame_iid, riid))
1361 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1362
1363 *ppv = NULL;
1364 return E_NOINTERFACE;
1365 }
1366
1367 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1368 {
1369 return 2;
1370 }
1371
1372 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1373 {
1374 return 1;
1375 }
1376
1377 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1378 {
1379 return E_NOTIMPL;
1380 }
1381
1382 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1383 {
1384 return E_NOTIMPL;
1385 }
1386
1387 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1388 {
1389 return E_NOTIMPL;
1390 }
1391
1392 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1393 LPCBORDERWIDTHS pborderwidths)
1394 {
1395 return E_NOTIMPL;
1396 }
1397
1398 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1399 LPCBORDERWIDTHS pborderwidths)
1400 {
1401 return S_OK;
1402 }
1403
1404 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1405 IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1406 {
1407 return S_OK;
1408 }
1409
1410 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1411 IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1412 {
1413 return S_OK;
1414 }
1415
1416 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1417 LPOLEMENUGROUPWIDTHS lpMenuWidths)
1418 {
1419 return E_NOTIMPL;
1420 }
1421
1422 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1423 HOLEMENU holemenu, HWND hwndActiveObject)
1424 {
1425 ok(0, "unexpected call\n");
1426 return E_NOTIMPL;
1427 }
1428
1429 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1430 {
1431 ok(0, "unexpected call\n");
1432 return E_NOTIMPL;
1433 }
1434
1435 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1436 {
1437 return S_OK;
1438 }
1439
1440 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1441 {
1442 return E_NOTIMPL;
1443 }
1444
1445 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1446 {
1447 ok(0, "unexpected call\n");
1448 return E_NOTIMPL;
1449 }
1450
1451 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1452 InPlaceFrame_QueryInterface,
1453 InPlaceFrame_AddRef,
1454 InPlaceFrame_Release,
1455 InPlaceFrame_GetWindow,
1456 InPlaceFrame_ContextSensitiveHelp,
1457 InPlaceFrame_GetBorder,
1458 InPlaceFrame_RequestBorderSpace,
1459 InPlaceFrame_SetBorderSpace,
1460 InPlaceFrame_SetActiveObject,
1461 InPlaceFrame_InsertMenus,
1462 InPlaceFrame_SetMenu,
1463 InPlaceFrame_RemoveMenus,
1464 InPlaceFrame_SetStatusText,
1465 InPlaceFrame_EnableModeless,
1466 InPlaceFrame_TranslateAccelerator
1467 };
1468
1469 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1470
1471 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1472 InPlaceFrame_QueryInterface,
1473 InPlaceFrame_AddRef,
1474 InPlaceFrame_Release,
1475 InPlaceFrame_GetWindow,
1476 InPlaceFrame_ContextSensitiveHelp,
1477 InPlaceFrame_GetBorder,
1478 InPlaceFrame_RequestBorderSpace,
1479 InPlaceFrame_SetBorderSpace,
1480 InPlaceUIWindow_SetActiveObject,
1481 };
1482
1483 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1484
1485 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1486 {
1487 return cs_qi(riid, ppv);
1488 }
1489
1490 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1491 {
1492 return 2;
1493 }
1494
1495 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1496 {
1497 return 1;
1498 }
1499
1500 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1501 {
1502 *phwnd = container_hwnd;
1503 return S_OK;
1504 }
1505
1506 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1507 {
1508 ok(0, "unexpected call\n");
1509 return E_NOTIMPL;
1510 }
1511
1512 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1513 {
1514 return S_OK;
1515 }
1516
1517 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1518 {
1519 return S_OK;
1520 }
1521
1522 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1523 {
1524 return S_OK;
1525 }
1526
1527 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1528 IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1529 LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1530 {
1531 static const RECT rect = {0,0,500,500};
1532
1533 *ppFrame = &InPlaceFrame;
1534 *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1535 *lprcPosRect = rect;
1536 *lprcClipRect = rect;
1537
1538 lpFrameInfo->fMDIApp = FALSE;
1539 lpFrameInfo->hwndFrame = container_hwnd;
1540 lpFrameInfo->haccel = NULL;
1541 lpFrameInfo->cAccelEntries = 0;
1542
1543 return S_OK;
1544 }
1545
1546 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1547 {
1548 return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1552 {
1553 return S_OK;
1554 }
1555
1556 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1557 {
1558 return S_OK;
1559 }
1560
1561 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1562 {
1563 return E_NOTIMPL;
1564 }
1565
1566 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1567 {
1568 return E_NOTIMPL;
1569 }
1570
1571 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1572 {
1573 return E_NOTIMPL;
1574 }
1575
1576 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1577 InPlaceSite_QueryInterface,
1578 InPlaceSite_AddRef,
1579 InPlaceSite_Release,
1580 InPlaceSite_GetWindow,
1581 InPlaceSite_ContextSensitiveHelp,
1582 InPlaceSite_CanInPlaceActivate,
1583 InPlaceSite_OnInPlaceActivate,
1584 InPlaceSite_OnUIActivate,
1585 InPlaceSite_GetWindowContext,
1586 InPlaceSite_Scroll,
1587 InPlaceSite_OnUIDeactivate,
1588 InPlaceSite_OnInPlaceDeactivate,
1589 InPlaceSite_DiscardUndoState,
1590 InPlaceSite_DeactivateAndUndo,
1591 InPlaceSite_OnPosRectChange,
1592 };
1593
1594 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1595
1596 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1597 {
1598 return cs_qi(riid, ppv);
1599 }
1600
1601 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1602 {
1603 return 2;
1604 }
1605
1606 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1607 {
1608 return 1;
1609 }
1610
1611 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1612 {
1613 ok(0, "unexpected call\n");
1614 return E_NOTIMPL;
1615 }
1616
1617 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1618 IMoniker **ppmon)
1619 {
1620 ok(0, "unexpected call\n");
1621 return E_NOTIMPL;
1622 }
1623
1624 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1625 {
1626 return E_NOTIMPL;
1627 }
1628
1629 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1630 {
1631 ok(0, "unexpected call\n");
1632 return E_NOTIMPL;
1633 }
1634
1635 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1636 {
1637 ok(0, "unexpected call\n");
1638 return E_NOTIMPL;
1639 }
1640
1641 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1642 {
1643 ok(0, "unexpected call\n");
1644 return E_NOTIMPL;
1645 }
1646
1647 static const IOleClientSiteVtbl ClientSiteVtbl = {
1648 ClientSite_QueryInterface,
1649 ClientSite_AddRef,
1650 ClientSite_Release,
1651 ClientSite_SaveObject,
1652 ClientSite_GetMoniker,
1653 ClientSite_GetContainer,
1654 ClientSite_ShowObject,
1655 ClientSite_OnShowWindow,
1656 ClientSite_RequestNewObjectLayout
1657 };
1658
1659 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1660
1661 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1662 {
1663 return cs_qi(riid, ppv);
1664 }
1665
1666 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1667 {
1668 return 2;
1669 }
1670
1671 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1672 {
1673 return 1;
1674 }
1675
1676 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1677 {
1678 RECT rect = {0,0,400,500};
1679 IOleDocument *document;
1680 HRESULT hres;
1681
1682 hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1683 ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1684
1685 hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1686 IOleDocument_Release(document);
1687 ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1688
1689 hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1690 ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1691
1692 hres = IOleDocumentView_UIActivate(view, TRUE);
1693 ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1694
1695 hres = IOleDocumentView_SetRect(view, &rect);
1696 ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1697
1698 hres = IOleDocumentView_Show(view, TRUE);
1699 ok(hres == S_OK, "Show failed: %08x\n", hres);
1700
1701 return S_OK;
1702 }
1703
1704 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1705 DocumentSite_QueryInterface,
1706 DocumentSite_AddRef,
1707 DocumentSite_Release,
1708 DocumentSite_ActivateMe
1709 };
1710
1711 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1712
1713 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1714 REFIID riid, void **ppv)
1715 {
1716 return cs_qi(riid, ppv);
1717 }
1718
1719 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1720 {
1721 return 2;
1722 }
1723
1724 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1725 {
1726 return 1;
1727 }
1728
1729 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
1730 REFIID riid, void **ppv)
1731 {
1732 if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
1733 CHECK_EXPECT(QueryService_TestActiveX);
1734 ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
1735 *ppv = &OleObject;
1736 return S_OK;
1737 }
1738
1739 *ppv = NULL;
1740 return E_NOINTERFACE;
1741 }
1742
1743 static const IServiceProviderVtbl ServiceProviderVtbl = {
1744 ServiceProvider_QueryInterface,
1745 ServiceProvider_AddRef,
1746 ServiceProvider_Release,
1747 ServiceProvider_QueryService
1748 };
1749
1750 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1751
1752 static HRESULT cs_qi(REFIID riid, void **ppv)
1753 {
1754 *ppv = NULL;
1755
1756 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1757 *ppv = &ClientSite;
1758 else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1759 *ppv = &DocumentSite;
1760 else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1761 *ppv = &InPlaceSite;
1762 else if(IsEqualGUID(riid, &IID_IServiceProvider))
1763 *ppv = &ServiceProvider;
1764
1765 return *ppv ? S_OK : E_NOINTERFACE;
1766 }
1767
1768 static IHTMLDocument2 *notif_doc;
1769 static BOOL doc_complete;
1770
1771 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
1772 REFIID riid, void**ppv)
1773 {
1774 if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1775 *ppv = iface;
1776 return S_OK;
1777 }
1778
1779 ok(0, "unexpected call\n");
1780 return E_NOINTERFACE;
1781 }
1782
1783 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
1784 {
1785 return 2;
1786 }
1787
1788 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
1789 {
1790 return 1;
1791 }
1792
1793 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
1794 {
1795 if(dispID == DISPID_READYSTATE){
1796 BSTR state;
1797 HRESULT hres;
1798
1799 static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
1800
1801 hres = IHTMLDocument2_get_readyState(notif_doc, &state);
1802 ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1803
1804 if(!lstrcmpW(state, completeW))
1805 doc_complete = TRUE;
1806
1807 SysFreeString(state);
1808 }
1809
1810 return S_OK;
1811 }
1812
1813 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
1814 {
1815 ok(0, "unexpected call\n");
1816 return E_NOTIMPL;
1817 }
1818
1819 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
1820 PropertyNotifySink_QueryInterface,
1821 PropertyNotifySink_AddRef,
1822 PropertyNotifySink_Release,
1823 PropertyNotifySink_OnChanged,
1824 PropertyNotifySink_OnRequestEdit
1825 };
1826
1827 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
1828
1829 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
1830 {
1831 IPersistStreamInit *init;
1832 IStream *stream;
1833 HGLOBAL mem;
1834 SIZE_T len;
1835
1836 notif_doc = doc;
1837
1838 doc_complete = FALSE;
1839 len = strlen(str);
1840 mem = GlobalAlloc(0, len);
1841 memcpy(mem, str, len);
1842 CreateStreamOnHGlobal(mem, TRUE, &stream);
1843
1844 IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1845
1846 IPersistStreamInit_Load(init, stream);
1847 IPersistStreamInit_Release(init);
1848 IStream_Release(stream);
1849 }
1850
1851 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
1852 {
1853 IConnectionPointContainer *container;
1854 IConnectionPoint *cp;
1855 DWORD cookie;
1856 HRESULT hres;
1857
1858 hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
1859 ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1860
1861 hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1862 IConnectionPointContainer_Release(container);
1863 ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1864
1865 hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1866 IConnectionPoint_Release(cp);
1867 ok(hres == S_OK, "Advise failed: %08x\n", hres);
1868 }
1869
1870 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1871 {
1872 IOleObject *oleobj;
1873 HRESULT hres;
1874
1875 if(!set && view) {
1876 IOleDocumentView_Show(view, FALSE);
1877 IOleDocumentView_CloseView(view, 0);
1878 IOleDocumentView_SetInPlaceSite(view, NULL);
1879 IOleDocumentView_Release(view);
1880 view = NULL;
1881 }
1882
1883 hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1884 ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1885
1886 hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1887 ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1888
1889 if(set) {
1890 IHlinkTarget *hlink;
1891
1892 hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1893 ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1894
1895 hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1896 ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1897
1898 IHlinkTarget_Release(hlink);
1899 }
1900
1901 IOleObject_Release(oleobj);
1902 }
1903 static IHTMLDocument2 *create_document(void)
1904 {
1905 IHTMLDocument2 *doc;
1906 HRESULT hres;
1907
1908 hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1909 &IID_IHTMLDocument2, (void**)&doc);
1910 ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1911
1912 return doc;
1913 }
1914
1915 static IHTMLDocument2 *create_doc(const char *str, BOOL *b)
1916 {
1917 IHTMLDocument2 *doc;
1918 MSG msg;
1919
1920 doc = create_document();
1921 set_client_site(doc, TRUE);
1922 doc_load_string(doc, str);
1923 do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1924
1925 while((!doc_complete || (b && !*b)) && GetMessage(&msg, NULL, 0, 0)) {
1926 TranslateMessage(&msg);
1927 DispatchMessage(&msg);
1928 }
1929
1930 return doc;
1931 }
1932
1933 static void release_doc(IHTMLDocument2 *doc)
1934 {
1935 ULONG ref;
1936
1937 set_client_site(doc, FALSE);
1938 ref = IHTMLDocument2_Release(doc);
1939 ok(!ref, "ref = %d\n", ref);
1940
1941 if(client_site) {
1942 IOleClientSite_Release(client_site);
1943 client_site = NULL;
1944 }
1945
1946 if(plugin_hwnd) {
1947 DestroyWindow(plugin_hwnd);
1948 plugin_hwnd = NULL;
1949 }
1950 }
1951
1952 static void test_object_ax(void)
1953 {
1954 IHTMLDocument2 *doc;
1955
1956 /*
1957 * We pump messages until both document is loaded and plugin instance is created.
1958 * Pumping until document is loaded should be enough, but Gecko loads plugins
1959 * asynchronously and until we'll work around it, we need this hack.
1960 */
1961 SET_EXPECT(CreateInstance);
1962 SET_EXPECT(FreezeEvents_TRUE);
1963 SET_EXPECT(QuickActivate);
1964 SET_EXPECT(FreezeEvents_FALSE);
1965 SET_EXPECT(IPersistPropertyBag_Load);
1966 SET_EXPECT(Invoke_READYSTATE);
1967 SET_EXPECT(SetExtent);
1968 SET_EXPECT(GetExtent);
1969 SET_EXPECT(DoVerb);
1970
1971 doc = create_doc(object_ax_str, &called_CreateInstance);
1972
1973 CHECK_CALLED(CreateInstance);
1974 todo_wine
1975 CHECK_CALLED(FreezeEvents_TRUE);
1976 CHECK_CALLED(QuickActivate);
1977 todo_wine
1978 CHECK_CALLED(FreezeEvents_FALSE);
1979 CHECK_CALLED(IPersistPropertyBag_Load);
1980 CHECK_CALLED(Invoke_READYSTATE);
1981 todo_wine
1982 CHECK_CALLED(SetExtent);
1983 todo_wine
1984 CHECK_CALLED(GetExtent);
1985 CHECK_CALLED(DoVerb);
1986
1987 /* Set in DoVerb */
1988 CHECK_CALLED(InPlaceObject_GetWindow);
1989 CHECK_CALLED(SetObjectRects);
1990
1991 test_ui_activate();
1992 test_container(notif_doc);
1993 test_object_elem(notif_doc);
1994
1995 SET_EXPECT(UIDeactivate);
1996 SET_EXPECT(Invoke_ENABLED);
1997 SET_EXPECT(Invoke_VALID);
1998 SET_EXPECT(InPlaceDeactivate);
1999 SET_EXPECT(Close);
2000 SET_EXPECT(SetClientSite_NULL);
2001 release_doc(doc);
2002 CHECK_CALLED(UIDeactivate);
2003 todo_wine
2004 CHECK_CALLED(Invoke_ENABLED);
2005 todo_wine
2006 CHECK_CALLED(Invoke_VALID);
2007 CHECK_CALLED(InPlaceDeactivate);
2008 CHECK_CALLED(Close);
2009 CHECK_CALLED(SetClientSite_NULL);
2010 }
2011
2012 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2013 {
2014 return DefWindowProc(hwnd, msg, wParam, lParam);
2015 }
2016
2017 static HWND create_container_window(void)
2018 {
2019 static const WCHAR html_document_testW[] =
2020 {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
2021 static WNDCLASSEXW wndclass = {
2022 sizeof(WNDCLASSEXW),
2023 0,
2024 wnd_proc,
2025 0, 0, NULL, NULL, NULL, NULL, NULL,
2026 html_document_testW,
2027 NULL
2028 };
2029
2030 RegisterClassExW(&wndclass);
2031 return CreateWindowW(html_document_testW, html_document_testW,
2032 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2033 515, 530, NULL, NULL, NULL, NULL);
2034 }
2035
2036 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
2037 {
2038 HKEY hkey;
2039 DWORD res;
2040
2041 if(!init) {
2042 RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
2043 return TRUE;
2044 }
2045
2046 res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
2047 if(res != ERROR_SUCCESS)
2048 return FALSE;
2049
2050 if(def_value)
2051 res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
2052
2053 RegCloseKey(hkey);
2054
2055 return res == ERROR_SUCCESS;
2056 }
2057
2058 static BOOL init_registry(BOOL init)
2059 {
2060 return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
2061 && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
2062 NULL, init)
2063 && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
2064 NULL, init);
2065 }
2066
2067 static BOOL register_activex(void)
2068 {
2069 DWORD regid;
2070 HRESULT hres;
2071
2072 if(!init_registry(TRUE)) {
2073 init_registry(FALSE);
2074 return FALSE;
2075 }
2076
2077 hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
2078 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, ®id);
2079 ok(hres == S_OK, "Could not register control: %08x\n", hres);
2080
2081 return TRUE;
2082 }
2083
2084 static BOOL check_ie(void)
2085 {
2086 IHTMLDocument5 *doc;
2087 HRESULT hres;
2088
2089 static const WCHAR xW[] = {'x',0};
2090 static const WCHAR yW[] = {'y',0};
2091
2092 if(!lstrcmpW(xW, yW))
2093 return FALSE;
2094
2095 hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2096 &IID_IHTMLDocument5, (void**)&doc);
2097 if(FAILED(hres))
2098 return FALSE;
2099
2100 IHTMLDocument5_Release(doc);
2101 return TRUE;
2102 }
2103
2104 START_TEST(activex)
2105 {
2106 CoInitialize(NULL);
2107
2108 if(!check_ie()) {
2109 CoUninitialize();
2110 win_skip("Too old IE\n");
2111 return;
2112 }
2113
2114 if(is_ie_hardened()) {
2115 CoUninitialize();
2116 win_skip("IE running in Enhanced Security Configuration\n");
2117 return;
2118 }
2119
2120 container_hwnd = create_container_window();
2121 ShowWindow(container_hwnd, SW_SHOW);
2122
2123 if(register_activex()) {
2124 test_object_ax();
2125 init_registry(FALSE);
2126 }else {
2127 skip("Could not register ActiveX\n");
2128 }
2129
2130 DestroyWindow(container_hwnd);
2131 CoUninitialize();
2132 }
2133
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.