1 /*
2 * OLEAUT32
3 *
4 * Copyright 1999, 2000 Marcus Meissner
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22 #include <string.h>
23 #include <limits.h>
24
25 #define COBJMACROS
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "winerror.h"
32
33 #include "ole2.h"
34 #include "olectl.h"
35 #include "oleauto.h"
36 #include "typelib.h"
37
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
41
42 static BOOL BSTR_bCache = TRUE; /* Cache allocations to minimise alloc calls? */
43
44 HMODULE OLEAUT32_hModule = NULL;
45
46 /******************************************************************************
47 * BSTR {OLEAUT32}
48 *
49 * NOTES
50 * BSTR is a simple typedef for a wide-character string used as the principle
51 * string type in ole automation. When encapsulated in a Variant type they are
52 * automatically copied and destroyed as the variant is processed.
53 *
54 * The low level BSTR Api allows manipulation of these strings and is used by
55 * higher level Api calls to manage the strings transparently to the caller.
56 *
57 * Internally the BSTR type is allocated with space for a DWORD byte count before
58 * the string data begins. This is undocumented and non-system code should not
59 * access the count directly. Use SysStringLen() or SysStringByteLen()
60 * instead. Note that the byte count does not include the terminating NUL.
61 *
62 * To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
63 * SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
64 * or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
65 *
66 * BSTR's are cached by Ole Automation by default. To override this behaviour
67 * either set the environment variable 'OANOCACHE', or call SetOaNoCache().
68 *
69 * SEE ALSO
70 * 'Inside OLE, second edition' by Kraig Brockshmidt.
71 */
72
73 /******************************************************************************
74 * SysStringLen [OLEAUT32.7]
75 *
76 * Get the allocated length of a BSTR in wide characters.
77 *
78 * PARAMS
79 * str [I] BSTR to find the length of
80 *
81 * RETURNS
82 * The allocated length of str, or 0 if str is NULL.
83 *
84 * NOTES
85 * See BSTR.
86 * The returned length may be different from the length of the string as
87 * calculated by lstrlenW(), since it returns the length that was used to
88 * allocate the string by SysAllocStringLen().
89 */
90 UINT WINAPI SysStringLen(BSTR str)
91 {
92 DWORD* bufferPointer;
93
94 if (!str) return 0;
95 /*
96 * The length of the string (in bytes) is contained in a DWORD placed
97 * just before the BSTR pointer
98 */
99 bufferPointer = (DWORD*)str;
100
101 bufferPointer--;
102
103 return (int)(*bufferPointer/sizeof(WCHAR));
104 }
105
106 /******************************************************************************
107 * SysStringByteLen [OLEAUT32.149]
108 *
109 * Get the allocated length of a BSTR in bytes.
110 *
111 * PARAMS
112 * str [I] BSTR to find the length of
113 *
114 * RETURNS
115 * The allocated length of str, or 0 if str is NULL.
116 *
117 * NOTES
118 * See SysStringLen(), BSTR().
119 */
120 UINT WINAPI SysStringByteLen(BSTR str)
121 {
122 DWORD* bufferPointer;
123
124 if (!str) return 0;
125 /*
126 * The length of the string (in bytes) is contained in a DWORD placed
127 * just before the BSTR pointer
128 */
129 bufferPointer = (DWORD*)str;
130
131 bufferPointer--;
132
133 return (int)(*bufferPointer);
134 }
135
136 /******************************************************************************
137 * SysAllocString [OLEAUT32.2]
138 *
139 * Create a BSTR from an OLESTR.
140 *
141 * PARAMS
142 * str [I] Source to create BSTR from
143 *
144 * RETURNS
145 * Success: A BSTR allocated with SysAllocStringLen().
146 * Failure: NULL, if oleStr is NULL.
147 *
148 * NOTES
149 * See BSTR.
150 * MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
151 * a length of 0. Native Win32 and this implementation both return a valid
152 * empty BSTR in this case.
153 */
154 BSTR WINAPI SysAllocString(LPCOLESTR str)
155 {
156 if (!str) return 0;
157
158 /* Delegate this to the SysAllocStringLen32 method. */
159 return SysAllocStringLen(str, lstrlenW(str));
160 }
161
162 /******************************************************************************
163 * SysFreeString [OLEAUT32.6]
164 *
165 * Free a BSTR.
166 *
167 * PARAMS
168 * str [I] BSTR to free.
169 *
170 * RETURNS
171 * Nothing.
172 *
173 * NOTES
174 * See BSTR.
175 * str may be NULL, in which case this function does nothing.
176 */
177 void WINAPI SysFreeString(BSTR str)
178 {
179 DWORD* bufferPointer;
180
181 /* NULL is a valid parameter */
182 if(!str) return;
183
184 /*
185 * We have to be careful when we free a BSTR pointer, it points to
186 * the beginning of the string but it skips the byte count contained
187 * before the string.
188 */
189 bufferPointer = (DWORD*)str;
190
191 bufferPointer--;
192
193 /*
194 * Free the memory from its "real" origin.
195 */
196 HeapFree(GetProcessHeap(), 0, bufferPointer);
197 }
198
199 /******************************************************************************
200 * SysAllocStringLen [OLEAUT32.4]
201 *
202 * Create a BSTR from an OLESTR of a given wide character length.
203 *
204 * PARAMS
205 * str [I] Source to create BSTR from
206 * len [I] Length of oleStr in wide characters
207 *
208 * RETURNS
209 * Success: A newly allocated BSTR from SysAllocStringByteLen()
210 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
211 *
212 * NOTES
213 * See BSTR(), SysAllocStringByteLen().
214 */
215 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
216 {
217 DWORD bufferSize;
218 DWORD* newBuffer;
219 WCHAR* stringBuffer;
220
221 /* Detect integer overflow. */
222 if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
223 return NULL;
224 /*
225 * Find the length of the buffer passed-in, in bytes.
226 */
227 bufferSize = len * sizeof (WCHAR);
228
229 /*
230 * Allocate a new buffer to hold the string.
231 * don't forget to keep an empty spot at the beginning of the
232 * buffer for the character count and an extra character at the
233 * end for the NULL.
234 */
235 newBuffer = HeapAlloc(GetProcessHeap(), 0,
236 bufferSize + sizeof(WCHAR) + sizeof(DWORD));
237
238 /*
239 * If the memory allocation failed, return a null pointer.
240 */
241 if (!newBuffer)
242 return NULL;
243
244 /*
245 * Copy the length of the string in the placeholder.
246 */
247 *newBuffer = bufferSize;
248
249 /*
250 * Skip the byte count.
251 */
252 newBuffer++;
253
254 /*
255 * Copy the information in the buffer.
256 * Since it is valid to pass a NULL pointer here, we'll initialize the
257 * buffer to nul if it is the case.
258 */
259 if (str != 0)
260 memcpy(newBuffer, str, bufferSize);
261 else
262 memset(newBuffer, 0, bufferSize);
263
264 /*
265 * Make sure that there is a nul character at the end of the
266 * string.
267 */
268 stringBuffer = (WCHAR*)newBuffer;
269 stringBuffer[len] = '\0';
270
271 return (LPWSTR)stringBuffer;
272 }
273
274 /******************************************************************************
275 * SysReAllocStringLen [OLEAUT32.5]
276 *
277 * Change the length of a previously created BSTR.
278 *
279 * PARAMS
280 * old [O] BSTR to change the length of
281 * str [I] New source for pbstr
282 * len [I] Length of oleStr in wide characters
283 *
284 * RETURNS
285 * Success: 1. The size of pbstr is updated.
286 * Failure: 0, if len >= 0x80000000 or memory allocation fails.
287 *
288 * NOTES
289 * See BSTR(), SysAllocStringByteLen().
290 * *old may be changed by this function.
291 */
292 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
293 {
294 /* Detect integer overflow. */
295 if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
296 return 0;
297
298 if (*old!=NULL) {
299 DWORD newbytelen = len*sizeof(WCHAR);
300 DWORD *ptr = HeapReAlloc(GetProcessHeap(),0,((DWORD*)*old)-1,newbytelen+sizeof(WCHAR)+sizeof(DWORD));
301 *old = (BSTR)(ptr+1);
302 *ptr = newbytelen;
303 if (str) {
304 memmove(*old, str, newbytelen);
305 (*old)[len] = 0;
306 } else {
307 /* Subtle hidden feature: The old string data is still there
308 * when 'in' is NULL!
309 * Some Microsoft program needs it.
310 */
311 }
312 } else {
313 /*
314 * Allocate the new string
315 */
316 *old = SysAllocStringLen(str, len);
317 }
318
319 return 1;
320 }
321
322 /******************************************************************************
323 * SysAllocStringByteLen [OLEAUT32.150]
324 *
325 * Create a BSTR from an OLESTR of a given byte length.
326 *
327 * PARAMS
328 * str [I] Source to create BSTR from
329 * len [I] Length of oleStr in bytes
330 *
331 * RETURNS
332 * Success: A newly allocated BSTR
333 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
334 *
335 * NOTES
336 * -If len is 0 or oleStr is NULL the resulting string is empty ("").
337 * -This function always NUL terminates the resulting BSTR.
338 * -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
339 * without checking for a terminating NUL.
340 * See BSTR.
341 */
342 BSTR WINAPI SysAllocStringByteLen(LPCSTR str, UINT len)
343 {
344 DWORD* newBuffer;
345 char* stringBuffer;
346
347 /* Detect integer overflow. */
348 if (len >= (UINT_MAX-sizeof(WCHAR)-sizeof(DWORD)))
349 return NULL;
350
351 /*
352 * Allocate a new buffer to hold the string.
353 * don't forget to keep an empty spot at the beginning of the
354 * buffer for the character count and an extra character at the
355 * end for the NULL.
356 */
357 newBuffer = HeapAlloc(GetProcessHeap(), 0,
358 len + sizeof(WCHAR) + sizeof(DWORD));
359
360 /*
361 * If the memory allocation failed, return a null pointer.
362 */
363 if (newBuffer==0)
364 return 0;
365
366 /*
367 * Copy the length of the string in the placeholder.
368 */
369 *newBuffer = len;
370
371 /*
372 * Skip the byte count.
373 */
374 newBuffer++;
375
376 /*
377 * Copy the information in the buffer.
378 * Since it is valid to pass a NULL pointer here, we'll initialize the
379 * buffer to nul if it is the case.
380 */
381 if (str != 0)
382 memcpy(newBuffer, str, len);
383
384 /*
385 * Make sure that there is a nul character at the end of the
386 * string.
387 */
388 stringBuffer = (char *)newBuffer;
389 stringBuffer[len] = 0;
390 stringBuffer[len+1] = 0;
391
392 return (LPWSTR)stringBuffer;
393 }
394
395 /******************************************************************************
396 * SysReAllocString [OLEAUT32.3]
397 *
398 * Change the length of a previously created BSTR.
399 *
400 * PARAMS
401 * old [I/O] BSTR to change the length of
402 * str [I] New source for pbstr
403 *
404 * RETURNS
405 * Success: 1
406 * Failure: 0.
407 *
408 * NOTES
409 * See BSTR(), SysAllocStringStringLen().
410 */
411 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
412 {
413 /*
414 * Sanity check
415 */
416 if (old==NULL)
417 return 0;
418
419 /*
420 * Make sure we free the old string.
421 */
422 if (*old!=NULL)
423 SysFreeString(*old);
424
425 /*
426 * Allocate the new string
427 */
428 *old = SysAllocString(str);
429
430 return 1;
431 }
432
433 /******************************************************************************
434 * SetOaNoCache (OLEAUT32.327)
435 *
436 * Instruct Ole Automation not to cache BSTR allocations.
437 *
438 * PARAMS
439 * None.
440 *
441 * RETURNS
442 * Nothing.
443 *
444 * NOTES
445 * See BSTR.
446 */
447 void WINAPI SetOaNoCache(void)
448 {
449 BSTR_bCache = FALSE;
450 }
451
452 static const WCHAR _delimiter[2] = {'!',0}; /* default delimiter apparently */
453 static const WCHAR *pdelimiter = &_delimiter[0];
454
455 /***********************************************************************
456 * RegisterActiveObject (OLEAUT32.33)
457 *
458 * Registers an object in the global item table.
459 *
460 * PARAMS
461 * punk [I] Object to register.
462 * rcid [I] CLSID of the object.
463 * dwFlags [I] Flags.
464 * pdwRegister [O] Address to store cookie of object registration in.
465 *
466 * RETURNS
467 * Success: S_OK.
468 * Failure: HRESULT code.
469 */
470 HRESULT WINAPI RegisterActiveObject(
471 LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
472 ) {
473 WCHAR guidbuf[80];
474 HRESULT ret;
475 LPRUNNINGOBJECTTABLE runobtable;
476 LPMONIKER moniker;
477
478 StringFromGUID2(rcid,guidbuf,39);
479 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
480 if (FAILED(ret))
481 return ret;
482 ret = GetRunningObjectTable(0,&runobtable);
483 if (FAILED(ret)) {
484 IMoniker_Release(moniker);
485 return ret;
486 }
487 ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
488 IRunningObjectTable_Release(runobtable);
489 IMoniker_Release(moniker);
490 return ret;
491 }
492
493 /***********************************************************************
494 * RevokeActiveObject (OLEAUT32.34)
495 *
496 * Revokes an object from the global item table.
497 *
498 * PARAMS
499 * xregister [I] Registration cookie.
500 * reserved [I] Reserved. Set to NULL.
501 *
502 * RETURNS
503 * Success: S_OK.
504 * Failure: HRESULT code.
505 */
506 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
507 {
508 LPRUNNINGOBJECTTABLE runobtable;
509 HRESULT ret;
510
511 ret = GetRunningObjectTable(0,&runobtable);
512 if (FAILED(ret)) return ret;
513 ret = IRunningObjectTable_Revoke(runobtable,xregister);
514 if (SUCCEEDED(ret)) ret = S_OK;
515 IRunningObjectTable_Release(runobtable);
516 return ret;
517 }
518
519 /***********************************************************************
520 * GetActiveObject (OLEAUT32.35)
521 *
522 * Gets an object from the global item table.
523 *
524 * PARAMS
525 * rcid [I] CLSID of the object.
526 * preserved [I] Reserved. Set to NULL.
527 * ppunk [O] Address to store object into.
528 *
529 * RETURNS
530 * Success: S_OK.
531 * Failure: HRESULT code.
532 */
533 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
534 {
535 WCHAR guidbuf[80];
536 HRESULT ret;
537 LPRUNNINGOBJECTTABLE runobtable;
538 LPMONIKER moniker;
539
540 StringFromGUID2(rcid,guidbuf,39);
541 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
542 if (FAILED(ret))
543 return ret;
544 ret = GetRunningObjectTable(0,&runobtable);
545 if (FAILED(ret)) {
546 IMoniker_Release(moniker);
547 return ret;
548 }
549 ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
550 IRunningObjectTable_Release(runobtable);
551 IMoniker_Release(moniker);
552 return ret;
553 }
554
555
556 /***********************************************************************
557 * OaBuildVersion [OLEAUT32.170]
558 *
559 * Get the Ole Automation build version.
560 *
561 * PARAMS
562 * None
563 *
564 * RETURNS
565 * The build version.
566 *
567 * NOTES
568 * Known oleaut32.dll versions:
569 *| OLE Ver. Comments Date Build Ver.
570 *| -------- ------------------------- ---- ---------
571 *| OLE 2.1 NT 1993-95 10 3023
572 *| OLE 2.1 10 3027
573 *| Win32s Ver 1.1e 20 4049
574 *| OLE 2.20 W95/NT 1993-96 20 4112
575 *| OLE 2.20 W95/NT 1993-96 20 4118
576 *| OLE 2.20 W95/NT 1993-96 20 4122
577 *| OLE 2.30 W95/NT 1993-98 30 4265
578 *| OLE 2.40 NT?? 1993-98 40 4267
579 *| OLE 2.40 W98 SE orig. file 1993-98 40 4275
580 *| OLE 2.40 W2K orig. file 1993-XX 40 4514
581 *
582 * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
583 * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
584 */
585 ULONG WINAPI OaBuildVersion(void)
586 {
587 switch(GetVersion() & 0x8000ffff) /* mask off build number */
588 {
589 case 0x80000a03: /* WIN31 */
590 return MAKELONG(0xffff, 20);
591 case 0x00003303: /* NT351 */
592 return MAKELONG(0xffff, 30);
593 case 0x80000004: /* WIN95; I'd like to use the "standard" w95 minor
594 version here (30), but as we still use w95
595 as default winver (which is good IMHO), I better
596 play safe and use the latest value for w95 for now.
597 Change this as soon as default winver gets changed
598 to something more recent */
599 case 0x80000a04: /* WIN98 */
600 case 0x00000004: /* NT40 */
601 case 0x00000005: /* W2K */
602 case 0x00000105: /* WinXP */
603 return MAKELONG(0xffff, 40);
604 default:
605 FIXME("Version value not known yet. Please investigate it !\n");
606 return MAKELONG(0xffff, 40); /* for now return the same value as for w2k */
607 }
608 }
609
610 /******************************************************************************
611 * OleTranslateColor [OLEAUT32.421]
612 *
613 * Convert an OLE_COLOR to a COLORREF.
614 *
615 * PARAMS
616 * clr [I] Color to convert
617 * hpal [I] Handle to a palette for the conversion
618 * pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
619 *
620 * RETURNS
621 * Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
622 * Failure: E_INVALIDARG, if any argument is invalid.
623 *
624 * FIXME
625 * Document the conversion rules.
626 */
627 HRESULT WINAPI OleTranslateColor(
628 OLE_COLOR clr,
629 HPALETTE hpal,
630 COLORREF* pColorRef)
631 {
632 COLORREF colorref;
633 BYTE b = HIBYTE(HIWORD(clr));
634
635 TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);
636
637 /*
638 * In case pColorRef is NULL, provide our own to simplify the code.
639 */
640 if (pColorRef == NULL)
641 pColorRef = &colorref;
642
643 switch (b)
644 {
645 case 0x00:
646 {
647 if (hpal != 0)
648 *pColorRef = PALETTERGB(GetRValue(clr),
649 GetGValue(clr),
650 GetBValue(clr));
651 else
652 *pColorRef = clr;
653
654 break;
655 }
656
657 case 0x01:
658 {
659 if (hpal != 0)
660 {
661 PALETTEENTRY pe;
662 /*
663 * Validate the palette index.
664 */
665 if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
666 return E_INVALIDARG;
667 }
668
669 *pColorRef = clr;
670
671 break;
672 }
673
674 case 0x02:
675 *pColorRef = clr;
676 break;
677
678 case 0x80:
679 {
680 int index = LOBYTE(LOWORD(clr));
681
682 /*
683 * Validate GetSysColor index.
684 */
685 if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
686 return E_INVALIDARG;
687
688 *pColorRef = GetSysColor(index);
689
690 break;
691 }
692
693 default:
694 return E_INVALIDARG;
695 }
696
697 return S_OK;
698 }
699
700 extern HRESULT OLEAUTPS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv);
701
702 extern void _get_STDFONT_CF(LPVOID *);
703 extern void _get_STDPIC_CF(LPVOID *);
704
705 static HRESULT WINAPI PSDispatchFacBuf_QueryInterface(IPSFactoryBuffer *iface, REFIID riid, void **ppv)
706 {
707 if (IsEqualIID(riid, &IID_IUnknown) ||
708 IsEqualIID(riid, &IID_IPSFactoryBuffer))
709 {
710 IUnknown_AddRef(iface);
711 *ppv = (void *)iface;
712 return S_OK;
713 }
714 return E_NOINTERFACE;
715 }
716
717 static ULONG WINAPI PSDispatchFacBuf_AddRef(IPSFactoryBuffer *iface)
718 {
719 return 2;
720 }
721
722 static ULONG WINAPI PSDispatchFacBuf_Release(IPSFactoryBuffer *iface)
723 {
724 return 1;
725 }
726
727 static HRESULT WINAPI PSDispatchFacBuf_CreateProxy(IPSFactoryBuffer *iface, IUnknown *pUnkOuter, REFIID riid, IRpcProxyBuffer **ppProxy, void **ppv)
728 {
729 IPSFactoryBuffer *pPSFB;
730 HRESULT hr;
731
732 if (IsEqualIID(riid, &IID_IDispatch))
733 hr = OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, &IID_IPSFactoryBuffer, (void **)&pPSFB);
734 else
735 hr = TMARSHAL_DllGetClassObject(&CLSID_PSOAInterface, &IID_IPSFactoryBuffer, (void **)&pPSFB);
736
737 if (FAILED(hr)) return hr;
738
739 hr = IPSFactoryBuffer_CreateProxy(pPSFB, pUnkOuter, riid, ppProxy, ppv);
740
741 IPSFactoryBuffer_Release(pPSFB);
742 return hr;
743 }
744
745 static HRESULT WINAPI PSDispatchFacBuf_CreateStub(IPSFactoryBuffer *iface, REFIID riid, IUnknown *pUnkOuter, IRpcStubBuffer **ppStub)
746 {
747 IPSFactoryBuffer *pPSFB;
748 HRESULT hr;
749
750 if (IsEqualIID(riid, &IID_IDispatch))
751 hr = OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, &IID_IPSFactoryBuffer, (void **)&pPSFB);
752 else
753 hr = TMARSHAL_DllGetClassObject(&CLSID_PSOAInterface, &IID_IPSFactoryBuffer, (void **)&pPSFB);
754
755 if (FAILED(hr)) return hr;
756
757 hr = IPSFactoryBuffer_CreateStub(pPSFB, riid, pUnkOuter, ppStub);
758
759 IPSFactoryBuffer_Release(pPSFB);
760 return hr;
761 }
762
763 static const IPSFactoryBufferVtbl PSDispatchFacBuf_Vtbl =
764 {
765 PSDispatchFacBuf_QueryInterface,
766 PSDispatchFacBuf_AddRef,
767 PSDispatchFacBuf_Release,
768 PSDispatchFacBuf_CreateProxy,
769 PSDispatchFacBuf_CreateStub
770 };
771
772 /* This is the whole PSFactoryBuffer object, just the vtableptr */
773 static const IPSFactoryBufferVtbl *pPSDispatchFacBuf = &PSDispatchFacBuf_Vtbl;
774
775 /***********************************************************************
776 * DllGetClassObject (OLEAUT32.@)
777 */
778 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
779 {
780 *ppv = NULL;
781 if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
782 if (IsEqualGUID(iid,&IID_IClassFactory)) {
783 _get_STDFONT_CF(ppv);
784 IClassFactory_AddRef((IClassFactory*)*ppv);
785 return S_OK;
786 }
787 }
788 if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
789 if (IsEqualGUID(iid,&IID_IClassFactory)) {
790 _get_STDPIC_CF(ppv);
791 IClassFactory_AddRef((IClassFactory*)*ppv);
792 return S_OK;
793 }
794 }
795 if (IsEqualCLSID(rclsid, &CLSID_PSTypeInfo) ||
796 IsEqualCLSID(rclsid, &CLSID_PSTypeLib) ||
797 IsEqualCLSID(rclsid, &CLSID_PSEnumVariant)) {
798 return OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, iid, ppv);
799 }
800 if (IsEqualCLSID(rclsid, &CLSID_PSDispatch) && IsEqualIID(iid, &IID_IPSFactoryBuffer)) {
801 *ppv = &pPSDispatchFacBuf;
802 IPSFactoryBuffer_AddRef((IPSFactoryBuffer *)*ppv);
803 return S_OK;
804 }
805 if (IsEqualGUID(rclsid,&CLSID_PSOAInterface)) {
806 if (S_OK==TMARSHAL_DllGetClassObject(rclsid,iid,ppv))
807 return S_OK;
808 /*FALLTHROUGH*/
809 }
810 return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
811 }
812
813 /***********************************************************************
814 * DllCanUnloadNow (OLEAUT32.@)
815 *
816 * Determine if this dll can be unloaded from the callers address space.
817 *
818 * PARAMS
819 * None.
820 *
821 * RETURNS
822 * Always returns S_FALSE. This dll cannot be unloaded.
823 */
824 HRESULT WINAPI DllCanUnloadNow(void)
825 {
826 return S_FALSE;
827 }
828
829 /*****************************************************************************
830 * DllMain [OLEAUT32.@]
831 */
832 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
833 {
834 TRACE("(%p,%d,%p)\n", hInstDll, fdwReason, lpvReserved);
835
836 switch (fdwReason) {
837 case DLL_PROCESS_ATTACH:
838 DisableThreadLibraryCalls(hInstDll);
839 OLEAUT32_hModule = hInstDll;
840 break;
841 case DLL_PROCESS_DETACH:
842 break;
843 };
844
845 return TRUE;
846 }
847
848 /***********************************************************************
849 * OleIconToCursor (OLEAUT32.415)
850 */
851 HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
852 {
853 FIXME("(%p,%p), partially implemented.\n",hinstExe,hIcon);
854 /* FIXME: make a extended conversation from HICON to HCURSOR */
855 return CopyCursor(hIcon);
856 }
857
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.