?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Assorted spelling fixes.
[wine/multimedia.git] / dlls / ole32 / ole2.c
blobbaaf02e9911b656c8b9a1d5a8a51c465b44302ca
1 /*
2 * OLE2 library
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1999 Francis Beaudet
6 * Copyright 1999 Noel Borthwick
7 * Copyright 1999, 2000 Marcus Meissner
8 * Copyright 2005 Juan Lang
9 * Copyright 2011 Adam Martinson for CodeWeavers
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include "config.h"
27
28 #include <assert.h>
29 #include <stdlib.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <string.h>
33
34 #define COBJMACROS
35 #define NONAMELESSUNION
36 #define NONAMELESSSTRUCT
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winerror.h"
41 #include "wingdi.h"
42 #include "winuser.h"
43 #include "winnls.h"
44 #include "winreg.h"
45 #include "ole2.h"
46 #include "ole2ver.h"
47
48 #include "wine/unicode.h"
49 #include "compobj_private.h"
50 #include "wine/list.h"
51
52 #include "wine/debug.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(ole);
55 WINE_DECLARE_DEBUG_CHANNEL(accel);
56
57 /******************************************************************************
58 * These are static/global variables and internal data structures that the
59 * OLE module uses to maintain its state.
60 */
61 typedef struct tagTrackerWindowInfo
62 {
63 IDataObject* dataObject;
64 IDropSource* dropSource;
65 DWORD dwOKEffect;
66 DWORD* pdwEffect;
67 BOOL trackingDone;
68 HRESULT returnValue;
69
70 BOOL escPressed;
71 HWND curTargetHWND; /* window the mouse is hovering over */
72 HWND curDragTargetHWND; /* might be an ancestor of curTargetHWND */
73 IDropTarget* curDragTarget;
74 POINTL curMousePos; /* current position of the mouse in screen coordinates */
75 DWORD dwKeyState; /* current state of the shift and ctrl keys and the mouse buttons */
76 } TrackerWindowInfo;
77
78 typedef struct tagOleMenuDescriptor /* OleMenuDescriptor */
79 {
80 HWND hwndFrame; /* The containers frame window */
81 HWND hwndActiveObject; /* The active objects window */
82 OLEMENUGROUPWIDTHS mgw; /* OLE menu group widths for the shared menu */
83 HMENU hmenuCombined; /* The combined menu */
84 BOOL bIsServerItem; /* True if the currently open popup belongs to the server */
85 } OleMenuDescriptor;
86
87 typedef struct tagOleMenuHookItem /* OleMenu hook item in per thread hook list */
88 {
89 DWORD tid; /* Thread Id */
90 HANDLE hHeap; /* Heap this is allocated from */
91 HHOOK GetMsg_hHook; /* message hook for WH_GETMESSAGE */
92 HHOOK CallWndProc_hHook; /* message hook for WH_CALLWNDPROC */
93 struct tagOleMenuHookItem *next;
94 } OleMenuHookItem;
95
96 static OleMenuHookItem *hook_list;
97
98 /*
99 * This is the lock count on the OLE library. It is controlled by the
100 * OLEInitialize/OLEUninitialize methods.
101 */
102 static LONG OLE_moduleLockCount = 0;
103
104 /*
105 * Name of our registered window class.
106 */
107 static const WCHAR OLEDD_DRAGTRACKERCLASS[] =
108 {'W','i','n','e','D','r','a','g','D','r','o','p','T','r','a','c','k','e','r','3','2',0};
109
110 /*
111 * Name of menu descriptor property.
112 */
113 static const WCHAR prop_olemenuW[] =
114 {'P','R','O','P','_','O','L','E','M','e','n','u','D','e','s','c','r','i','p','t','o','r',0};
115
116 /* property to store IDropTarget pointer */
117 static const WCHAR prop_oledroptarget[] =
118 {'O','l','e','D','r','o','p','T','a','r','g','e','t','I','n','t','e','r','f','a','c','e',0};
119
120 /* property to store Marshalled IDropTarget pointer */
121 static const WCHAR prop_marshalleddroptarget[] =
122 {'W','i','n','e','M','a','r','s','h','a','l','l','e','d','D','r','o','p','T','a','r','g','e','t',0};
123
124 static const WCHAR clsidfmtW[] =
125 {'C','L','S','I','D','\\','{','%','0','8','x','-','%','0','4','x','-','%','0','4','x','-',
126 '%','0','2','x','%','0','2','x','-','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
127 '%','0','2','x','%','0','2','x','}','\\',0};
128
129 static const WCHAR emptyW[] = { 0 };
130
131 /******************************************************************************
132 * These are the prototypes of miscellaneous utility methods
133 */
134 static void OLEUTL_ReadRegistryDWORDValue(HKEY regKey, DWORD* pdwValue);
135
136 /******************************************************************************
137 * These are the prototypes of the utility methods used to manage a shared menu
138 */
139 static void OLEMenu_Initialize(void);
140 static void OLEMenu_UnInitialize(void);
141 static BOOL OLEMenu_InstallHooks( DWORD tid );
142 static BOOL OLEMenu_UnInstallHooks( DWORD tid );
143 static OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid );
144 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos );
145 static BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor );
146 static LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam);
147 static LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam);
148
149 /******************************************************************************
150 * These are the prototypes of the OLE Clipboard initialization methods (in clipboard.c)
151 */
152 extern void OLEClipbrd_UnInitialize(void);
153 extern void OLEClipbrd_Initialize(void);
154
155 /******************************************************************************
156 * These are the prototypes of the utility methods used for OLE Drag n Drop
157 */
158 static void OLEDD_Initialize(void);
159 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
160 static void OLEDD_TrackMouseMove(TrackerWindowInfo* trackerInfo);
161 static void OLEDD_TrackStateChange(TrackerWindowInfo* trackerInfo);
162 static DWORD OLEDD_GetButtonState(void);
163
164 /******************************************************************************
165 * OleBuildVersion [OLE32.@]
166 */
167 DWORD WINAPI OleBuildVersion(void)
168 {
169 TRACE("Returning version %d, build %d.\n", rmm, rup);
170 return (rmm<<16)+rup;
171 }
172
173 /***********************************************************************
174 * OleInitialize (OLE32.@)
175 */
176 HRESULT WINAPI OleInitialize(LPVOID reserved)
177 {
178 HRESULT hr;
179
180 TRACE("(%p)\n", reserved);
181
182 /*
183 * The first duty of the OleInitialize is to initialize the COM libraries.
184 */
185 hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
186
187 /*
188 * If the CoInitializeEx call failed, the OLE libraries can't be
189 * initialized.
190 */
191 if (FAILED(hr))
192 return hr;
193
194 if (!COM_CurrentInfo()->ole_inits)
195 hr = S_OK;
196
197 /*
198 * Then, it has to initialize the OLE specific modules.
199 * This includes:
200 * Clipboard
201 * Drag and Drop
202 * Object linking and Embedding
203 * In-place activation
204 */
205 if (!COM_CurrentInfo()->ole_inits++ &&
206 InterlockedIncrement(&OLE_moduleLockCount) == 1)
207 {
208 /*
209 * Initialize the libraries.
210 */
211 TRACE("() - Initializing the OLE libraries\n");
212
213 /*
214 * OLE Clipboard
215 */
216 OLEClipbrd_Initialize();
217
218 /*
219 * Drag and Drop
220 */
221 OLEDD_Initialize();
222
223 /*
224 * OLE shared menu
225 */
226 OLEMenu_Initialize();
227 }
228
229 return hr;
230 }
231
232 /******************************************************************************
233 * OleUninitialize [OLE32.@]
234 */
235 void WINAPI OleUninitialize(void)
236 {
237 TRACE("()\n");
238
239 /*
240 * If we hit the bottom of the lock stack, free the libraries.
241 */
242 if (!--COM_CurrentInfo()->ole_inits && !InterlockedDecrement(&OLE_moduleLockCount))
243 {
244 /*
245 * Actually free the libraries.
246 */
247 TRACE("() - Freeing the last reference count\n");
248
249 /*
250 * OLE Clipboard
251 */
252 OLEClipbrd_UnInitialize();
253
254 /*
255 * OLE shared menu
256 */
257 OLEMenu_UnInitialize();
258 }
259
260 /*
261 * Then, uninitialize the COM libraries.
262 */
263 CoUninitialize();
264 }
265
266 /******************************************************************************
267 * OleInitializeWOW [OLE32.@]
268 */
269 HRESULT WINAPI OleInitializeWOW(DWORD x, DWORD y) {
270 FIXME("(0x%08x, 0x%08x),stub!\n",x, y);
271 return 0;
272 }
273
274 /*************************************************************
275 * get_droptarget_handle
276 *
277 * Retrieve a handle to the map containing the marshalled IDropTarget.
278 * This handle belongs to the process that called RegisterDragDrop.
279 * See get_droptarget_local_handle().
280 */
281 static inline HANDLE get_droptarget_handle(HWND hwnd)
282 {
283 return GetPropW(hwnd, prop_marshalleddroptarget);
284 }
285
286 /*************************************************************
287 * is_droptarget
288 *
289 * Is the window a droptarget.
290 */
291 static inline BOOL is_droptarget(HWND hwnd)
292 {
293 return get_droptarget_handle(hwnd) != 0;
294 }
295
296 /*************************************************************
297 * get_droptarget_local_handle
298 *
299 * Retrieve a handle to the map containing the marshalled IDropTarget.
300 * The handle should be closed when finished with.
301 */
302 static HANDLE get_droptarget_local_handle(HWND hwnd)
303 {
304 HANDLE handle, local_handle = 0;
305
306 handle = get_droptarget_handle(hwnd);
307
308 if(handle)
309 {
310 DWORD pid;
311 HANDLE process;
312
313 GetWindowThreadProcessId(hwnd, &pid);
314 process = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
315 if(process)
316 {
317 DuplicateHandle(process, handle, GetCurrentProcess(), &local_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
318 CloseHandle(process);
319 }
320 }
321 return local_handle;
322 }
323
324 /***********************************************************************
325 * create_map_from_stream
326 *
327 * Helper for RegisterDragDrop. Creates a file mapping object
328 * with the contents of the provided stream. The stream must
329 * be a global memory backed stream.
330 */
331 static HRESULT create_map_from_stream(IStream *stream, HANDLE *map)
332 {
333 HGLOBAL hmem;
334 DWORD size;
335 HRESULT hr;
336 void *data;
337
338 hr = GetHGlobalFromStream(stream, &hmem);
339 if(FAILED(hr)) return hr;
340
341 size = GlobalSize(hmem);
342 *map = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, NULL);
343 if(!*map) return E_OUTOFMEMORY;
344
345 data = MapViewOfFile(*map, FILE_MAP_WRITE, 0, 0, size);
346 memcpy(data, GlobalLock(hmem), size);
347 GlobalUnlock(hmem);
348 UnmapViewOfFile(data);
349 return S_OK;
350 }
351
352 /***********************************************************************
353 * create_stream_from_map
354 *
355 * Creates a stream from the provided map.
356 */
357 static HRESULT create_stream_from_map(HANDLE map, IStream **stream)
358 {
359 HRESULT hr = E_OUTOFMEMORY;
360 HGLOBAL hmem;
361 void *data;
362 MEMORY_BASIC_INFORMATION info;
363
364 data = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
365 if(!data) return hr;
366
367 VirtualQuery(data, &info, sizeof(info));
368 TRACE("size %d\n", (int)info.RegionSize);
369
370 hmem = GlobalAlloc(GMEM_MOVEABLE, info.RegionSize);
371 if(hmem)
372 {
373 memcpy(GlobalLock(hmem), data, info.RegionSize);
374 GlobalUnlock(hmem);
375 hr = CreateStreamOnHGlobal(hmem, TRUE, stream);
376 }
377 UnmapViewOfFile(data);
378 return hr;
379 }
380
381 /* This is to work around apps which break COM rules by not implementing
382 * IDropTarget::QueryInterface(). Windows doesn't expose this because it
383 * doesn't call CoMarshallInterface() in RegisterDragDrop().
384 * The wrapper is only used internally, and only exists for the life of
385 * the marshal. We don't want to hold a ref on the app provided target
386 * as some apps destroy this prior to CoUninitialize without calling
387 * RevokeDragDrop. The only (long-term) ref is held by the window prop. */
388 typedef struct {
389 IDropTarget IDropTarget_iface;
390 HWND hwnd;
391 LONG refs;
392 } DropTargetWrapper;
393
394 static inline DropTargetWrapper* impl_from_IDropTarget(IDropTarget* iface)
395 {
396 return CONTAINING_RECORD(iface, DropTargetWrapper, IDropTarget_iface);
397 }
398
399 static HRESULT WINAPI DropTargetWrapper_QueryInterface(IDropTarget* iface,
400 REFIID riid,
401 void** ppvObject)
402 {
403 DropTargetWrapper* This = impl_from_IDropTarget(iface);
404 if (IsEqualIID(riid, &IID_IUnknown) ||
405 IsEqualIID(riid, &IID_IDropTarget))
406 {
407 IDropTarget_AddRef(&This->IDropTarget_iface);
408 *ppvObject = &This->IDropTarget_iface;
409 return S_OK;
410 }
411 *ppvObject = NULL;
412 return E_NOINTERFACE;
413 }
414
415 static ULONG WINAPI DropTargetWrapper_AddRef(IDropTarget* iface)
416 {
417 DropTargetWrapper* This = impl_from_IDropTarget(iface);
418 return InterlockedIncrement(&This->refs);
419 }
420
421 static ULONG WINAPI DropTargetWrapper_Release(IDropTarget* iface)
422 {
423 DropTargetWrapper* This = impl_from_IDropTarget(iface);
424 ULONG refs = InterlockedDecrement(&This->refs);
425 if (!refs) HeapFree(GetProcessHeap(), 0, This);
426 return refs;
427 }
428
429 static inline HRESULT get_target_from_wrapper( IDropTarget *wrapper, IDropTarget **target )
430 {
431 DropTargetWrapper* This = impl_from_IDropTarget( wrapper );
432 *target = GetPropW( This->hwnd, prop_oledroptarget );
433 if (!*target) return DRAGDROP_E_NOTREGISTERED;
434 IDropTarget_AddRef( *target );
435 return S_OK;
436 }
437
438 static HRESULT WINAPI DropTargetWrapper_DragEnter(IDropTarget* iface,
439 IDataObject* pDataObj,
440 DWORD grfKeyState,
441 POINTL pt,
442 DWORD* pdwEffect)
443 {
444 IDropTarget *target;
445 HRESULT r = get_target_from_wrapper( iface, &target );
446
447 if (SUCCEEDED( r ))
448 {
449 r = IDropTarget_DragEnter( target, pDataObj, grfKeyState, pt, pdwEffect );
450 IDropTarget_Release( target );
451 }
452 return r;
453 }
454
455 static HRESULT WINAPI DropTargetWrapper_DragOver(IDropTarget* iface,
456 DWORD grfKeyState,
457 POINTL pt,
458 DWORD* pdwEffect)
459 {
460 IDropTarget *target;
461 HRESULT r = get_target_from_wrapper( iface, &target );
462
463 if (SUCCEEDED( r ))
464 {
465 r = IDropTarget_DragOver( target, grfKeyState, pt, pdwEffect );
466 IDropTarget_Release( target );
467 }
468 return r;
469 }
470
471 static HRESULT WINAPI DropTargetWrapper_DragLeave(IDropTarget* iface)
472 {
473 IDropTarget *target;
474 HRESULT r = get_target_from_wrapper( iface, &target );
475
476 if (SUCCEEDED( r ))
477 {
478 r = IDropTarget_DragLeave( target );
479 IDropTarget_Release( target );
480 }
481 return r;
482 }
483
484 static HRESULT WINAPI DropTargetWrapper_Drop(IDropTarget* iface,
485 IDataObject* pDataObj,
486 DWORD grfKeyState,
487 POINTL pt,
488 DWORD* pdwEffect)
489 {
490 IDropTarget *target;
491 HRESULT r = get_target_from_wrapper( iface, &target );
492
493 if (SUCCEEDED( r ))
494 {
495 r = IDropTarget_Drop( target, pDataObj, grfKeyState, pt, pdwEffect );
496 IDropTarget_Release( target );
497 }
498 return r;
499 }
500
501 static const IDropTargetVtbl DropTargetWrapperVTbl =
502 {
503 DropTargetWrapper_QueryInterface,
504 DropTargetWrapper_AddRef,
505 DropTargetWrapper_Release,
506 DropTargetWrapper_DragEnter,
507 DropTargetWrapper_DragOver,
508 DropTargetWrapper_DragLeave,
509 DropTargetWrapper_Drop
510 };
511
512 static IDropTarget* WrapDropTarget( HWND hwnd )
513 {
514 DropTargetWrapper* This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
515
516 if (This)
517 {
518 This->IDropTarget_iface.lpVtbl = &DropTargetWrapperVTbl;
519 This->hwnd = hwnd;
520 This->refs = 1;
521 }
522 return &This->IDropTarget_iface;
523 }
524
525 /***********************************************************************
526 * get_droptarget_pointer
527 *
528 * Retrieves the marshalled IDropTarget from the window.
529 */
530 static IDropTarget* get_droptarget_pointer(HWND hwnd)
531 {
532 IDropTarget *droptarget = NULL;
533 HANDLE map;
534 IStream *stream;
535
536 map = get_droptarget_local_handle(hwnd);
537 if(!map) return NULL;
538
539 if(SUCCEEDED(create_stream_from_map(map, &stream)))
540 {
541 CoUnmarshalInterface(stream, &IID_IDropTarget, (void**)&droptarget);
542 IStream_Release(stream);
543 }
544 CloseHandle(map);
545 return droptarget;
546 }
547
548 /***********************************************************************
549 * RegisterDragDrop (OLE32.@)
550 */
551 HRESULT WINAPI RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
552 {
553 DWORD pid = 0;
554 HRESULT hr;
555 IStream *stream;
556 HANDLE map;
557 IDropTarget *wrapper;
558
559 TRACE("(%p,%p)\n", hwnd, pDropTarget);
560
561 if (!COM_CurrentApt())
562 {
563 ERR("COM not initialized\n");
564 return E_OUTOFMEMORY;
565 }
566
567 if (!pDropTarget)
568 return E_INVALIDARG;
569
570 if (!IsWindow(hwnd))
571 {
572 ERR("invalid hwnd %p\n", hwnd);
573 return DRAGDROP_E_INVALIDHWND;
574 }
575
576 /* block register for other processes windows */
577 GetWindowThreadProcessId(hwnd, &pid);
578 if (pid != GetCurrentProcessId())
579 {
580 FIXME("register for another process windows is disabled\n");
581 return DRAGDROP_E_INVALIDHWND;
582 }
583
584 /* check if the window is already registered */
585 if (is_droptarget(hwnd))
586 return DRAGDROP_E_ALREADYREGISTERED;
587
588 /*
589 * Marshal the drop target pointer into a shared memory map and
590 * store the map's handle in a Wine specific window prop. We also
591 * store the drop target pointer itself in the
592 * "OleDropTargetInterface" prop for compatibility with Windows.
593 */
594
595 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
596 if(FAILED(hr)) return hr;
597
598 /* IDropTarget::QueryInterface() shouldn't be called, some (broken) apps depend on this. */
599 wrapper = WrapDropTarget( hwnd );
600 if(!wrapper)
601 {
602 IStream_Release(stream);
603 return E_OUTOFMEMORY;
604 }
605 hr = CoMarshalInterface(stream, &IID_IDropTarget, (IUnknown*)wrapper, MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
606 IDropTarget_Release(wrapper);
607
608 if(SUCCEEDED(hr))
609 {
610 hr = create_map_from_stream(stream, &map);
611 if(SUCCEEDED(hr))
612 {
613 IDropTarget_AddRef(pDropTarget);
614 SetPropW(hwnd, prop_oledroptarget, pDropTarget);
615 SetPropW(hwnd, prop_marshalleddroptarget, map);
616 }
617 else
618 {
619 LARGE_INTEGER zero;
620 zero.QuadPart = 0;
621 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
622 CoReleaseMarshalData(stream);
623 }
624 }
625 IStream_Release(stream);
626
627 return hr;
628 }
629
630 /***********************************************************************
631 * RevokeDragDrop (OLE32.@)
632 */
633 HRESULT WINAPI RevokeDragDrop(HWND hwnd)
634 {
635 HANDLE map;
636 IStream *stream;
637 IDropTarget *drop_target;
638 HRESULT hr;
639
640 TRACE("(%p)\n", hwnd);
641
642 if (!IsWindow(hwnd))
643 {
644 ERR("invalid hwnd %p\n", hwnd);
645 return DRAGDROP_E_INVALIDHWND;
646 }
647
648 /* no registration data */
649 if (!(map = get_droptarget_handle(hwnd)))
650 return DRAGDROP_E_NOTREGISTERED;
651
652 drop_target = GetPropW(hwnd, prop_oledroptarget);
653 if(drop_target) IDropTarget_Release(drop_target);
654
655 RemovePropW(hwnd, prop_oledroptarget);
656 RemovePropW(hwnd, prop_marshalleddroptarget);
657
658 hr = create_stream_from_map(map, &stream);
659 if(SUCCEEDED(hr))
660 {
661 CoReleaseMarshalData(stream);
662 IStream_Release(stream);
663 }
664 CloseHandle(map);
665
666 return hr;
667 }
668
669 /***********************************************************************
670 * OleRegGetUserType (OLE32.@)
671 *
672 * This implementation of OleRegGetUserType ignores the dwFormOfType
673 * parameter and always returns the full name of the object. This is
674 * not too bad since this is the case for many objects because of the
675 * way they are registered.
676 */
677 HRESULT WINAPI OleRegGetUserType(
678 REFCLSID clsid,
679 DWORD dwFormOfType,
680 LPOLESTR* pszUserType)
681 {
682 WCHAR keyName[60];
683 DWORD dwKeyType;
684 DWORD cbData;
685 HKEY clsidKey;
686 LONG hres;
687
688 /*
689 * Initialize the out parameter.
690 */
691 *pszUserType = NULL;
692
693 /*
694 * Build the key name we're looking for
695 */
696 sprintfW( keyName, clsidfmtW,
697 clsid->Data1, clsid->Data2, clsid->Data3,
698 clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
699 clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
700
701 TRACE("(%s, %d, %p)\n", debugstr_w(keyName), dwFormOfType, pszUserType);
702
703 /*
704 * Open the class id Key
705 */
706 hres = open_classes_key(HKEY_CLASSES_ROOT, keyName, MAXIMUM_ALLOWED, &clsidKey);
707 if (hres != ERROR_SUCCESS)
708 return REGDB_E_CLASSNOTREG;
709
710 /*
711 * Retrieve the size of the name string.
712 */
713 cbData = 0;
714
715 hres = RegQueryValueExW(clsidKey,
716 emptyW,
717 NULL,
718 &dwKeyType,
719 NULL,
720 &cbData);
721
722 if (hres!=ERROR_SUCCESS)
723 {
724 RegCloseKey(clsidKey);
725 return REGDB_E_READREGDB;
726 }
727
728 /*
729 * Allocate a buffer for the registry value.
730 */
731 *pszUserType = CoTaskMemAlloc(cbData);
732
733 if (*pszUserType==NULL)
734 {
735 RegCloseKey(clsidKey);
736 return E_OUTOFMEMORY;
737 }
738
739 hres = RegQueryValueExW(clsidKey,
740 emptyW,
741 NULL,
742 &dwKeyType,
743 (LPBYTE) *pszUserType,
744 &cbData);
745
746 RegCloseKey(clsidKey);
747
748 if (hres != ERROR_SUCCESS)
749 {
750 CoTaskMemFree(*pszUserType);
751 *pszUserType = NULL;
752
753 return REGDB_E_READREGDB;
754 }
755
756 return S_OK;
757 }
758
759 /***********************************************************************
760 * DoDragDrop [OLE32.@]
761 */
762 HRESULT WINAPI DoDragDrop (
763 IDataObject *pDataObject, /* [in] ptr to the data obj */
764 IDropSource* pDropSource, /* [in] ptr to the source obj */
765 DWORD dwOKEffect, /* [in] effects allowed by the source */
766 DWORD *pdwEffect) /* [out] ptr to effects of the source */
767 {
768 static const WCHAR trackerW[] = {'T','r','a','c','k','e','r','W','i','n','d','o','w',0};
769 TrackerWindowInfo trackerInfo;
770 HWND hwndTrackWindow;
771 MSG msg;
772
773 TRACE("(%p, %p, %08x, %p)\n", pDataObject, pDropSource, dwOKEffect, pdwEffect);
774
775 if (!pDataObject || !pDropSource || !pdwEffect)
776 return E_INVALIDARG;
777
778 /*
779 * Setup the drag n drop tracking window.
780 */
781
782 trackerInfo.dataObject = pDataObject;
783 trackerInfo.dropSource = pDropSource;
784 trackerInfo.dwOKEffect = dwOKEffect;
785 trackerInfo.pdwEffect = pdwEffect;
786 trackerInfo.trackingDone = FALSE;
787 trackerInfo.escPressed = FALSE;
788 trackerInfo.curDragTargetHWND = 0;
789 trackerInfo.curTargetHWND = 0;
790 trackerInfo.curDragTarget = 0;
791
792 hwndTrackWindow = CreateWindowW(OLEDD_DRAGTRACKERCLASS, trackerW,
793 WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT,
794 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0,
795 &trackerInfo);
796
797 if (hwndTrackWindow)
798 {
799 /*
800 * Capture the mouse input
801 */
802 SetCapture(hwndTrackWindow);
803
804 msg.message = 0;
805
806 /*
807 * Pump messages. All mouse input should go to the capture window.
808 */
809 while (!trackerInfo.trackingDone && GetMessageW(&msg, 0, 0, 0) )
810 {
811 trackerInfo.curMousePos.x = msg.pt.x;
812 trackerInfo.curMousePos.y = msg.pt.y;
813 trackerInfo.dwKeyState = OLEDD_GetButtonState();
814
815 if ( (msg.message >= WM_KEYFIRST) &&
816 (msg.message <= WM_KEYLAST) )
817 {
818 /*
819 * When keyboard messages are sent to windows on this thread, we
820 * want to ignore notify the drop source that the state changed.
821 * in the case of the Escape key, we also notify the drop source
822 * we give it a special meaning.
823 */
824 if ( (msg.message==WM_KEYDOWN) &&
825 (msg.wParam==VK_ESCAPE) )
826 {
827 trackerInfo.escPressed = TRUE;
828 }
829
830 /*
831 * Notify the drop source.
832 */
833 OLEDD_TrackStateChange(&trackerInfo);
834 }
835 else
836 {
837 /*
838 * Dispatch the messages only when it's not a keyboard message.
839 */
840 DispatchMessageW(&msg);
841 }
842 }
843
844 /* re-post the quit message to outer message loop */
845 if (msg.message == WM_QUIT)
846 PostQuitMessage(msg.wParam);
847 /*
848 * Destroy the temporary window.
849 */
850 DestroyWindow(hwndTrackWindow);
851
852 return trackerInfo.returnValue;
853 }
854
855 return E_FAIL;
856 }
857
858 /***********************************************************************
859 * OleQueryLinkFromData [OLE32.@]
860 */
861 HRESULT WINAPI OleQueryLinkFromData(
862 IDataObject* pSrcDataObject)
863 {
864 FIXME("(%p),stub!\n", pSrcDataObject);
865 return S_FALSE;
866 }
867
868 /***********************************************************************
869 * OleRegGetMiscStatus [OLE32.@]
870 */
871 HRESULT WINAPI OleRegGetMiscStatus(
872 REFCLSID clsid,
873 DWORD dwAspect,
874 DWORD* pdwStatus)
875 {
876 static const WCHAR miscstatusW[] = {'M','i','s','c','S','t','a','t','u','s',0};
877 static const WCHAR dfmtW[] = {'%','d',0};
878 WCHAR keyName[60];
879 HKEY clsidKey;
880 HKEY miscStatusKey;
881 HKEY aspectKey;
882 LONG result;
883
884 /*
885 * Build the key name we're looking for
886 */
887 sprintfW( keyName, clsidfmtW,
888 clsid->Data1, clsid->Data2, clsid->Data3,
889 clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
890 clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
891
892 TRACE("(%s, %d, %p)\n", debugstr_w(keyName), dwAspect, pdwStatus);
893
894 if (!pdwStatus) return E_INVALIDARG;
895
896 *pdwStatus = 0;
897
898 if (actctx_get_miscstatus(clsid, dwAspect, pdwStatus)) return S_OK;
899
900 /*
901 * Open the class id Key
902 */
903 result = open_classes_key(HKEY_CLASSES_ROOT, keyName, MAXIMUM_ALLOWED, &clsidKey);
904 if (result != ERROR_SUCCESS)
905 return REGDB_E_CLASSNOTREG;
906
907 /*
908 * Get the MiscStatus
909 */
910 result = open_classes_key(clsidKey, miscstatusW, MAXIMUM_ALLOWED, &miscStatusKey);
911 if (result != ERROR_SUCCESS)
912 {
913 RegCloseKey(clsidKey);
914 return S_OK;
915 }
916
917 /*
918 * Read the default value
919 */
920 OLEUTL_ReadRegistryDWORDValue(miscStatusKey, pdwStatus);
921
922 /*
923 * Open the key specific to the requested aspect.
924 */
925 sprintfW(keyName, dfmtW, dwAspect);
926
927 result = open_classes_key(miscStatusKey, keyName, MAXIMUM_ALLOWED, &aspectKey);
928 if (result == ERROR_SUCCESS)
929 {
930 OLEUTL_ReadRegistryDWORDValue(aspectKey, pdwStatus);
931 RegCloseKey(aspectKey);
932 }
933
934 /*
935 * Cleanup
936 */
937 RegCloseKey(miscStatusKey);
938 RegCloseKey(clsidKey);
939
940 return S_OK;
941 }
942
943 static HRESULT EnumOLEVERB_Construct(HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum);
944
945 typedef struct
946 {
947 IEnumOLEVERB IEnumOLEVERB_iface;
948 LONG ref;
949
950 HKEY hkeyVerb;
951 ULONG index;
952 } EnumOLEVERB;
953
954 static inline EnumOLEVERB *impl_from_IEnumOLEVERB(IEnumOLEVERB *iface)
955 {
956 return CONTAINING_RECORD(iface, EnumOLEVERB, IEnumOLEVERB_iface);
957 }
958
959 static HRESULT WINAPI EnumOLEVERB_QueryInterface(
960 IEnumOLEVERB *iface, REFIID riid, void **ppv)
961 {
962 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
963 if (IsEqualIID(riid, &IID_IUnknown) ||
964 IsEqualIID(riid, &IID_IEnumOLEVERB))
965 {
966 IEnumOLEVERB_AddRef(iface);
967 *ppv = iface;
968 return S_OK;
969 }
970 return E_NOINTERFACE;
971 }
972
973 static ULONG WINAPI EnumOLEVERB_AddRef(
974 IEnumOLEVERB *iface)
975 {
976 EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
977 TRACE("()\n");
978 return InterlockedIncrement(&This->ref);
979 }
980
981 static ULONG WINAPI EnumOLEVERB_Release(
982 IEnumOLEVERB *iface)
983 {
984 EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
985 LONG refs = InterlockedDecrement(&This->ref);
986 TRACE("()\n");
987 if (!refs)
988 {
989 RegCloseKey(This->hkeyVerb);
990 HeapFree(GetProcessHeap(), 0, This);
991 }
992 return refs;
993 }
994
995 static HRESULT WINAPI EnumOLEVERB_Next(
996 IEnumOLEVERB *iface, ULONG celt, LPOLEVERB rgelt,
997 ULONG *pceltFetched)
998 {
999 EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
1000 HRESULT hr = S_OK;
1001
1002 TRACE("(%d, %p, %p)\n", celt, rgelt, pceltFetched);
1003
1004 if (pceltFetched)
1005 *pceltFetched = 0;
1006
1007 for (; celt; celt--, rgelt++)
1008 {
1009 WCHAR wszSubKey[20];
1010 LONG cbData;
1011 LPWSTR pwszOLEVERB;
1012 LPWSTR pwszMenuFlags;
1013 LPWSTR pwszAttribs;
1014 LONG res = RegEnumKeyW(This->hkeyVerb, This->index, wszSubKey, sizeof(wszSubKey)/sizeof(wszSubKey[0]));
1015 if (res == ERROR_NO_MORE_ITEMS)
1016 {
1017 hr = S_FALSE;
1018 break;
1019 }
1020 else if (res != ERROR_SUCCESS)
1021 {
1022 ERR("RegEnumKeyW failed with error %d\n", res);
1023 hr = REGDB_E_READREGDB;
1024 break;
1025 }
1026 res = RegQueryValueW(This->hkeyVerb, wszSubKey, NULL, &cbData);
1027 if (res != ERROR_SUCCESS)
1028 {
1029 ERR("RegQueryValueW failed with error %d\n", res);
1030 hr = REGDB_E_READREGDB;
1031 break;
1032 }
1033 pwszOLEVERB = CoTaskMemAlloc(cbData);
1034 if (!pwszOLEVERB)
1035 {
1036 hr = E_OUTOFMEMORY;
1037 break;
1038 }
1039 res = RegQueryValueW(This->hkeyVerb, wszSubKey, pwszOLEVERB, &cbData);
1040 if (res != ERROR_SUCCESS)
1041 {
1042 ERR("RegQueryValueW failed with error %d\n", res);
1043 hr = REGDB_E_READREGDB;
1044 CoTaskMemFree(pwszOLEVERB);
1045 break;
1046 }
1047
1048 TRACE("verb string: %s\n", debugstr_w(pwszOLEVERB));
1049 pwszMenuFlags = strchrW(pwszOLEVERB, ',');
1050 if (!pwszMenuFlags)
1051 {
1052 hr = OLEOBJ_E_INVALIDVERB;
1053 CoTaskMemFree(pwszOLEVERB);
1054 break;
1055 }
1056 /* nul terminate the name string and advance to first character */
1057 *pwszMenuFlags = '\0';
1058 pwszMenuFlags++;
1059 pwszAttribs = strchrW(pwszMenuFlags, ',');
1060 if (!pwszAttribs)
1061 {
1062 hr = OLEOBJ_E_INVALIDVERB;
1063 CoTaskMemFree(pwszOLEVERB);
1064 break;
1065 }
1066 /* nul terminate the menu string and advance to first character */
1067 *pwszAttribs = '\0';
1068 pwszAttribs++;
1069
1070 /* fill out structure for this verb */
1071 rgelt->lVerb = atolW(wszSubKey);
1072 rgelt->lpszVerbName = pwszOLEVERB; /* user should free */
1073 rgelt->fuFlags = atolW(pwszMenuFlags);
1074 rgelt->grfAttribs = atolW(pwszAttribs);
1075
1076 if (pceltFetched)
1077 (*pceltFetched)++;
1078 This->index++;
1079 }
1080 return hr;
1081 }
1082
1083 static HRESULT WINAPI EnumOLEVERB_Skip(
1084 IEnumOLEVERB *iface, ULONG celt)
1085 {
1086 EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
1087
1088 TRACE("(%d)\n", celt);
1089
1090 This->index += celt;
1091 return S_OK;
1092 }
1093
1094 static HRESULT WINAPI EnumOLEVERB_Reset(
1095 IEnumOLEVERB *iface)
1096 {
1097 EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
1098
1099 TRACE("()\n");
1100
1101 This->index = 0;
1102 return S_OK;
1103 }
1104
1105 static HRESULT WINAPI EnumOLEVERB_Clone(
1106 IEnumOLEVERB *iface,
1107 IEnumOLEVERB **ppenum)
1108 {
1109 EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
1110 HKEY hkeyVerb;
1111 TRACE("(%p)\n", ppenum);
1112 if (!DuplicateHandle(GetCurrentProcess(), This->hkeyVerb, GetCurrentProcess(), (HANDLE *)&hkeyVerb, 0, FALSE, DUPLICATE_SAME_ACCESS))
1113 return HRESULT_FROM_WIN32(GetLastError());
1114 return EnumOLEVERB_Construct(hkeyVerb, This->index, ppenum);
1115 }
1116
1117 static const IEnumOLEVERBVtbl EnumOLEVERB_VTable =
1118 {
1119 EnumOLEVERB_QueryInterface,
1120 EnumOLEVERB_AddRef,
1121 EnumOLEVERB_Release,
1122 EnumOLEVERB_Next,
1123 EnumOLEVERB_Skip,
1124 EnumOLEVERB_Reset,
1125 EnumOLEVERB_Clone
1126 };
1127
1128 static HRESULT EnumOLEVERB_Construct(HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum)
1129 {
1130 EnumOLEVERB *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1131 if (!This)
1132 {
1133 RegCloseKey(hkeyVerb);
1134 return E_OUTOFMEMORY;
1135 }
1136 This->IEnumOLEVERB_iface.lpVtbl = &EnumOLEVERB_VTable;
1137 This->ref = 1;
1138 This->index = index;
1139 This->hkeyVerb = hkeyVerb;
1140 *ppenum = &This->IEnumOLEVERB_iface;
1141 return S_OK;
1142 }
1143
1144 /***********************************************************************
1145 * OleRegEnumVerbs [OLE32.@]
1146 *
1147 * Enumerates verbs associated with a class stored in the registry.
1148 *
1149 * PARAMS
1150 * clsid [I] Class ID to enumerate the verbs for.
1151 * ppenum [O] Enumerator.
1152 *
1153 * RETURNS
1154 * S_OK: Success.
1155 * REGDB_E_CLASSNOTREG: The specified class does not have a key in the registry.
1156 * REGDB_E_READREGDB: The class key could not be opened for some other reason.
1157 * OLE_E_REGDB_KEY: The Verb subkey for the class is not present.
1158 * OLEOBJ_E_NOVERBS: The Verb subkey for the class is empty.
1159 */
1160 HRESULT WINAPI OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB* ppenum)
1161 {
1162 LONG res;
1163 HKEY hkeyVerb;
1164 DWORD dwSubKeys;
1165 static const WCHAR wszVerb[] = {'V','e','r','b',0};
1166
1167 TRACE("(%s, %p)\n", debugstr_guid(clsid), ppenum);
1168
1169 res = COM_OpenKeyForCLSID(clsid, wszVerb, KEY_READ, &hkeyVerb);
1170 if (FAILED(res))
1171 {
1172 if (res == REGDB_E_CLASSNOTREG)
1173 ERR("CLSID %s not registered\n", debugstr_guid(clsid));
1174 else if (res == REGDB_E_KEYMISSING)
1175 ERR("no Verbs key for class %s\n", debugstr_guid(clsid));
1176 else
1177 ERR("failed to open Verbs key for CLSID %s with error %d\n",
1178 debugstr_guid(clsid), res);
1179 return res;
1180 }
1181
1182 res = RegQueryInfoKeyW(hkeyVerb, NULL, NULL, NULL, &dwSubKeys, NULL,
1183 NULL, NULL, NULL, NULL, NULL, NULL);
1184 if (res != ERROR_SUCCESS)
1185 {
1186 ERR("failed to get subkey count with error %d\n", GetLastError());
1187 return REGDB_E_READREGDB;
1188 }
1189
1190 if (!dwSubKeys)
1191 {
1192 WARN("class %s has no verbs\n", debugstr_guid(clsid));
1193 RegCloseKey(hkeyVerb);
1194 return OLEOBJ_E_NOVERBS;
1195 }
1196
1197 return EnumOLEVERB_Construct(hkeyVerb, 0, ppenum);
1198 }
1199
1200 /******************************************************************************
1201 * OleSetContainedObject [OLE32.@]
1202 */
1203 HRESULT WINAPI OleSetContainedObject(
1204 LPUNKNOWN pUnknown,
1205 BOOL fContained)
1206 {
1207 IRunnableObject* runnable = NULL;
1208 HRESULT hres;
1209
1210 TRACE("(%p,%x)\n", pUnknown, fContained);
1211
1212 hres = IUnknown_QueryInterface(pUnknown,
1213 &IID_IRunnableObject,
1214 (void**)&runnable);
1215
1216 if (SUCCEEDED(hres))
1217 {
1218 hres = IRunnableObject_SetContainedObject(runnable, fContained);
1219
1220 IRunnableObject_Release(runnable);
1221
1222 return hres;
1223 }
1224
1225 return S_OK;
1226 }
1227
1228 /******************************************************************************
1229 * OleRun [OLE32.@]
1230 *
1231 * Set the OLE object to the running state.
1232 *
1233 * PARAMS
1234 * pUnknown [I] OLE object to run.
1235 *
1236 * RETURNS
1237 * Success: S_OK.
1238 * Failure: Any HRESULT code.
1239 */
1240 HRESULT WINAPI OleRun(LPUNKNOWN pUnknown)
1241 {
1242 IRunnableObject *runable;
1243 HRESULT hres;
1244
1245 TRACE("(%p)\n", pUnknown);
1246
1247 hres = IUnknown_QueryInterface(pUnknown, &IID_IRunnableObject, (void**)&runable);
1248 if (FAILED(hres))
1249 return S_OK; /* Appears to return no error. */
1250
1251 hres = IRunnableObject_Run(runable, NULL);
1252 IRunnableObject_Release(runable);
1253 return hres;
1254 }
1255
1256 /******************************************************************************
1257 * OleLoad [OLE32.@]
1258 */
1259 HRESULT WINAPI OleLoad(
1260 LPSTORAGE pStg,
1261 REFIID riid,
1262 LPOLECLIENTSITE pClientSite,
1263 LPVOID* ppvObj)
1264 {
1265 IPersistStorage* persistStorage = NULL;
1266 IUnknown* pUnk;
1267 IOleObject* pOleObject = NULL;
1268 STATSTG storageInfo;
1269 HRESULT hres;
1270
1271 TRACE("(%p, %s, %p, %p)\n", pStg, debugstr_guid(riid), pClientSite, ppvObj);
1272
1273 *ppvObj = NULL;
1274
1275 /*
1276 * TODO, Conversion ... OleDoAutoConvert
1277 */
1278
1279 /*
1280 * Get the class ID for the object.
1281 */
1282 hres = IStorage_Stat(pStg, &storageInfo, STATFLAG_NONAME);
1283
1284 /*
1285 * Now, try and create the handler for the object
1286 */
1287 hres = CoCreateInstance(&storageInfo.clsid,
1288 NULL,
1289 CLSCTX_INPROC_HANDLER|CLSCTX_INPROC_SERVER,
1290 riid,
1291 (void**)&pUnk);
1292
1293 /*
1294 * If that fails, as it will most times, load the default
1295 * OLE handler.
1296 */
1297 if (FAILED(hres))
1298 {
1299 hres = OleCreateDefaultHandler(&storageInfo.clsid,
1300 NULL,
1301 riid,
1302 (void**)&pUnk);
1303 }
1304
1305 /*
1306 * If we couldn't find a handler... this is bad. Abort the whole thing.
1307 */
1308 if (FAILED(hres))
1309 return hres;
1310
1311 if (pClientSite)
1312 {
1313 hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (void **)&pOleObject);
1314 if (SUCCEEDED(hres))
1315 {
1316 DWORD dwStatus;
1317 hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
1318 }
1319 }
1320
1321 /*
1322 * Initialize the object with its IPersistStorage interface.
1323 */
1324 hres = IUnknown_QueryInterface(pUnk, &IID_IPersistStorage, (void**)&persistStorage);
1325 if (SUCCEEDED(hres))
1326 {
1327 hres = IPersistStorage_Load(persistStorage, pStg);
1328
1329 IPersistStorage_Release(persistStorage);
1330 persistStorage = NULL;
1331 }
1332
1333 if (SUCCEEDED(hres) && pClientSite)
1334 /*
1335 * Inform the new object of its client site.
1336 */
1337 hres = IOleObject_SetClientSite(pOleObject, pClientSite);
1338
1339 /*
1340 * Cleanup interfaces used internally
1341 */
1342 if (pOleObject)
1343 IOleObject_Release(pOleObject);
1344
1345 if (SUCCEEDED(hres))
1346 {
1347 IOleLink *pOleLink;
1348 HRESULT hres1;
1349 hres1 = IUnknown_QueryInterface(pUnk, &IID_IOleLink, (void **)&pOleLink);
1350 if (SUCCEEDED(hres1))
1351 {
1352 FIXME("handle OLE link\n");
1353 IOleLink_Release(pOleLink);
1354 }
1355 }
1356
1357 if (FAILED(hres))
1358 {
1359 IUnknown_Release(pUnk);
1360 pUnk = NULL;
1361 }
1362
1363 *ppvObj = pUnk;
1364
1365 return hres;
1366 }
1367
1368 /***********************************************************************
1369 * OleSave [OLE32.@]
1370 */
1371 HRESULT WINAPI OleSave(
1372 LPPERSISTSTORAGE pPS,
1373 LPSTORAGE pStg,
1374 BOOL fSameAsLoad)
1375 {
1376 HRESULT hres;
1377 CLSID objectClass;
1378
1379 TRACE("(%p,%p,%x)\n", pPS, pStg, fSameAsLoad);
1380
1381 /*
1382 * First, we transfer the class ID (if available)
1383 */
1384 hres = IPersistStorage_GetClassID(pPS, &objectClass);
1385
1386 if (SUCCEEDED(hres))
1387 {
1388 WriteClassStg(pStg, &objectClass);
1389 }
1390
1391 /*
1392 * Then, we ask the object to save itself to the
1393 * storage. If it is successful, we commit the storage.
1394 */
1395 hres = IPersistStorage_Save(pPS, pStg, fSameAsLoad);
1396
1397 if (SUCCEEDED(hres))
1398 {
1399 IStorage_Commit(pStg,
1400 STGC_DEFAULT);
1401 }
1402
1403 return hres;
1404 }
1405
1406
1407 /******************************************************************************
1408 * OleLockRunning [OLE32.@]
1409 */
1410 HRESULT WINAPI OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
1411 {
1412 IRunnableObject* runnable = NULL;
1413 HRESULT hres;
1414
1415 TRACE("(%p,%x,%x)\n", pUnknown, fLock, fLastUnlockCloses);
1416
1417 hres = IUnknown_QueryInterface(pUnknown,
1418 &IID_IRunnableObject,
1419 (void**)&runnable);
1420
1421 if (SUCCEEDED(hres))
1422 {
1423 hres = IRunnableObject_LockRunning(runnable, fLock, fLastUnlockCloses);
1424
1425 IRunnableObject_Release(runnable);
1426
1427 return hres;
1428 }
1429
1430 return S_OK;
1431 }
1432
1433
1434 /**************************************************************************
1435 * Internal methods to manage the shared OLE menu in response to the
1436 * OLE***MenuDescriptor API
1437 */
1438
1439 /***
1440 * OLEMenu_Initialize()
1441 *
1442 * Initializes the OLEMENU data structures.
1443 */
1444 static void OLEMenu_Initialize(void)
1445 {
1446 }
1447
1448 /***
1449 * OLEMenu_UnInitialize()
1450 *
1451 * Releases the OLEMENU data structures.
1452 */
1453 static void OLEMenu_UnInitialize(void)
1454 {
1455 }
1456
1457 /*************************************************************************
1458 * OLEMenu_InstallHooks
1459 * Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1460 *
1461 * RETURNS: TRUE if message hooks were successfully installed
1462 * FALSE on failure
1463 */
1464 static BOOL OLEMenu_InstallHooks( DWORD tid )
1465 {
1466 OleMenuHookItem *pHookItem;
1467
1468 /* Create an entry for the hook table */
1469 if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
1470 sizeof(OleMenuHookItem)) ) )
1471 return FALSE;
1472
1473 pHookItem->tid = tid;
1474 pHookItem->hHeap = GetProcessHeap();
1475 pHookItem->CallWndProc_hHook = NULL;
1476
1477 /* Install a thread scope message hook for WH_GETMESSAGE */
1478 pHookItem->GetMsg_hHook = SetWindowsHookExW( WH_GETMESSAGE, OLEMenu_GetMsgProc,
1479 0, GetCurrentThreadId() );
1480 if ( !pHookItem->GetMsg_hHook )
1481 goto CLEANUP;
1482
1483 /* Install a thread scope message hook for WH_CALLWNDPROC */
1484 pHookItem->CallWndProc_hHook = SetWindowsHookExW( WH_CALLWNDPROC, OLEMenu_CallWndProc,
1485 0, GetCurrentThreadId() );
1486 if ( !pHookItem->CallWndProc_hHook )
1487 goto CLEANUP;
1488
1489 /* Insert the hook table entry */
1490 pHookItem->next = hook_list;
1491 hook_list = pHookItem;
1492
1493 return TRUE;
1494
1495 CLEANUP:
1496 /* Unhook any hooks */
1497 if ( pHookItem->GetMsg_hHook )
1498 UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
1499 if ( pHookItem->CallWndProc_hHook )
1500 UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
1501 /* Release the hook table entry */
1502 HeapFree(pHookItem->hHeap, 0, pHookItem );
1503
1504 return FALSE;
1505 }
1506
1507 /*************************************************************************
1508 * OLEMenu_UnInstallHooks
1509 * UnInstall thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1510 *
1511 * RETURNS: TRUE if message hooks were successfully installed
1512 * FALSE on failure
1513 */
1514 static BOOL OLEMenu_UnInstallHooks( DWORD tid )
1515 {
1516 OleMenuHookItem *pHookItem = NULL;
1517 OleMenuHookItem **ppHook = &hook_list;
1518
1519 while (*ppHook)
1520 {
1521 if ((*ppHook)->tid == tid)
1522 {
1523 pHookItem = *ppHook;
1524 *ppHook = pHookItem->next;
1525 break;
1526 }
1527 ppHook = &(*ppHook)->next;
1528 }
1529 if (!pHookItem) return FALSE;
1530
1531 /* Uninstall the hooks installed for this thread */
1532 if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
1533 goto CLEANUP;
1534 if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
1535 goto CLEANUP;
1536
1537 /* Release the hook table entry */
1538 HeapFree(pHookItem->hHeap, 0, pHookItem );
1539
1540 return TRUE;
1541
1542 CLEANUP:
1543 /* Release the hook table entry */
1544 HeapFree(pHookItem->hHeap, 0, pHookItem );
1545
1546 return FALSE;
1547 }
1548
1549 /*************************************************************************
1550 * OLEMenu_IsHookInstalled
1551 * Tests if OLEMenu hooks have been installed for a thread
1552 *
1553 * RETURNS: The pointer and index of the hook table entry for the tid
1554 * NULL and -1 for the index if no hooks were installed for this thread
1555 */
1556 static OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid )
1557 {
1558 OleMenuHookItem *pHookItem;
1559
1560 /* Do a simple linear search for an entry whose tid matches ours.
1561 * We really need a map but efficiency is not a concern here. */
1562 for (pHookItem = hook_list; pHookItem; pHookItem = pHookItem->next)
1563 {
1564 if ( tid == pHookItem->tid )
1565 return pHookItem;
1566 }
1567
1568 return NULL;
1569 }
1570
1571 /***********************************************************************
1572 * OLEMenu_FindMainMenuIndex
1573 *
1574 * Used by OLEMenu API to find the top level group a menu item belongs to.
1575 * On success pnPos contains the index of the item in the top level menu group
1576 *
1577 * RETURNS: TRUE if the ID was found, FALSE on failure
1578 */
1579 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos )
1580 {
1581 INT i, nItems;
1582
1583 nItems = GetMenuItemCount( hMainMenu );
1584
1585 for (i = 0; i < nItems; i++)
1586 {
1587 HMENU hsubmenu;
1588
1589 /* Is the current item a submenu? */
1590 if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
1591 {
1592 /* If the handle is the same we're done */
1593 if ( hsubmenu == hPopupMenu )
1594 {
1595 if (pnPos)
1596 *pnPos = i;
1597 return TRUE;
1598 }
1599 /* Recursively search without updating pnPos */
1600 else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
1601 {
1602 if (pnPos)
1603 *pnPos = i;
1604 return TRUE;
1605 }
1606 }
1607 }
1608
1609 return FALSE;
1610 }
1611
1612 /***********************************************************************
1613 * OLEMenu_SetIsServerMenu
1614 *
1615 * Checks whether a popup menu belongs to a shared menu group which is
1616 * owned by the server, and sets the menu descriptor state accordingly.
1617 * All menu messages from these groups should be routed to the server.
1618 *
1619 * RETURNS: TRUE if the popup menu is part of a server owned group
1620 * FALSE if the popup menu is part of a container owned group
1621 */
1622 static BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor )
1623 {
1624 UINT nPos = 0, nWidth, i;
1625
1626 pOleMenuDescriptor->bIsServerItem = FALSE;
1627
1628 /* Don't bother searching if the popup is the combined menu itself */
1629 if ( hmenu == pOleMenuDescriptor->hmenuCombined )
1630 return FALSE;
1631
1632 /* Find the menu item index in the shared OLE menu that this item belongs to */
1633 if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu, &nPos ) )
1634 return FALSE;
1635
1636 /* The group widths array has counts for the number of elements
1637 * in the groups File, Edit, Container, Object, Window, Help.
1638 * The Edit, Object & Help groups belong to the server object
1639 * and the other three belong to the container.
1640 * Loop through the group widths and locate the group we are a member of.
1641 */
1642 for ( i = 0, nWidth = 0; i < 6; i++ )
1643 {
1644 nWidth += pOleMenuDescriptor->mgw.width[i];
1645 if ( nPos < nWidth )
1646 {
1647 /* Odd elements are server menu widths */
1648 pOleMenuDescriptor->bIsServerItem = i%2;
1649 break;
1650 }
1651 }
1652
1653 return pOleMenuDescriptor->bIsServerItem;
1654 }
1655
1656 /*************************************************************************
1657 * OLEMenu_CallWndProc
1658 * Thread scope WH_CALLWNDPROC hook proc filter function (callback)
1659 * This is invoked from a message hook installed in OleSetMenuDescriptor.
1660 */
1661 static LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam)
1662 {
1663 LPCWPSTRUCT pMsg;
1664 HOLEMENU hOleMenu = 0;
1665 OleMenuDescriptor *pOleMenuDescriptor = NULL;
1666 OleMenuHookItem *pHookItem = NULL;
1667 WORD fuFlags;
1668
1669 TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
1670
1671 /* Check if we're being asked to process the message */
1672 if ( HC_ACTION != code )
1673 goto NEXTHOOK;
1674
1675 /* Retrieve the current message being dispatched from lParam */
1676 pMsg = (LPCWPSTRUCT)lParam;
1677
1678 /* Check if the message is destined for a window we are interested in:
1679 * If the window has an OLEMenu property we may need to dispatch
1680 * the menu message to its active objects window instead. */
1681
1682 hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
1683 if ( !hOleMenu )
1684 goto NEXTHOOK;
1685
1686 /* Get the menu descriptor */
1687 pOleMenuDescriptor = GlobalLock( hOleMenu );
1688 if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1689 goto NEXTHOOK;
1690
1691 /* Process menu messages */
1692 switch( pMsg->message )
1693 {
1694 case WM_INITMENU:
1695 {
1696 /* Reset the menu descriptor state */
1697 pOleMenuDescriptor->bIsServerItem = FALSE;
1698
1699 /* Send this message to the server as well */
1700 SendMessageW( pOleMenuDescriptor->hwndActiveObject,
1701 pMsg->message, pMsg->wParam, pMsg->lParam );
1702 goto NEXTHOOK;
1703 }
1704
1705 case WM_INITMENUPOPUP:
1706 {
1707 /* Save the state for whether this is a server owned menu */
1708 OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
1709 break;
1710 }
1711
1712 case WM_MENUSELECT:
1713 {
1714 fuFlags = HIWORD(pMsg->wParam); /* Get flags */
1715 if ( fuFlags & MF_SYSMENU )
1716 goto NEXTHOOK;
1717
1718 /* Save the state for whether this is a server owned popup menu */
1719 else if ( fuFlags & MF_POPUP )
1720 OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
1721
1722 break;
1723 }
1724
1725 case WM_DRAWITEM:
1726 {
1727 LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
1728 if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
1729 goto NEXTHOOK; /* Not a menu message */
1730
1731 break;
1732 }
1733
1734 default:
1735 goto NEXTHOOK;
1736 }
1737
1738 /* If the message was for the server dispatch it accordingly */
1739 if ( pOleMenuDescriptor->bIsServerItem )
1740 {
1741 SendMessageW( pOleMenuDescriptor->hwndActiveObject,
1742 pMsg->message, pMsg->wParam, pMsg->lParam );
1743 }
1744
1745 NEXTHOOK:
1746 if ( pOleMenuDescriptor )
1747 GlobalUnlock( hOleMenu );
1748
1749 /* Lookup the hook item for the current thread */
1750 if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1751 {
1752 /* This should never fail!! */
1753 WARN("could not retrieve hHook for current thread!\n" );
1754 return 0;
1755 }
1756
1757 /* Pass on the message to the next hooker */
1758 return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
1759 }
1760
1761 /*************************************************************************
1762 * OLEMenu_GetMsgProc
1763 * Thread scope WH_GETMESSAGE hook proc filter function (callback)
1764 * This is invoked from a message hook installed in OleSetMenuDescriptor.
1765 */
1766 static LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam)
1767 {
1768 LPMSG pMsg;
1769 HOLEMENU hOleMenu = 0;
1770 OleMenuDescriptor *pOleMenuDescriptor = NULL;
1771 OleMenuHookItem *pHookItem = NULL;
1772 WORD wCode;
1773
1774 TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
1775
1776 /* Check if we're being asked to process a messages */
1777 if ( HC_ACTION != code )
1778 goto NEXTHOOK;
1779
1780 /* Retrieve the current message being dispatched from lParam */
1781 pMsg = (LPMSG)lParam;
1782
1783 /* Check if the message is destined for a window we are interested in:
1784 * If the window has an OLEMenu property we may need to dispatch
1785 * the menu message to its active objects window instead. */
1786
1787 hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
1788 if ( !hOleMenu )
1789 goto NEXTHOOK;
1790
1791 /* Process menu messages */
1792 switch( pMsg->message )
1793 {
1794 case WM_COMMAND:
1795 {
1796 wCode = HIWORD(pMsg->wParam); /* Get notification code */
1797 if ( wCode )
1798 goto NEXTHOOK; /* Not a menu message */
1799 break;
1800 }
1801 default:
1802 goto NEXTHOOK;
1803 }
1804
1805 /* Get the menu descriptor */
1806 pOleMenuDescriptor = GlobalLock( hOleMenu );
1807 if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1808 goto NEXTHOOK;
1809
1810 /* If the message was for the server dispatch it accordingly */
1811 if ( pOleMenuDescriptor->bIsServerItem )
1812 {
1813 /* Change the hWnd in the message to the active objects hWnd.
1814 * The message loop which reads this message will automatically
1815 * dispatch it to the embedded objects window. */
1816 pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
1817 }
1818
1819 NEXTHOOK:
1820 if ( pOleMenuDescriptor )
1821 GlobalUnlock( hOleMenu );
1822
1823 /* Lookup the hook item for the current thread */
1824 if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1825 {
1826 /* This should never fail!! */
1827 WARN("could not retrieve hHook for current thread!\n" );
1828 return FALSE;
1829 }
1830
1831 /* Pass on the message to the next hooker */
1832 return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
1833 }
1834
1835 /***********************************************************************
1836 * OleCreateMenuDescriptor [OLE32.@]
1837 * Creates an OLE menu descriptor for OLE to use when dispatching
1838 * menu messages and commands.
1839 *
1840 * PARAMS:
1841 * hmenuCombined - Handle to the objects combined menu
1842 * lpMenuWidths - Pointer to array of 6 LONG's indicating menus per group
1843 *
1844 */
1845 HOLEMENU WINAPI OleCreateMenuDescriptor(
1846 HMENU hmenuCombined,
1847 LPOLEMENUGROUPWIDTHS lpMenuWidths)
1848 {
1849 HOLEMENU hOleMenu;
1850 OleMenuDescriptor *pOleMenuDescriptor;
1851 int i;
1852
1853 if ( !hmenuCombined || !lpMenuWidths )
1854 return 0;
1855
1856 /* Create an OLE menu descriptor */
1857 if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
1858 sizeof(OleMenuDescriptor) ) ) )
1859 return 0;
1860
1861 pOleMenuDescriptor = GlobalLock( hOleMenu );
1862 if ( !pOleMenuDescriptor )
1863 return 0;
1864
1865 /* Initialize menu group widths and hmenu */
1866 for ( i = 0; i < 6; i++ )
1867 pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
1868
1869 pOleMenuDescriptor->hmenuCombined = hmenuCombined;
1870 pOleMenuDescriptor->bIsServerItem = FALSE;
1871 GlobalUnlock( hOleMenu );
1872
1873 return hOleMenu;
1874 }
1875
1876 /***********************************************************************
1877 * OleDestroyMenuDescriptor [OLE32.@]
1878 * Destroy the shared menu descriptor
1879 */
1880 HRESULT WINAPI OleDestroyMenuDescriptor(
1881 HOLEMENU hmenuDescriptor)
1882 {
1883 if ( hmenuDescriptor )
1884 GlobalFree( hmenuDescriptor );
1885 return S_OK;
1886 }
1887
1888 /***********************************************************************
1889 * OleSetMenuDescriptor [OLE32.@]
1890 * Installs or removes OLE dispatching code for the containers frame window.
1891 *
1892 * PARAMS
1893 * hOleMenu Handle to composite menu descriptor
1894 * hwndFrame Handle to containers frame window
1895 * hwndActiveObject Handle to objects in-place activation window
1896 * lpFrame Pointer to IOleInPlaceFrame on containers window
1897 * lpActiveObject Pointer to IOleInPlaceActiveObject on active in-place object
1898 *
1899 * RETURNS
1900 * S_OK - menu installed correctly
1901 * E_FAIL, E_INVALIDARG, E_UNEXPECTED - failure
1902 *
1903 * FIXME
1904 * The lpFrame and lpActiveObject parameters are currently ignored
1905 * OLE should install context sensitive help F1 filtering for the app when
1906 * these are non null.
1907 */
1908 HRESULT WINAPI OleSetMenuDescriptor(
1909 HOLEMENU hOleMenu,
1910 HWND hwndFrame,
1911 HWND hwndActiveObject,
1912 LPOLEINPLACEFRAME lpFrame,
1913 LPOLEINPLACEACTIVEOBJECT lpActiveObject)
1914 {
1915 OleMenuDescriptor *pOleMenuDescriptor = NULL;
1916
1917 /* Check args */
1918 if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
1919 return E_INVALIDARG;
1920
1921 if ( lpFrame || lpActiveObject )
1922 {
1923 FIXME("(%p, %p, %p, %p, %p), Context sensitive help filtering not implemented!\n",
1924 hOleMenu,
1925 hwndFrame,
1926 hwndActiveObject,
1927 lpFrame,
1928 lpActiveObject);
1929 }
1930
1931 /* Set up a message hook to intercept the containers frame window messages.
1932 * The message filter is responsible for dispatching menu messages from the
1933 * shared menu which are intended for the object.
1934 */
1935
1936 if ( hOleMenu ) /* Want to install dispatching code */
1937 {
1938 /* If OLEMenu hooks are already installed for this thread, fail
1939 * Note: This effectively means that OleSetMenuDescriptor cannot
1940 * be called twice in succession on the same frame window
1941 * without first calling it with a null hOleMenu to uninstall
1942 */
1943 if ( OLEMenu_IsHookInstalled( GetCurrentThreadId() ) )
1944 return E_FAIL;
1945
1946 /* Get the menu descriptor */
1947 pOleMenuDescriptor = GlobalLock( hOleMenu );
1948 if ( !pOleMenuDescriptor )
1949 return E_UNEXPECTED;
1950
1951 /* Update the menu descriptor */
1952 pOleMenuDescriptor->hwndFrame = hwndFrame;
1953 pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
1954
1955 GlobalUnlock( hOleMenu );
1956 pOleMenuDescriptor = NULL;
1957
1958 /* Add a menu descriptor windows property to the frame window */
1959 SetPropW( hwndFrame, prop_olemenuW, hOleMenu );
1960
1961 /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
1962 if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
1963 return E_FAIL;
1964 }
1965 else /* Want to uninstall dispatching code */
1966 {
1967 /* Uninstall the hooks */
1968 if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
1969 return E_FAIL;
1970
1971 /* Remove the menu descriptor property from the frame window */
1972 RemovePropW( hwndFrame, prop_olemenuW );
1973 }
1974
1975 return S_OK;
1976 }
1977
1978 /******************************************************************************
1979 * IsAccelerator [OLE32.@]
1980 * Mostly copied from controls/menu.c TranslateAccelerator implementation
1981 */
1982 BOOL WINAPI IsAccelerator(HACCEL hAccel, int cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
1983 {
1984 LPACCEL lpAccelTbl;
1985 int i;
1986
1987 if(!lpMsg) return FALSE;
1988 if (!hAccel)
1989 {
1990 WARN_(accel)("NULL accel handle\n");
1991 return FALSE;
1992 }
1993 if((lpMsg->message != WM_KEYDOWN &&
1994 lpMsg->message != WM_SYSKEYDOWN &&
1995 lpMsg->message != WM_SYSCHAR &&
1996 lpMsg->message != WM_CHAR)) return FALSE;
1997 lpAccelTbl = HeapAlloc(GetProcessHeap(), 0, cAccelEntries * sizeof(ACCEL));
1998 if (NULL == lpAccelTbl)
1999 {
2000 return FALSE;
2001 }
2002 if (CopyAcceleratorTableW(hAccel, lpAccelTbl, cAccelEntries) != cAccelEntries)
2003 {
2004 WARN_(accel)("CopyAcceleratorTableW failed\n");
2005 HeapFree(GetProcessHeap(), 0, lpAccelTbl);
2006 return FALSE;
2007 }
2008
2009 TRACE_(accel)("hAccel=%p, cAccelEntries=%d,"
2010 "msg->hwnd=%p, msg->message=%04x, wParam=%08lx, lParam=%08lx\n",
2011 hAccel, cAccelEntries,
2012 lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam);
2013 for(i = 0; i < cAccelEntries; i++)
2014 {
2015 if(lpAccelTbl[i].key != lpMsg->wParam)
2016 continue;
2017
2018 if(lpMsg->message == WM_CHAR)
2019 {
2020 if(!(lpAccelTbl[i].fVirt & FALT) && !(lpAccelTbl[i].fVirt & FVIRTKEY))
2021 {
2022 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", LOWORD(lpMsg->wParam) & 0xff);
2023 goto found;
2024 }
2025 }
2026 else
2027 {
2028 if(lpAccelTbl[i].fVirt & FVIRTKEY)
2029 {
2030 INT mask = 0;
2031 TRACE_(accel)("found accel for virt_key %04lx (scan %04x)\n",
2032 lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff);
2033 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
2034 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
2035 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
2036 if(mask == (lpAccelTbl[i].fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
2037 TRACE_(accel)("incorrect SHIFT/CTRL/ALT-state\n");
2038 }
2039 else
2040 {
2041 if(!(lpMsg->lParam & 0x01000000)) /* no special_key */
2042 {
2043 if((lpAccelTbl[i].fVirt & FALT) && (lpMsg->lParam & 0x20000000))
2044 { /* ^^ ALT pressed */
2045 TRACE_(accel)("found accel for Alt-%c\n", LOWORD(lpMsg->wParam) & 0xff);
2046 goto found;
2047 }
2048 }
2049 }
2050 }
2051 }
2052
2053 WARN_(accel)("couldn't translate accelerator key\n");
2054 HeapFree(GetProcessHeap(), 0, lpAccelTbl);
2055 return FALSE;
2056
2057 found:
2058 if(lpwCmd) *lpwCmd = lpAccelTbl[i].cmd;
2059 HeapFree(GetProcessHeap(), 0, lpAccelTbl);
2060 return TRUE;
2061 }
2062
2063 /***********************************************************************
2064 * ReleaseStgMedium [OLE32.@]
2065 */
2066 void WINAPI ReleaseStgMedium(
2067 STGMEDIUM* pmedium)
2068 {
2069 switch (pmedium->tymed)
2070 {
2071 case TYMED_HGLOBAL:
2072 {
2073 if ( (pmedium->pUnkForRelease==0) &&
2074 (pmedium->u.hGlobal!=0) )
2075 GlobalFree(pmedium->u.hGlobal);
2076 break;
2077 }
2078 case TYMED_FILE:
2079 {
2080 if (pmedium->u.lpszFileName!=0)
2081 {
2082 if (pmedium->pUnkForRelease==0)
2083 {
2084 DeleteFileW(pmedium->u.lpszFileName);
2085 }
2086
2087 CoTaskMemFree(pmedium->u.lpszFileName);
2088 }
2089 break;
2090 }
2091 case TYMED_ISTREAM:
2092 {
2093 if (pmedium->u.pstm!=0)
2094 {
2095 IStream_Release(pmedium->u.pstm);
2096 }
2097 break;
2098 }
2099 case TYMED_ISTORAGE:
2100 {
2101 if (pmedium->u.pstg!=0)
2102 {
2103 IStorage_Release(pmedium->u.pstg);
2104 }
2105 break;
2106 }
2107 case TYMED_GDI:
2108 {
2109 if ( (pmedium->pUnkForRelease==0) &&
2110 (pmedium->u.hBitmap!=0) )
2111 DeleteObject(pmedium->u.hBitmap);
2112 break;
2113 }
2114 case TYMED_MFPICT:
2115 {
2116 if ( (pmedium->pUnkForRelease==0) &&
2117 (pmedium->u.hMetaFilePict!=0) )
2118 {
2119 LPMETAFILEPICT pMP = GlobalLock(pmedium->u.hMetaFilePict);
2120 DeleteMetaFile(pMP->hMF);
2121 GlobalUnlock(pmedium->u.hMetaFilePict);
2122 GlobalFree(pmedium->u.hMetaFilePict);
2123 }
2124 break;
2125 }
2126 case TYMED_ENHMF:
2127 {
2128 if ( (pmedium->pUnkForRelease==0) &&
2129 (pmedium->u.hEnhMetaFile!=0) )
2130 {
2131 DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
2132 }
2133 break;
2134 }
2135 case TYMED_NULL:
2136 default:
2137 break;
2138 }
2139 pmedium->tymed=TYMED_NULL;
2140
2141 /*
2142 * After cleaning up, the unknown is released
2143 */
2144 if (pmedium->pUnkForRelease!=0)
2145 {
2146 IUnknown_Release(pmedium->pUnkForRelease);
2147 pmedium->pUnkForRelease = 0;
2148 }
2149 }
2150
2151 /***
2152 * OLEDD_Initialize()
2153 *
2154 * Initializes the OLE drag and drop data structures.
2155 */
2156 static void OLEDD_Initialize(void)
2157 {
2158 WNDCLASSW wndClass;
2159
2160 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
2161 wndClass.style = CS_GLOBALCLASS;
2162 wndClass.lpfnWndProc = OLEDD_DragTrackerWindowProc;
2163 wndClass.cbClsExtra = 0;
2164 wndClass.cbWndExtra = sizeof(TrackerWindowInfo*);
2165 wndClass.hCursor = 0;
2166 wndClass.hbrBackground = 0;
2167 wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
2168
2169 RegisterClassW (&wndClass);
2170 }
2171
2172 /***
2173 * OLEDD_DragTrackerWindowProc()
2174 *
2175 * This method is the WindowProcedure of the drag n drop tracking
2176 * window. During a drag n Drop operation, an invisible window is created
2177 * to receive the user input and act upon it. This procedure is in charge
2178 * of this behavior.
2179 */
2180
2181 #define DRAG_TIMER_ID 1
2182
2183 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(
2184 HWND hwnd,
2185 UINT uMsg,
2186 WPARAM wParam,
2187 LPARAM lParam)
2188 {
2189 switch (uMsg)
2190 {
2191 case WM_CREATE:
2192 {
2193 LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
2194
2195 SetWindowLongPtrW(hwnd, 0, (LONG_PTR)createStruct->lpCreateParams);
2196 SetTimer(hwnd, DRAG_TIMER_ID, 50, NULL);
2197
2198 break;
2199 }
2200 case WM_TIMER:
2201 case WM_MOUSEMOVE:
2202 {
2203 OLEDD_TrackMouseMove((TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0));
2204 break;
2205 }
2206 case WM_LBUTTONUP:
2207 case WM_MBUTTONUP:
2208 case WM_RBUTTONUP:
2209 case WM_LBUTTONDOWN:
2210 case WM_MBUTTONDOWN:
2211 case WM_RBUTTONDOWN:
2212 {
2213 OLEDD_TrackStateChange((TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0));
2214 break;
2215 }
2216 case WM_DESTROY:
2217 {
2218 KillTimer(hwnd, DRAG_TIMER_ID);
2219 break;
2220 }
2221 }
2222
2223 /*
2224 * This is a window proc after all. Let's call the default.
2225 */
2226 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
2227 }
2228
2229 /***
2230 * OLEDD_TrackMouseMove()
2231 *
2232 * This method is invoked while a drag and drop operation is in effect.
2233 * it will generate the appropriate callbacks in the drop source
2234 * and drop target. It will also provide the expected feedback to
2235 * the user.
2236 *
2237 * params:
2238 * trackerInfo - Pointer to the structure identifying the
2239 * drag & drop operation that is currently
2240 * active.
2241 */
2242 static void OLEDD_TrackMouseMove(TrackerWindowInfo* trackerInfo)
2243 {
2244 HWND hwndNewTarget = 0;
2245 HRESULT hr = S_OK;
2246 POINT pt;
2247
2248 /*
2249 * Get the handle of the window under the mouse
2250 */
2251 pt.x = trackerInfo->curMousePos.x;
2252 pt.y = trackerInfo->curMousePos.y;
2253 hwndNewTarget = WindowFromPoint(pt);
2254
2255 /*
2256 * Every time, we re-initialize the effects passed to the
2257 * IDropTarget to the effects allowed by the source.
2258 */
2259 *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
2260
2261 /*
2262 * If we are hovering over the same target as before, send the
2263 * DragOver notification
2264 */
2265 if ( (trackerInfo->curDragTarget != 0) &&
2266 (trackerInfo->curTargetHWND == hwndNewTarget) )
2267 {
2268 IDropTarget_DragOver(trackerInfo->curDragTarget,
2269 trackerInfo->dwKeyState,
2270 trackerInfo->curMousePos,
2271 trackerInfo->pdwEffect);
2272 }
2273 else
2274 {
2275 /*
2276 * If we changed window, we have to notify our old target and check for
2277 * the new one.
2278 */
2279 if (trackerInfo->curDragTarget)
2280 IDropTarget_DragLeave(trackerInfo->curDragTarget);
2281
2282 /*
2283 * Make sure we're hovering over a window.
2284 */
2285 if (hwndNewTarget)
2286 {
2287 /*
2288 * Find-out if there is a drag target under the mouse
2289 */
2290 HWND next_target_wnd = hwndNewTarget;
2291
2292 trackerInfo->curTargetHWND = hwndNewTarget;
2293
2294 while (next_target_wnd && !is_droptarget(next_target_wnd))
2295 next_target_wnd = GetParent(next_target_wnd);
2296
2297 if (next_target_wnd) hwndNewTarget = next_target_wnd;
2298
2299 trackerInfo->curDragTargetHWND = hwndNewTarget;
2300 if(trackerInfo->curDragTarget) IDropTarget_Release(trackerInfo->curDragTarget);
2301 trackerInfo->curDragTarget = get_droptarget_pointer(hwndNewTarget);
2302
2303 /*
2304 * If there is, notify it that we just dragged-in
2305 */
2306 if (trackerInfo->curDragTarget)
2307 {
2308 hr = IDropTarget_DragEnter(trackerInfo->curDragTarget,
2309 trackerInfo->dataObject,
2310 trackerInfo->dwKeyState,
2311 trackerInfo->curMousePos,
2312 trackerInfo->pdwEffect);
2313
2314 /* failed DragEnter() means invalid target */
2315 if (hr != S_OK)
2316 {
2317 trackerInfo->curDragTargetHWND = 0;
2318 trackerInfo->curTargetHWND = 0;
2319 IDropTarget_Release(trackerInfo->curDragTarget);
2320 trackerInfo->curDragTarget = 0;
2321 }
2322 }
2323 }
2324 else
2325 {
2326 /*
2327 * The mouse is not over a window so we don't track anything.
2328 */
2329 trackerInfo->curDragTargetHWND = 0;
2330 trackerInfo->curTargetHWND = 0;
2331 if(trackerInfo->curDragTarget) IDropTarget_Release(trackerInfo->curDragTarget);
2332 trackerInfo->curDragTarget = 0;
2333 }
2334 }
2335
2336 /*
2337 * Now that we have done that, we have to tell the source to give
2338 * us feedback on the work being done by the target. If we don't
2339 * have a target, simulate no effect.
2340 */
2341 if (trackerInfo->curDragTarget==0)
2342 {
2343 *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2344 }
2345
2346 hr = IDropSource_GiveFeedback(trackerInfo->dropSource,
2347 *trackerInfo->pdwEffect);
2348
2349 /*
2350 * When we ask for feedback from the drop source, sometimes it will
2351 * do all the necessary work and sometimes it will not handle it
2352 * when that's the case, we must display the standard drag and drop
2353 * cursors.
2354 */
2355 if (hr == DRAGDROP_S_USEDEFAULTCURSORS)
2356 {
2357 HCURSOR hCur;
2358
2359 if (*trackerInfo->pdwEffect & DROPEFFECT_MOVE)
2360 {
2361 hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(2));
2362 }
2363 else if (*trackerInfo->pdwEffect & DROPEFFECT_COPY)
2364 {
2365 hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(3));
2366 }
2367 else if (*trackerInfo->pdwEffect & DROPEFFECT_LINK)
2368 {
2369 hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(4));
2370 }
2371 else
2372 {
2373 hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(1));
2374 }
2375
2376 SetCursor(hCur);
2377 }
2378 }
2379
2380 /***
2381 * OLEDD_TrackStateChange()
2382 *
2383 * This method is invoked while a drag and drop operation is in effect.
2384 * It is used to notify the drop target/drop source callbacks when
2385 * the state of the keyboard or mouse button change.
2386 *
2387 * params:
2388 * trackerInfo - Pointer to the structure identifying the
2389 * drag & drop operation that is currently
2390 * active.
2391 */
2392 static void OLEDD_TrackStateChange(TrackerWindowInfo* trackerInfo)
2393 {
2394 /*
2395 * Ask the drop source what to do with the operation.
2396 */
2397 trackerInfo->returnValue = IDropSource_QueryContinueDrag(
2398 trackerInfo->dropSource,
2399 trackerInfo->escPressed,
2400 trackerInfo->dwKeyState);
2401
2402 /*
2403 * All the return valued will stop the operation except the S_OK
2404 * return value.
2405 */
2406 if (trackerInfo->returnValue!=S_OK)
2407 {
2408 /*
2409 * Make sure the message loop in DoDragDrop stops
2410 */
2411 trackerInfo->trackingDone = TRUE;
2412
2413 /*
2414 * Release the mouse in case the drop target decides to show a popup
2415 * or a menu or something.
2416 */
2417 ReleaseCapture();
2418
2419 /*
2420 * If we end-up over a target, drop the object in the target or
2421 * inform the target that the operation was cancelled.
2422 */
2423 if (trackerInfo->curDragTarget)
2424 {
2425 switch (trackerInfo->returnValue)
2426 {
2427 /*
2428 * If the source wants us to complete the operation, we tell
2429 * the drop target that we just dropped the object in it.
2430 */
2431 case DRAGDROP_S_DROP:
2432 if (*trackerInfo->pdwEffect != DROPEFFECT_NONE)
2433 IDropTarget_Drop(trackerInfo->curDragTarget,
2434 trackerInfo->dataObject,
2435 trackerInfo->dwKeyState,
2436 trackerInfo->curMousePos,
2437 trackerInfo->pdwEffect);
2438 else
2439 IDropTarget_DragLeave(trackerInfo->curDragTarget);
2440 break;
2441
2442 /*
2443 * If the source told us that we should cancel, fool the drop
2444 * target by telling it that the mouse left its window.
2445 * Also set the drop effect to "NONE" in case the application
2446 * ignores the result of DoDragDrop.
2447 */
2448 case DRAGDROP_S_CANCEL:
2449 IDropTarget_DragLeave(trackerInfo->curDragTarget);
2450 *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2451 break;
2452 }
2453 }
2454 }
2455 }
2456
2457 /***
2458 * OLEDD_GetButtonState()
2459 *
2460 * This method will use the current state of the keyboard to build
2461 * a button state mask equivalent to the one passed in the
2462 * WM_MOUSEMOVE wParam.
2463 */
2464 static DWORD OLEDD_GetButtonState(void)
2465 {
2466 BYTE keyboardState[256];
2467 DWORD keyMask = 0;
2468
2469 GetKeyboardState(keyboardState);
2470
2471 if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
2472 keyMask |= MK_SHIFT;
2473
2474 if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
2475 keyMask |= MK_CONTROL;
2476
2477 if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
2478 keyMask |= MK_LBUTTON;
2479
2480 if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
2481 keyMask |= MK_RBUTTON;
2482
2483 if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
2484 keyMask |= MK_MBUTTON;
2485
2486 return keyMask;
2487 }
2488
2489 /***
2490 * OLEDD_GetButtonState()
2491 *
2492 * This method will read the default value of the registry key in
2493 * parameter and extract a DWORD value from it. The registry key value
2494 * can be in a string key or a DWORD key.
2495 *
2496 * params:
2497 * regKey - Key to read the default value from
2498 * pdwValue - Pointer to the location where the DWORD
2499 * value is returned. This value is not modified
2500 * if the value is not found.
2501 */
2502
2503 static void OLEUTL_ReadRegistryDWORDValue(
2504 HKEY regKey,
2505 DWORD* pdwValue)
2506 {
2507 WCHAR buffer[20];
2508 DWORD cbData = sizeof(buffer);
2509 DWORD dwKeyType;
2510 LONG lres;
2511
2512 lres = RegQueryValueExW(regKey,
2513 emptyW,
2514 NULL,
2515 &dwKeyType,
2516 (LPBYTE)buffer,
2517 &cbData);
2518
2519 if (lres==ERROR_SUCCESS)
2520 {
2521 switch (dwKeyType)
2522 {
2523 case REG_DWORD:
2524 *pdwValue = *(DWORD*)buffer;
2525 break;
2526 case REG_EXPAND_SZ:
2527 case REG_MULTI_SZ:
2528 case REG_SZ:
2529 *pdwValue = (DWORD)strtoulW(buffer, NULL, 10);
2530 break;
2531 }
2532 }
2533 }
2534
2535 /******************************************************************************
2536 * OleDraw (OLE32.@)
2537 *
2538 * The operation of this function is documented literally in the WinAPI
2539 * documentation to involve a QueryInterface for the IViewObject interface,
2540 * followed by a call to IViewObject::Draw.
2541 */
2542 HRESULT WINAPI OleDraw(
2543 IUnknown *pUnk,
2544 DWORD dwAspect,
2545 HDC hdcDraw,
2546 LPCRECT rect)
2547 {
2548 HRESULT hres;
2549 IViewObject *viewobject;
2550
2551 if (!pUnk) return E_INVALIDARG;
2552
2553 hres = IUnknown_QueryInterface(pUnk,
2554 &IID_IViewObject,
2555 (void**)&viewobject);
2556 if (SUCCEEDED(hres))
2557 {
2558 hres = IViewObject_Draw(viewobject, dwAspect, -1, 0, 0, 0, hdcDraw, (RECTL*)rect, 0, 0, 0);
2559 IViewObject_Release(viewobject);
2560 return hres;
2561 }
2562 else
2563 return DV_E_NOIVIEWOBJECT;
2564 }
2565
2566 /***********************************************************************
2567 * OleTranslateAccelerator [OLE32.@]
2568 */
2569 HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame,
2570 LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
2571 {
2572 WORD wID;
2573
2574 TRACE("(%p,%p,%p)\n", lpFrame, lpFrameInfo, lpmsg);
2575
2576 if (IsAccelerator(lpFrameInfo->haccel,lpFrameInfo->cAccelEntries,lpmsg,&wID))
2577 return IOleInPlaceFrame_TranslateAccelerator(lpFrame,lpmsg,wID);
2578
2579 return S_FALSE;
2580 }
2581
2582 /******************************************************************************
2583 * OleCreate [OLE32.@]
2584 *
2585 */
2586 HRESULT WINAPI OleCreate(
2587 REFCLSID rclsid,
2588 REFIID riid,
2589 DWORD renderopt,
2590 LPFORMATETC pFormatEtc,
2591 LPOLECLIENTSITE pClientSite,
2592 LPSTORAGE pStg,
2593 LPVOID* ppvObj)
2594 {
2595 HRESULT hres;
2596 IUnknown * pUnk = NULL;
2597 IOleObject *pOleObject = NULL;
2598
2599 TRACE("(%s, %s, %d, %p, %p, %p, %p)\n", debugstr_guid(rclsid),
2600 debugstr_guid(riid), renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
2601
2602 hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, riid, (LPVOID*)&pUnk);
2603
2604 if (SUCCEEDED(hres))
2605 hres = IStorage_SetClass(pStg, rclsid);
2606
2607 if (pClientSite && SUCCEEDED(hres))
2608 {
2609 hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (LPVOID*)&pOleObject);
2610 if (SUCCEEDED(hres))
2611 {
2612 DWORD dwStatus;
2613 hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
2614 }
2615 }
2616
2617 if (SUCCEEDED(hres))
2618 {
2619 IPersistStorage * pPS;
2620 if (SUCCEEDED((hres = IUnknown_QueryInterface(pUnk, &IID_IPersistStorage, (LPVOID*)&pPS))))
2621 {
2622 TRACE("trying to set stg %p\n", pStg);
2623 hres = IPersistStorage_InitNew(pPS, pStg);
2624 TRACE("-- result 0x%08x\n", hres);
2625 IPersistStorage_Release(pPS);
2626 }
2627 }
2628
2629 if (pClientSite && SUCCEEDED(hres))
2630 {
2631 TRACE("trying to set clientsite %p\n", pClientSite);
2632 hres = IOleObject_SetClientSite(pOleObject, pClientSite);
2633 TRACE("-- result 0x%08x\n", hres);
2634 }
2635
2636 if (pOleObject)
2637 IOleObject_Release(pOleObject);
2638
2639 if (((renderopt == OLERENDER_DRAW) || (renderopt == OLERENDER_FORMAT)) &&
2640 SUCCEEDED(hres))
2641 {
2642 IRunnableObject *pRunnable;
2643 IOleCache *pOleCache;
2644 HRESULT hres2;
2645
2646 hres2 = IUnknown_QueryInterface(pUnk, &IID_IRunnableObject, (void **)&pRunnable);
2647 if (SUCCEEDED(hres2))
2648 {
2649 hres = IRunnableObject_Run(pRunnable, NULL);
2650 IRunnableObject_Release(pRunnable);
2651 }
2652
2653 if (SUCCEEDED(hres))
2654 {
2655 hres2 = IUnknown_QueryInterface(pUnk, &IID_IOleCache, (void **)&pOleCache);
2656 if (SUCCEEDED(hres2))
2657 {
2658 DWORD dwConnection;
2659 if (renderopt == OLERENDER_DRAW && !pFormatEtc) {
2660 FORMATETC pfe;
2661 pfe.cfFormat = 0;
2662 pfe.ptd = NULL;
2663 pfe.dwAspect = DVASPECT_CONTENT;
2664 pfe.lindex = -1;
2665 pfe.tymed = TYMED_NULL;
2666 hres = IOleCache_Cache(pOleCache, &pfe, ADVF_PRIMEFIRST, &dwConnection);
2667 }
2668 else
2669 hres = IOleCache_Cache(pOleCache, pFormatEtc, ADVF_PRIMEFIRST, &dwConnection);
2670 IOleCache_Release(pOleCache);
2671 }
2672 }
2673 }
2674
2675 if (FAILED(hres) && pUnk)
2676 {
2677 IUnknown_Release(pUnk);
2678 pUnk = NULL;
2679 }
2680
2681 *ppvObj = pUnk;
2682
2683 TRACE("-- %p\n", pUnk);
2684 return hres;
2685 }
2686
2687 /******************************************************************************
2688 * OleGetAutoConvert [OLE32.@]
2689 */
2690 HRESULT WINAPI OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
2691 {
2692 static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2693 HKEY hkey = NULL;
2694 WCHAR buf[CHARS_IN_GUID];
2695 LONG len;
2696 HRESULT res = S_OK;
2697
2698 res = COM_OpenKeyForCLSID(clsidOld, wszAutoConvertTo, KEY_READ, &hkey);
2699 if (FAILED(res))
2700 goto done;
2701
2702 len = sizeof(buf);
2703 if (RegQueryValueW(hkey, NULL, buf, &len))
2704 {
2705 res = REGDB_E_KEYMISSING;
2706 goto done;
2707 }
2708 res = CLSIDFromString(buf, pClsidNew);
2709 done:
2710 if (hkey) RegCloseKey(hkey);
2711 return res;
2712 }
2713
2714 /******************************************************************************
2715 * OleSetAutoConvert [OLE32.@]
2716 */
2717 HRESULT WINAPI OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew)
2718 {
2719 static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2720 HKEY hkey = NULL;
2721 WCHAR szClsidNew[CHARS_IN_GUID];
2722 HRESULT res = S_OK;
2723
2724 TRACE("(%s,%s)\n", debugstr_guid(clsidOld), debugstr_guid(clsidNew));
2725
2726 res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2727 if (FAILED(res))
2728 goto done;
2729 StringFromGUID2(clsidNew, szClsidNew, CHARS_IN_GUID);
2730 if (RegSetValueW(hkey, wszAutoConvertTo, REG_SZ, szClsidNew, (strlenW(szClsidNew)+1) * sizeof(WCHAR)))
2731 {
2732 res = REGDB_E_WRITEREGDB;
2733 goto done;
2734 }
2735
2736 done:
2737 if (hkey) RegCloseKey(hkey);
2738 return res;
2739 }
2740
2741 /******************************************************************************
2742 * OleDoAutoConvert [OLE32.@]
2743 */
2744 HRESULT WINAPI OleDoAutoConvert(LPSTORAGE pStg, LPCLSID pClsidNew)
2745 {
2746 FIXME("(%p,%p) : stub\n",pStg,pClsidNew);
2747 return E_NOTIMPL;
2748 }
2749
2750 /******************************************************************************
2751 * OleIsRunning [OLE32.@]
2752 */
2753 BOOL WINAPI OleIsRunning(LPOLEOBJECT object)
2754 {
2755 IRunnableObject *pRunnable;
2756 HRESULT hr;
2757 BOOL running;
2758
2759 TRACE("(%p)\n", object);
2760
2761 if (!object) return FALSE;
2762
2763 hr = IOleObject_QueryInterface(object, &IID_IRunnableObject, (void **)&pRunnable);
2764 if (FAILED(hr))
2765 return TRUE;
2766 running = IRunnableObject_IsRunning(pRunnable);
2767 IRunnableObject_Release(pRunnable);
2768 return running;
2769 }
2770
2771 /***********************************************************************
2772 * OleNoteObjectVisible [OLE32.@]
2773 */
2774 HRESULT WINAPI OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL bVisible)
2775 {
2776 TRACE("(%p, %s)\n", pUnknown, bVisible ? "TRUE" : "FALSE");
2777 return CoLockObjectExternal(pUnknown, bVisible, TRUE);
2778 }
2779
2780
2781 /***********************************************************************
2782 * OLE_FreeClipDataArray [internal]
2783 *
2784 * NOTES:
2785 * frees the data associated with an array of CLIPDATAs
2786 */
2787 static void OLE_FreeClipDataArray(ULONG count, CLIPDATA * pClipDataArray)
2788 {
2789 ULONG i;
2790 for (i = 0; i < count; i++)
2791 if (pClipDataArray[i].pClipData)
2792 CoTaskMemFree(pClipDataArray[i].pClipData);
2793 }
2794
2795 /***********************************************************************
2796 * PropSysAllocString [OLE32.@]
2797 * NOTES
2798 * Forward to oleaut32.
2799 */
2800 BSTR WINAPI PropSysAllocString(LPCOLESTR str)
2801 {
2802 return SysAllocString(str);
2803 }
2804
2805 /***********************************************************************
2806 * PropSysFreeString [OLE32.@]
2807 * NOTES
2808 * Forward to oleaut32.
2809 */
2810 void WINAPI PropSysFreeString(LPOLESTR str)
2811 {
2812 SysFreeString(str);
2813 }
2814
2815 /******************************************************************************
2816 * Check if a PROPVARIANT's type is valid.
2817 */
2818 static inline HRESULT PROPVARIANT_ValidateType(VARTYPE vt)
2819 {
2820 switch (vt)
2821 {
2822 case VT_EMPTY:
2823 case VT_NULL:
2824 case VT_I1:
2825 case VT_I2:
2826 case VT_I4:
2827 case VT_I8:
2828 case VT_R4:
2829 case VT_R8:
2830 case VT_CY:
2831 case VT_DATE:
2832 case VT_BSTR:
2833 case VT_ERROR:
2834 case VT_BOOL:
2835 case VT_DECIMAL:
2836 case VT_UI1:
2837 case VT_UI2:
2838 case VT_UI4:
2839 case VT_UI8:
2840 case VT_LPSTR:
2841 case VT_LPWSTR:
2842 case VT_FILETIME:
2843 case VT_BLOB:
2844 case VT_STREAM:
2845 case VT_STORAGE:
2846 case VT_STREAMED_OBJECT:
2847 case VT_STORED_OBJECT:
2848 case VT_BLOB_OBJECT:
2849 case VT_CF:
2850 case VT_CLSID:
2851 case VT_I1|VT_VECTOR:
2852 case VT_I2|VT_VECTOR:
2853 case VT_I4|VT_VECTOR:
2854 case VT_I8|VT_VECTOR:
2855 case VT_R4|VT_VECTOR:
2856 case VT_R8|VT_VECTOR:
2857 case VT_CY|VT_VECTOR:
2858 case VT_DATE|VT_VECTOR:
2859 case VT_BSTR|VT_VECTOR:
2860 case VT_ERROR|VT_VECTOR:
2861 case VT_BOOL|VT_VECTOR:
2862 case VT_VARIANT|VT_VECTOR:
2863 case VT_UI1|VT_VECTOR:
2864 case VT_UI2|VT_VECTOR:
2865 case VT_UI4|VT_VECTOR:
2866 case VT_UI8|VT_VECTOR:
2867 case VT_LPSTR|VT_VECTOR:
2868 case VT_LPWSTR|VT_VECTOR:
2869 case VT_FILETIME|VT_VECTOR:
2870 case VT_CF|VT_VECTOR:
2871 case VT_CLSID|VT_VECTOR:
2872 return S_OK;
2873 }
2874 WARN("Bad type %d\n", vt);
2875 return STG_E_INVALIDPARAMETER;
2876 }
2877
2878 /***********************************************************************
2879 * PropVariantClear [OLE32.@]
2880 */
2881 HRESULT WINAPI PropVariantClear(PROPVARIANT * pvar) /* [in/out] */
2882 {
2883 HRESULT hr;
2884
2885 TRACE("(%p)\n", pvar);
2886
2887 if (!pvar)
2888 return S_OK;
2889
2890 hr = PROPVARIANT_ValidateType(pvar->vt);
2891 if (FAILED(hr))
2892 return hr;
2893
2894 switch(pvar->vt)
2895 {
2896 case VT_EMPTY:
2897 case VT_NULL:
2898 case VT_I1:
2899 case VT_I2:
2900 case VT_I4:
2901 case VT_I8:
2902 case VT_R4:
2903 case VT_R8:
2904 case VT_CY:
2905 case VT_DATE:
2906 case VT_ERROR:
2907 case VT_BOOL:
2908 case VT_DECIMAL:
2909 case VT_UI1:
2910 case VT_UI2:
2911 case VT_UI4:
2912 case VT_UI8:
2913 case VT_FILETIME:
2914 break;
2915 case VT_STREAM:
2916 case VT_STREAMED_OBJECT:
2917 case VT_STORAGE:
2918 case VT_STORED_OBJECT:
2919 if (pvar->u.pStream)
2920 IStream_Release(pvar->u.pStream);
2921 break;
2922 case VT_CLSID:
2923 case VT_LPSTR:
2924 case VT_LPWSTR:
2925 /* pick an arbitrary typed pointer - we don't care about the type
2926 * as we are just freeing it */
2927 CoTaskMemFree(pvar->u.puuid);
2928 break;
2929 case VT_BLOB:
2930 case VT_BLOB_OBJECT:
2931 CoTaskMemFree(pvar->u.blob.pBlobData);
2932 break;
2933 case VT_BSTR:
2934 PropSysFreeString(pvar->u.bstrVal);
2935 break;
2936 case VT_CF:
2937 if (pvar->u.pclipdata)
2938 {
2939 OLE_FreeClipDataArray(1, pvar->u.pclipdata);
2940 CoTaskMemFree(pvar->u.pclipdata);
2941 }
2942 break;
2943 default:
2944 if (pvar->vt & VT_VECTOR)
2945 {
2946 ULONG i;
2947
2948 switch (pvar->vt & ~VT_VECTOR)
2949 {
2950 case VT_VARIANT:
2951 FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
2952 break;
2953 case VT_CF:
2954 OLE_FreeClipDataArray(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
2955 break;
2956 case VT_BSTR:
2957 for (i = 0; i < pvar->u.cabstr.cElems; i++)
2958 PropSysFreeString(pvar->u.cabstr.pElems[i]);
2959 break;
2960 case VT_LPSTR:
2961 for (i = 0; i < pvar->u.calpstr.cElems; i++)
2962 CoTaskMemFree(pvar->u.calpstr.pElems[i]);
2963 break;
2964 case VT_LPWSTR:
2965 for (i = 0; i < pvar->u.calpwstr.cElems; i++)
2966 CoTaskMemFree(pvar->u.calpwstr.pElems[i]);
2967 break;
2968 }
2969 if (pvar->vt & ~VT_VECTOR)
2970 {
2971 /* pick an arbitrary VT_VECTOR structure - they all have the same
2972 * memory layout */
2973 CoTaskMemFree(pvar->u.capropvar.pElems);
2974 }
2975 }
2976 else
2977 WARN("Invalid/unsupported type %d\n", pvar->vt);
2978 }
2979
2980 ZeroMemory(pvar, sizeof(*pvar));
2981
2982 return S_OK;
2983 }
2984
2985 /***********************************************************************
2986 * PropVariantCopy [OLE32.@]
2987 */
2988 HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest, /* [out] */
2989 const PROPVARIANT *pvarSrc) /* [in] */
2990 {
2991 ULONG len;
2992 HRESULT hr;
2993
2994 TRACE("(%p, %p vt %04x)\n", pvarDest, pvarSrc, pvarSrc->vt);
2995
2996 hr = PROPVARIANT_ValidateType(pvarSrc->vt);
2997 if (FAILED(hr))
2998 return hr;
2999
3000 /* this will deal with most cases */
3001 *pvarDest = *pvarSrc;
3002
3003 switch(pvarSrc->vt)
3004 {
3005 case VT_EMPTY:
3006 case VT_NULL:
3007 case VT_I1:
3008 case VT_UI1:
3009 case VT_I2:
3010 case VT_UI2:
3011 case VT_BOOL:
3012 case VT_DECIMAL:
3013 case VT_I4:
3014 case VT_UI4:
3015 case VT_R4:
3016 case VT_ERROR:
3017 case VT_I8:
3018 case VT_UI8:
3019 case VT_R8:
3020 case VT_CY:
3021 case VT_DATE:
3022 case VT_FILETIME:
3023 break;
3024 case VT_STREAM:
3025 case VT_STREAMED_OBJECT:
3026 case VT_STORAGE:
3027 case VT_STORED_OBJECT:
3028 IUnknown_AddRef((LPUNKNOWN)pvarDest->u.pStream);
3029 break;
3030 case VT_CLSID:
3031 pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
3032 *pvarDest->u.puuid = *pvarSrc->u.puuid;
3033 break;
3034 case VT_LPSTR:
3035 len = strlen(pvarSrc->u.pszVal);
3036 pvarDest->u.pszVal = CoTaskMemAlloc((len+1)*sizeof(CHAR));
3037 CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, (len+1)*sizeof(CHAR));
3038 break;
3039 case VT_LPWSTR:
3040 len = lstrlenW(pvarSrc->u.pwszVal);
3041 pvarDest->u.pwszVal = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
3042 CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, (len+1)*sizeof(WCHAR));
3043 break;
3044 case VT_BLOB:
3045 case VT_BLOB_OBJECT:
3046 if (pvarSrc->u.blob.pBlobData)
3047 {
3048 len = pvarSrc->u.blob.cbSize;
3049 pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
3050 CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
3051 }
3052 break;
3053 case VT_BSTR:
3054 pvarDest->u.bstrVal = PropSysAllocString(pvarSrc->u.bstrVal);
3055 break;
3056 case VT_CF:
3057 if (pvarSrc->u.pclipdata)
3058 {
3059 len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
3060 pvarDest->u.pclipdata = CoTaskMemAlloc(sizeof (CLIPDATA));
3061 pvarDest->u.pclipdata->cbSize = pvarSrc->u.pclipdata->cbSize;
3062 pvarDest->u.pclipdata->ulClipFmt = pvarSrc->u.pclipdata->ulClipFmt;
3063 pvarDest->u.pclipdata->pClipData = CoTaskMemAlloc(len);
3064 CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
3065 }
3066 break;
3067 default:
3068 if (pvarSrc->vt & VT_VECTOR)
3069 {
3070 int elemSize;
3071 ULONG i;
3072
3073 switch(pvarSrc->vt & ~VT_VECTOR)
3074 {
3075 case VT_I1: elemSize = sizeof(pvarSrc->u.cVal); break;
3076 case VT_UI1: elemSize = sizeof(pvarSrc->u.bVal); break;
3077 case VT_I2: elemSize = sizeof(pvarSrc->u.iVal); break;
3078 case VT_UI2: elemSize = sizeof(pvarSrc->u.uiVal); break;
3079 case VT_BOOL: elemSize = sizeof(pvarSrc->u.boolVal); break;
3080 case VT_I4: elemSize = sizeof(pvarSrc->u.lVal); break;
3081 case VT_UI4: elemSize = sizeof(pvarSrc->u.ulVal); break;
3082 case VT_R4: elemSize = sizeof(pvarSrc->u.fltVal); break;
3083 case VT_R8: elemSize = sizeof(pvarSrc->u.dblVal); break;
3084 case VT_ERROR: elemSize = sizeof(pvarSrc->u.scode); break;
3085 case VT_I8: elemSize = sizeof(pvarSrc->u.hVal); break;
3086 case VT_UI8: elemSize = sizeof(pvarSrc->u.uhVal); break;
3087 case VT_CY: elemSize = sizeof(pvarSrc->u.cyVal); break;
3088 case VT_DATE: elemSize = sizeof(pvarSrc->u.date); break;
3089 case VT_FILETIME: elemSize = sizeof(pvarSrc->u.filetime); break;
3090 case VT_CLSID: elemSize = sizeof(*pvarSrc->u.puuid); break;
3091 case VT_CF: elemSize = sizeof(*pvarSrc->u.pclipdata); break;
3092 case VT_BSTR: elemSize = sizeof(pvarSrc->u.bstrVal); break;
3093 case VT_LPSTR: elemSize = sizeof(pvarSrc->u.pszVal); break;
3094 case VT_LPWSTR: elemSize = sizeof(pvarSrc->u.pwszVal); break;
3095 case VT_VARIANT: elemSize = sizeof(*pvarSrc->u.pvarVal); break;
3096
3097 default:
3098 FIXME("Invalid element type: %ul\n", pvarSrc->vt & ~VT_VECTOR);
3099 return E_INVALIDARG;
3100 }
3101 len = pvarSrc->u.capropvar.cElems;
3102 pvarDest->u.capropvar.pElems = CoTaskMemAlloc(len * elemSize);
3103 if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
3104 {
3105 for (i = 0; i < len; i++)
3106 PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
3107 }
3108 else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
3109 {
3110 FIXME("Copy clipformats\n");
3111 }
3112 else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
3113 {
3114 for (i = 0; i < len; i++)
3115 pvarDest->u.cabstr.pElems[i] = PropSysAllocString(pvarSrc->u.cabstr.pElems[i]);
3116 }
3117 else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
3118 {
3119 size_t strLen;
3120 for (i = 0; i < len; i++)
3121 {
3122 strLen = lstrlenA(pvarSrc->u.calpstr.pElems[i]) + 1;
3123 pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
3124 memcpy(pvarDest->u.calpstr.pElems[i],
3125 pvarSrc->u.calpstr.pElems[i], strLen);
3126 }
3127 }
3128 else if (pvarSrc->vt == (VT_VECTOR | VT_LPWSTR))
3129 {
3130 size_t strLen;
3131 for (i = 0; i < len; i++)
3132 {
3133 strLen = (lstrlenW(pvarSrc->u.calpwstr.pElems[i]) + 1) *
3134 sizeof(WCHAR);
3135 pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
3136 memcpy(pvarDest->u.calpstr.pElems[i],
3137 pvarSrc->u.calpstr.pElems[i], strLen);
3138 }
3139 }
3140 else
3141 CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
3142 }
3143 else
3144 WARN("Invalid/unsupported type %d\n", pvarSrc->vt);
3145 }
3146
3147 return S_OK;
3148 }
3149
3150 /***********************************************************************
3151 * FreePropVariantArray [OLE32.@]
3152 */
3153 HRESULT WINAPI FreePropVariantArray(ULONG cVariants, /* [in] */
3154 PROPVARIANT *rgvars) /* [in/out] */
3155 {
3156 ULONG i;
3157
3158 TRACE("(%u, %p)\n", cVariants, rgvars);
3159
3160 if (!rgvars)
3161 return E_INVALIDARG;
3162
3163 for(i = 0; i < cVariants; i++)
3164 PropVariantClear(&rgvars[i]);
3165
3166 return S_OK;
3167 }
3168
3169 /******************************************************************************
3170 * DllDebugObjectRPCHook (OLE32.@)
3171 * turns on and off internal debugging, pointer is only used on macintosh
3172 */
3173
3174 BOOL WINAPI DllDebugObjectRPCHook(BOOL b, void *dummy)
3175 {
3176 FIXME("stub\n");
3177 return TRUE;
3178 }
Maarten's multimedia branch