[SHELL32]
[reactos.git] / reactos / lib / atl / atlbase.h
1 /*
2 * ReactOS ATL
3 *
4 * Copyright 2009 Andrew Hill <ash77@reactos.org>
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 Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #pragma once
22
23 #include "atlcore.h"
24 #include "statreg.h"
25
26 #ifdef _MSC_VER
27 // It is common to use this in ATL constructors. They only store this for later use, so the usage is safe.
28 #pragma warning(disable:4355)
29 #endif
30
31 #ifndef _ATL_PACKING
32 #define _ATL_PACKING 8
33 #endif
34
35 #ifndef _ATL_FREE_THREADED
36 #ifndef _ATL_APARTMENT_THREADED
37 #ifndef _ATL_SINGLE_THREADED
38 #define _ATL_FREE_THREADED
39 #endif
40 #endif
41 #endif
42
43 #ifndef ATLTRY
44 #define ATLTRY(x) x;
45 #endif
46
47 #ifdef _ATL_DISABLE_NO_VTABLE
48 #define ATL_NO_VTABLE
49 #else
50 #define ATL_NO_VTABLE __declspec(novtable)
51 #endif
52
53 #define offsetofclass(base, derived) (reinterpret_cast<DWORD_PTR>(static_cast<base *>(reinterpret_cast<derived *>(_ATL_PACKING))) - _ATL_PACKING)
54
55 namespace ATL
56 {
57
58 class CAtlModule;
59 class CComModule;
60 class CAtlComModule;
61 __declspec(selectany) CAtlModule *_pAtlModule = NULL;
62 __declspec(selectany) CComModule *_pModule = NULL;
63 extern CAtlComModule _AtlComModule;
64
65 typedef HRESULT (WINAPI _ATL_CREATORFUNC)(void *pv, REFIID riid, LPVOID *ppv);
66 typedef LPCTSTR (WINAPI _ATL_DESCRIPTIONFUNC)();
67 typedef const struct _ATL_CATMAP_ENTRY * (_ATL_CATMAPFUNC)();
68
69 struct _ATL_OBJMAP_ENTRY30
70 {
71 const CLSID *pclsid;
72 HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister);
73 _ATL_CREATORFUNC *pfnGetClassObject;
74 _ATL_CREATORFUNC *pfnCreateInstance;
75 IUnknown *pCF;
76 DWORD dwRegister;
77 _ATL_DESCRIPTIONFUNC *pfnGetObjectDescription;
78 _ATL_CATMAPFUNC *pfnGetCategoryMap;
79 void (WINAPI *pfnObjectMain)(bool bStarting);
80
81 HRESULT WINAPI RevokeClassObject()
82 {
83 if (dwRegister == 0)
84 return S_OK;
85 return CoRevokeClassObject(dwRegister);
86 }
87
88 HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
89 {
90 IUnknown *p;
91 HRESULT hResult;
92
93 p = NULL;
94 if (pfnGetClassObject == NULL)
95 return S_OK;
96
97 hResult = pfnGetClassObject(reinterpret_cast<LPVOID *>(pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&p));
98 if (SUCCEEDED(hResult))
99 hResult = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
100
101 if (p != NULL)
102 p->Release();
103
104 return hResult;
105 }
106 };
107
108 typedef _ATL_OBJMAP_ENTRY30 _ATL_OBJMAP_ENTRY;
109
110 typedef void (__stdcall _ATL_TERMFUNC)(DWORD_PTR dw);
111
112 struct _ATL_TERMFUNC_ELEM
113 {
114 _ATL_TERMFUNC *pFunc;
115 DWORD_PTR dw;
116 _ATL_TERMFUNC_ELEM *pNext;
117 };
118
119 struct _ATL_MODULE70
120 {
121 UINT cbSize;
122 LONG m_nLockCnt;
123 _ATL_TERMFUNC_ELEM *m_pTermFuncs;
124 CComCriticalSection m_csStaticDataInitAndTypeInfo;
125 };
126 typedef _ATL_MODULE70 _ATL_MODULE;
127
128 typedef HRESULT (WINAPI _ATL_CREATORARGFUNC)(void *pv, REFIID riid, LPVOID *ppv, DWORD_PTR dw);
129
130 #define _ATL_SIMPLEMAPENTRY ((ATL::_ATL_CREATORARGFUNC *)1)
131
132 struct _ATL_INTMAP_ENTRY
133 {
134 const IID *piid;
135 DWORD_PTR dw;
136 _ATL_CREATORARGFUNC *pFunc;
137 };
138
139 struct _AtlCreateWndData
140 {
141 void *m_pThis;
142 DWORD m_dwThreadID;
143 _AtlCreateWndData *m_pNext;
144 };
145
146 struct _ATL_COM_MODULE70
147 {
148 UINT cbSize;
149 HINSTANCE m_hInstTypeLib;
150 _ATL_OBJMAP_ENTRY **m_ppAutoObjMapFirst;
151 _ATL_OBJMAP_ENTRY **m_ppAutoObjMapLast;
152 CComCriticalSection m_csObjMap;
153 };
154 typedef _ATL_COM_MODULE70 _ATL_COM_MODULE;
155
156 struct _ATL_WIN_MODULE70
157 {
158 UINT cbSize;
159 CComCriticalSection m_csWindowCreate;
160 _AtlCreateWndData *m_pCreateWndList;
161 #ifdef NOTYET
162 CSimpleArray<ATOM> m_rgWindowClassAtoms;
163 #endif
164 };
165 typedef _ATL_WIN_MODULE70 _ATL_WIN_MODULE;
166
167 struct _ATL_REGMAP_ENTRY
168 {
169 LPCOLESTR szKey;
170 LPCOLESTR szData;
171 };
172
173 HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule);
174 HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst);
175 HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject);
176 void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject);
177 void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule);
178 HRESULT __stdcall AtlComModuleGetClassObject(_ATL_COM_MODULE *pComModule, REFCLSID rclsid, REFIID riid, LPVOID *ppv);
179
180 template<class TLock>
181 class CComCritSecLock
182 {
183 private:
184 bool m_bLocked;
185 TLock &m_cs;
186 public:
187 CComCritSecLock(TLock &cs, bool bInitialLock = true) : m_cs(cs)
188 {
189 HRESULT hResult;
190
191 m_bLocked = false;
192 if (bInitialLock)
193 {
194 hResult = Lock();
195 if (FAILED(hResult))
196 {
197 ATLASSERT(false);
198 }
199 }
200 }
201
202 ~CComCritSecLock()
203 {
204 if (m_bLocked)
205 Unlock();
206 }
207
208 HRESULT Lock()
209 {
210 HRESULT hResult;
211
212 ATLASSERT(!m_bLocked);
213 hResult = m_cs.Lock();
214 if (FAILED(hResult))
215 return hResult;
216 m_bLocked = true;
217
218 return S_OK;
219 }
220
221 void Unlock()
222 {
223 HRESULT hResult;
224
225 ATLASSERT(m_bLocked);
226 hResult = m_cs.Unlock();
227 if (FAILED(hResult))
228 {
229 ATLASSERT(false);
230 }
231 m_bLocked = false;
232 }
233 };
234
235 inline BOOL WINAPI InlineIsEqualUnknown(REFGUID rguid1)
236 {
237 return (
238 ((unsigned long *)&rguid1)[0] == 0 &&
239 ((unsigned long *)&rguid1)[1] == 0 &&
240 ((unsigned long *)&rguid1)[2] == 0x000000C0 &&
241 ((unsigned long *)&rguid1)[3] == 0x46000000);
242 }
243
244 class CComMultiThreadModelNoCS
245 {
246 public:
247 typedef CComFakeCriticalSection AutoCriticalSection;
248 typedef CComFakeCriticalSection CriticalSection;
249 typedef CComMultiThreadModelNoCS ThreadModelNoCS;
250 typedef CComFakeCriticalSection AutoDeleteCriticalSection;
251
252 static ULONG WINAPI Increment(LPLONG p)
253 {
254 return InterlockedIncrement(p);
255 }
256
257 static ULONG WINAPI Decrement(LPLONG p)
258 {
259 return InterlockedDecrement(p);
260 }
261 };
262
263 class CComMultiThreadModel
264 {
265 public:
266 typedef CComAutoCriticalSection AutoCriticalSection;
267 typedef CComCriticalSection CriticalSection;
268 typedef CComMultiThreadModelNoCS ThreadModelNoCS;
269 typedef CComAutoDeleteCriticalSection AutoDeleteCriticalSection;
270
271 static ULONG WINAPI Increment(LPLONG p)
272 {
273 return InterlockedIncrement(p);
274 }
275
276 static ULONG WINAPI Decrement(LPLONG p)
277 {
278 return InterlockedDecrement(p);
279 }
280 };
281
282 class CComSingleThreadModel
283 {
284 public:
285 typedef CComFakeCriticalSection AutoCriticalSection;
286 typedef CComFakeCriticalSection CriticalSection;
287 typedef CComSingleThreadModel ThreadModelNoCS;
288 typedef CComFakeCriticalSection AutoDeleteCriticalSection;
289
290 static ULONG WINAPI Increment(LPLONG p)
291 {
292 return ++*p;
293 }
294
295 static ULONG WINAPI Decrement(LPLONG p)
296 {
297 return --*p;
298 }
299 };
300
301 #if defined(_ATL_FREE_THREADED)
302
303 typedef CComMultiThreadModel CComObjectThreadModel;
304 typedef CComMultiThreadModel CComGlobalsThreadModel;
305
306 #elif defined(_ATL_APARTMENT_THREADED)
307
308 typedef CComSingleThreadModel CComObjectThreadModel;
309 typedef CComMultiThreadModel CComGlobalsThreadModel;
310
311 #elif defined(_ATL_SINGLE_THREADED)
312
313 typedef CComSingleThreadModel CComObjectThreadModel;
314 typedef CComSingleThreadModel CComGlobalsThreadModel;
315
316 #else
317 #error No threading model
318 #endif
319
320 class CAtlModule : public _ATL_MODULE
321 {
322 protected:
323 static GUID m_libid;
324 public:
325 CAtlModule()
326 {
327 ATLASSERT(_pAtlModule == NULL);
328 _pAtlModule = this;
329 cbSize = sizeof(_ATL_MODULE);
330 m_nLockCnt = 0;
331 }
332
333 virtual LONG GetLockCount()
334 {
335 return m_nLockCnt;
336 }
337
338 virtual LONG Lock()
339 {
340 return CComGlobalsThreadModel::Increment(&m_nLockCnt);
341 }
342
343 virtual LONG Unlock()
344 {
345 return CComGlobalsThreadModel::Decrement(&m_nLockCnt);
346 }
347
348 virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* /*pRegistrar*/) = 0;
349
350 HRESULT WINAPI UpdateRegistryFromResource(LPCTSTR lpszRes, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
351 {
352 CRegObject registrar;
353 TCHAR modulePath[MAX_PATH];
354 HRESULT hResult;
355
356 hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
357 if (FAILED(hResult))
358 return hResult;
359
360 if (bRegister != FALSE)
361 hResult = registrar.ResourceRegisterSz(modulePath, lpszRes, _T("REGISTRY"));
362 else
363 hResult = registrar.ResourceUnregisterSz(modulePath, lpszRes, _T("REGISTRY"));
364
365 return hResult;
366 }
367
368 HRESULT WINAPI UpdateRegistryFromResource(UINT nResID, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
369 {
370 CRegObject registrar;
371 TCHAR modulePath[MAX_PATH];
372 HRESULT hResult;
373
374 hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
375 if (FAILED(hResult))
376 return hResult;
377
378 if (bRegister != FALSE)
379 hResult = registrar.ResourceRegister(modulePath, nResID, _T("REGISTRY"));
380 else
381 hResult = registrar.ResourceRegister(modulePath, nResID, _T("REGISTRY"));
382
383 return hResult;
384 }
385
386 private:
387 HRESULT CommonInitRegistrar(CRegObject &registrar, TCHAR *modulePath, DWORD modulePathCount, struct _ATL_REGMAP_ENTRY *pMapEntries)
388 {
389 HINSTANCE hInstance;
390 DWORD dwFLen;
391 HRESULT hResult;
392
393 hInstance = _AtlBaseModule.GetModuleInstance();
394 dwFLen = GetModuleFileName(hInstance, modulePath, modulePathCount);
395 if (dwFLen == modulePathCount)
396 return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
397 else if (dwFLen == 0)
398 return HRESULT_FROM_WIN32(GetLastError());
399
400 if (pMapEntries != NULL)
401 {
402 while (pMapEntries->szKey != NULL)
403 {
404 ATLASSERT(pMapEntries->szData != NULL);
405 hResult = registrar.AddReplacement(pMapEntries->szKey, pMapEntries->szData);
406 if (FAILED(hResult))
407 return hResult;
408 pMapEntries++;
409 }
410 }
411
412 hResult = AddCommonRGSReplacements(&registrar);
413 if (FAILED(hResult))
414 return hResult;
415
416 hResult = registrar.AddReplacement(_T("Module"), modulePath);
417 if (FAILED(hResult))
418 return hResult;
419
420 hResult = registrar.AddReplacement(_T("Module_Raw"), modulePath);
421 if (FAILED(hResult))
422 return hResult;
423
424 return S_OK;
425 }
426 };
427
428 __declspec(selectany) GUID CAtlModule::m_libid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0} };
429
430 template <class T>
431 class CAtlModuleT : public CAtlModule
432 {
433 public:
434
435 virtual HRESULT AddCommonRGSReplacements(IRegistrarBase *pRegistrar)
436 {
437 return pRegistrar->AddReplacement(L"APPID", T::GetAppId());
438 }
439
440 static LPCOLESTR GetAppId()
441 {
442 return L"";
443 }
444 };
445
446 class CAtlComModule : public _ATL_COM_MODULE
447 {
448 public:
449 CAtlComModule()
450 {
451 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInstTypeLib);
452 m_ppAutoObjMapFirst = NULL;
453 m_ppAutoObjMapLast = NULL;
454 if (FAILED(m_csObjMap.Init()))
455 {
456 ATLASSERT(0);
457 CAtlBaseModule::m_bInitFailed = true;
458 return;
459 }
460 cbSize = sizeof(_ATL_COM_MODULE);
461 }
462
463 ~CAtlComModule()
464 {
465 Term();
466 }
467
468 void Term()
469 {
470 if (cbSize != 0)
471 {
472 ATLASSERT(m_ppAutoObjMapFirst == NULL);
473 ATLASSERT(m_ppAutoObjMapLast == NULL);
474 m_csObjMap.Term();
475 cbSize = 0;
476 }
477 }
478 };
479
480 template <class T>
481 class CAtlDllModuleT : public CAtlModuleT<T>
482 {
483 public:
484 CAtlDllModuleT()
485 {
486 }
487
488 HRESULT DllCanUnloadNow()
489 {
490 T *pThis;
491
492 pThis = static_cast<T *>(this);
493 if (pThis->GetLockCount() == 0)
494 return S_OK;
495 return S_FALSE;
496 }
497
498 HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
499 {
500 T *pThis;
501
502 pThis = static_cast<T *>(this);
503 return pThis->GetClassObject(rclsid, riid, ppv);
504 }
505
506 HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
507 {
508 T *pThis;
509 HRESULT hResult;
510
511 pThis = static_cast<T *>(this);
512 hResult = pThis->RegisterServer(bRegTypeLib);
513 return hResult;
514 }
515
516 HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
517 {
518 T *pThis;
519 HRESULT hResult;
520
521 pThis = static_cast<T *>(this);
522 hResult = pThis->UnregisterServer(bUnRegTypeLib);
523 return hResult;
524 }
525
526 HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
527 {
528 return AtlComModuleGetClassObject(&_AtlComModule, rclsid, riid, ppv);
529 }
530 };
531
532 class CComModule : public CAtlModuleT<CComModule>
533 {
534 public:
535 _ATL_OBJMAP_ENTRY *m_pObjMap;
536 public:
537 CComModule()
538 {
539 ATLASSERT(_pModule == NULL);
540 _pModule = this;
541 _pModule->m_pObjMap = NULL;
542 }
543
544 ~CComModule()
545 {
546 _pModule = NULL;
547 }
548
549 HRESULT Init(_ATL_OBJMAP_ENTRY *p, HINSTANCE /* h */, const GUID *plibid)
550 {
551 _ATL_OBJMAP_ENTRY *objectMapEntry;
552
553 if (plibid != NULL)
554 m_libid = *plibid;
555
556 if (p != reinterpret_cast<_ATL_OBJMAP_ENTRY *>(-1))
557 {
558 m_pObjMap = p;
559 if (p != NULL)
560 {
561 objectMapEntry = p;
562 while (objectMapEntry->pclsid != NULL)
563 {
564 objectMapEntry->pfnObjectMain(true);
565 objectMapEntry++;
566 }
567 }
568 }
569 return S_OK;
570 }
571
572 void Term()
573 {
574 _ATL_OBJMAP_ENTRY *objectMapEntry;
575
576 if (m_pObjMap != NULL)
577 {
578 objectMapEntry = m_pObjMap;
579 while (objectMapEntry->pclsid != NULL)
580 {
581 if (objectMapEntry->pCF != NULL)
582 objectMapEntry->pCF->Release();
583 objectMapEntry->pCF = NULL;
584 objectMapEntry->pfnObjectMain(false);
585 objectMapEntry++;
586 }
587 }
588 }
589
590 HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
591 {
592 _ATL_OBJMAP_ENTRY *objectMapEntry;
593 HRESULT hResult;
594
595 ATLASSERT(ppv != NULL);
596 if (ppv == NULL)
597 return E_POINTER;
598 hResult = S_OK;
599 if (m_pObjMap != NULL)
600 {
601 objectMapEntry = m_pObjMap;
602 while (objectMapEntry->pclsid != NULL)
603 {
604 if (objectMapEntry->pfnGetClassObject != NULL && InlineIsEqualGUID(rclsid, *objectMapEntry->pclsid) != FALSE)
605 {
606 if (objectMapEntry->pCF == NULL)
607 {
608 CComCritSecLock<CComCriticalSection> lock(_AtlComModule.m_csObjMap, true);
609
610 if (objectMapEntry->pCF == NULL)
611 hResult = objectMapEntry->pfnGetClassObject(reinterpret_cast<void *>(objectMapEntry->pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&objectMapEntry->pCF));
612 }
613 if (objectMapEntry->pCF != NULL)
614 hResult = objectMapEntry->pCF->QueryInterface(riid, ppv);
615 break;
616 }
617 objectMapEntry++;
618 }
619 }
620 return hResult;
621 }
622
623 HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
624 {
625 _ATL_OBJMAP_ENTRY *objectMapEntry;
626 HRESULT hResult;
627
628 hResult = S_OK;
629 objectMapEntry = m_pObjMap;
630 if (objectMapEntry != NULL)
631 {
632 while (objectMapEntry->pclsid != NULL)
633 {
634 if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
635 {
636 hResult = objectMapEntry->pfnUpdateRegistry(TRUE);
637 if (FAILED(hResult))
638 break;
639 }
640 objectMapEntry++;
641 }
642 }
643 return hResult;
644 }
645
646 HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
647 {
648 _ATL_OBJMAP_ENTRY *objectMapEntry;
649 HRESULT hResult;
650
651 hResult = S_OK;
652 objectMapEntry = m_pObjMap;
653 if (objectMapEntry != NULL)
654 {
655 while (objectMapEntry->pclsid != NULL)
656 {
657 if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
658 {
659 hResult = objectMapEntry->pfnUpdateRegistry(FALSE); //unregister
660 if (FAILED(hResult))
661 break;
662 }
663 objectMapEntry++;
664 }
665 }
666 return hResult;
667 }
668
669 HRESULT DllCanUnloadNow()
670 {
671 if (GetLockCount() == 0)
672 return S_OK;
673 return S_FALSE;
674 }
675
676 HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
677 {
678 return GetClassObject(rclsid, riid, ppv);
679 }
680
681 HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
682 {
683 return RegisterServer(bRegTypeLib);
684 }
685
686 HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
687 {
688 return UnregisterServer(bUnRegTypeLib);
689 }
690
691 };
692
693 class CAtlWinModule : public _ATL_WIN_MODULE
694 {
695 public:
696 CAtlWinModule()
697 {
698 HRESULT hResult;
699
700 hResult = AtlWinModuleInit(this);
701 if (FAILED(hResult))
702 {
703 CAtlBaseModule::m_bInitFailed = true;
704 ATLASSERT(0);
705 }
706 }
707
708 ~CAtlWinModule()
709 {
710 Term();
711 }
712
713 void Term()
714 {
715 AtlWinModuleTerm(this, _AtlBaseModule.GetModuleInstance());
716 }
717
718 void AddCreateWndData(_AtlCreateWndData *pData, void *pObject)
719 {
720 AtlWinModuleAddCreateWndData(this, pData, pObject);
721 }
722
723 void *ExtractCreateWndData()
724 {
725 return AtlWinModuleExtractCreateWndData(this);
726 }
727 };
728
729 extern CAtlWinModule _AtlWinModule;
730
731 template<class T>
732 class CComPtr
733 {
734 public:
735 T *p;
736 public:
737 CComPtr()
738 {
739 p = NULL;
740 }
741
742 CComPtr(T *lp)
743 {
744 p = lp;
745 if (p != NULL)
746 p->AddRef();
747 }
748
749 CComPtr(const CComPtr<T> &lp)
750 {
751 p = lp.p;
752 if (p != NULL)
753 p->AddRef();
754 }
755
756 ~CComPtr()
757 {
758 if (p != NULL)
759 p->Release();
760 }
761
762 T *operator = (T *lp)
763 {
764 if (p != NULL)
765 p->Release();
766 p = lp;
767 if (p != NULL)
768 p->AddRef();
769 return *this;
770 }
771
772 T *operator = (const CComPtr<T> &lp)
773 {
774 if (p != NULL)
775 p->Release();
776 p = lp.p;
777 if (p != NULL)
778 p->AddRef();
779 return *this;
780 }
781
782 void Release()
783 {
784 if (p != NULL)
785 {
786 p->Release();
787 p = NULL;
788 }
789 }
790
791 void Attach(T *lp)
792 {
793 if (p != NULL)
794 p->Release();
795 p = lp;
796 }
797
798 T *Detach()
799 {
800 T *saveP;
801
802 saveP = p;
803 p = NULL;
804 return saveP;
805 }
806
807 T **operator & ()
808 {
809 ATLASSERT(p == NULL);
810 return &p;
811 }
812
813 operator T * ()
814 {
815 return p;
816 }
817
818 T *operator -> ()
819 {
820 ATLASSERT(p != NULL);
821 return p;
822 }
823 };
824
825 class CComBSTR
826 {
827 public:
828 BSTR m_str;
829 public:
830 CComBSTR(LPCOLESTR pSrc)
831 {
832 if (pSrc == NULL)
833 m_str = NULL;
834 else
835 m_str = ::SysAllocString(pSrc);
836 }
837 ~CComBSTR()
838 {
839 ::SysFreeString(m_str);
840 m_str = NULL;
841 }
842 };
843
844 class CComVariant : public tagVARIANT
845 {
846 public:
847 CComVariant()
848 {
849 ::VariantInit(this);
850 }
851
852 ~CComVariant()
853 {
854 Clear();
855 }
856
857 HRESULT Clear()
858 {
859 return ::VariantClear(this);
860 }
861 };
862
863 inline HRESULT __stdcall AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID &iid, LPDWORD pdw)
864 {
865 CComPtr<IConnectionPointContainer> container;
866 CComPtr<IConnectionPoint> connectionPoint;
867 HRESULT hResult;
868
869 if (pUnkCP == NULL)
870 return E_INVALIDARG;
871 hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
872 if (FAILED(hResult))
873 return hResult;
874 hResult = container->FindConnectionPoint(iid, &connectionPoint);
875 if (FAILED(hResult))
876 return hResult;
877 return connectionPoint->Advise(pUnk, pdw);
878 }
879
880 inline HRESULT __stdcall AtlUnadvise(IUnknown *pUnkCP, const IID &iid, DWORD dw)
881 {
882 CComPtr<IConnectionPointContainer> container;
883 CComPtr<IConnectionPoint> connectionPoint;
884 HRESULT hResult;
885
886 if (pUnkCP == NULL)
887 return E_INVALIDARG;
888 hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
889 if (FAILED(hResult))
890 return hResult;
891 hResult = container->FindConnectionPoint(iid, &connectionPoint);
892 if (FAILED(hResult))
893 return hResult;
894 return connectionPoint->Unadvise(dw);
895 }
896
897 inline HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
898 {
899 int i;
900 IUnknown *resultInterface;
901 HRESULT hResult;
902
903 ATLASSERT(pThis != NULL && pEntries != NULL);
904 if (pThis == NULL || pEntries == NULL)
905 return E_INVALIDARG;
906 ATLASSERT(ppvObject != NULL);
907 if (ppvObject == NULL)
908 return E_POINTER;
909
910 if (InlineIsEqualUnknown(iid))
911 {
912 resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[0].dw);
913 *ppvObject = resultInterface;
914 resultInterface->AddRef();
915 return S_OK;
916 }
917
918 i = 0;
919 while (pEntries[i].pFunc != 0)
920 {
921 if (pEntries[i].piid == NULL || InlineIsEqualGUID(iid, *pEntries[i].piid))
922 {
923 if (pEntries[i].pFunc == reinterpret_cast<_ATL_CREATORARGFUNC *>(1))
924 {
925 ATLASSERT(pEntries[i].piid != NULL);
926 resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[i].dw);
927 *ppvObject = resultInterface;
928 resultInterface->AddRef();
929 return S_OK;
930 }
931 else
932 {
933 hResult = pEntries[i].pFunc(pThis, iid, ppvObject, 0);
934 if (hResult == S_OK || (FAILED(hResult) && pEntries[i].piid != NULL))
935 return hResult;
936 }
937 break;
938 }
939 i++;
940 }
941 *ppvObject = NULL;
942 return E_NOINTERFACE;
943 }
944
945 inline HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule)
946 {
947 if (pWinModule == NULL)
948 return E_INVALIDARG;
949 pWinModule->m_pCreateWndList = NULL;
950 return pWinModule->m_csWindowCreate.Init();
951 }
952
953 inline HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst)
954 {
955 if (pWinModule == NULL)
956 return E_INVALIDARG;
957 pWinModule->m_csWindowCreate.Term();
958 return S_OK;
959 }
960
961 inline void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject)
962 {
963 CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
964
965 ATLASSERT(pWinModule != NULL);
966 ATLASSERT(pObject != NULL);
967
968 pData->m_pThis = pObject;
969 pData->m_dwThreadID = ::GetCurrentThreadId();
970 pData->m_pNext = pWinModule->m_pCreateWndList;
971 pWinModule->m_pCreateWndList = pData;
972 }
973
974 inline void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule)
975 {
976 CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
977 void *result;
978 _AtlCreateWndData *currentEntry;
979 _AtlCreateWndData **previousLink;
980 DWORD threadID;
981
982 ATLASSERT(pWinModule != NULL);
983
984 result = NULL;
985 threadID = GetCurrentThreadId();
986 currentEntry = pWinModule->m_pCreateWndList;
987 previousLink = &pWinModule->m_pCreateWndList;
988 while (currentEntry != NULL)
989 {
990 if (currentEntry->m_dwThreadID == threadID)
991 {
992 *previousLink = currentEntry->m_pNext;
993 result = currentEntry->m_pThis;
994 break;
995 }
996 previousLink = &currentEntry->m_pNext;
997 currentEntry = currentEntry->m_pNext;
998 }
999 return result;
1000 }
1001
1002 }; // namespace ATL
1003
1004 #ifndef _ATL_NO_AUTOMATIC_NAMESPACE
1005 using namespace ATL;
1006 #endif //!_ATL_NO_AUTOMATIC_NAMESPACE