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