[ATL] Continue enumeration after a failing COM_INTERFACE_ENTRY_FUNC_BLIND
[reactos.git] / sdk / 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 #include "atlcomcli.h"
26 #include "atlalloc.h"
27 #include "comcat.h"
28 #include "tchar.h"
29
30 #ifdef _MSC_VER
31 // It is common to use this in ATL constructors. They only store this for later use, so the usage is safe.
32 #pragma warning(disable:4355)
33 #endif
34
35 #ifndef _ATL_PACKING
36 #define _ATL_PACKING 8
37 #endif
38
39 #ifndef _ATL_FREE_THREADED
40 #ifndef _ATL_APARTMENT_THREADED
41 #ifndef _ATL_SINGLE_THREADED
42 #define _ATL_FREE_THREADED
43 #endif
44 #endif
45 #endif
46
47 #ifndef ATLTRY
48 #define ATLTRY(x) x;
49 #endif
50
51 #ifdef _ATL_DISABLE_NO_VTABLE
52 #define ATL_NO_VTABLE
53 #else
54 #define ATL_NO_VTABLE __declspec(novtable)
55 #endif
56
57 #ifndef ATL_DEPRECATED
58 #define ATL_DEPRECATED __declspec(deprecated)
59 #endif
60
61 #define offsetofclass(base, derived) (reinterpret_cast<DWORD_PTR>(static_cast<base *>(reinterpret_cast<derived *>(_ATL_PACKING))) - _ATL_PACKING)
62
63 namespace ATL
64 {
65
66 class CAtlModule;
67 class CComModule;
68 class CAtlComModule;
69 __declspec(selectany) CAtlModule *_pAtlModule = NULL;
70 __declspec(selectany) CComModule *_pModule = NULL;
71 extern CAtlComModule _AtlComModule;
72
73
74 struct _ATL_CATMAP_ENTRY
75 {
76 int iType;
77 const GUID* pcatid;
78 };
79
80 #define _ATL_CATMAP_ENTRY_END 0
81 #define _ATL_CATMAP_ENTRY_IMPLEMENTED 1
82 #define _ATL_CATMAP_ENTRY_REQUIRED 2
83
84
85 typedef HRESULT (WINAPI _ATL_CREATORFUNC)(void *pv, REFIID riid, LPVOID *ppv);
86 typedef LPCTSTR (WINAPI _ATL_DESCRIPTIONFUNC)();
87 typedef const struct _ATL_CATMAP_ENTRY * (_ATL_CATMAPFUNC)();
88
89 struct _ATL_OBJMAP_ENTRY30
90 {
91 const CLSID *pclsid;
92 HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister);
93 _ATL_CREATORFUNC *pfnGetClassObject;
94 _ATL_CREATORFUNC *pfnCreateInstance;
95 IUnknown *pCF;
96 DWORD dwRegister;
97 _ATL_DESCRIPTIONFUNC *pfnGetObjectDescription;
98 _ATL_CATMAPFUNC *pfnGetCategoryMap;
99 void (WINAPI *pfnObjectMain)(bool bStarting);
100
101 HRESULT WINAPI RevokeClassObject()
102 {
103 if (dwRegister == 0)
104 return S_OK;
105 return CoRevokeClassObject(dwRegister);
106 }
107
108 HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
109 {
110 IUnknown *p;
111 HRESULT hResult;
112
113 p = NULL;
114 if (pfnGetClassObject == NULL)
115 return S_OK;
116
117 hResult = pfnGetClassObject(reinterpret_cast<LPVOID *>(pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&p));
118 if (SUCCEEDED(hResult))
119 hResult = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
120
121 if (p != NULL)
122 p->Release();
123
124 return hResult;
125 }
126 };
127
128 typedef _ATL_OBJMAP_ENTRY30 _ATL_OBJMAP_ENTRY;
129
130 typedef void (__stdcall _ATL_TERMFUNC)(DWORD_PTR dw);
131
132 struct _ATL_TERMFUNC_ELEM
133 {
134 _ATL_TERMFUNC *pFunc;
135 DWORD_PTR dw;
136 _ATL_TERMFUNC_ELEM *pNext;
137 };
138
139 struct _ATL_MODULE70
140 {
141 UINT cbSize;
142 LONG m_nLockCnt;
143 _ATL_TERMFUNC_ELEM *m_pTermFuncs;
144 CComCriticalSection m_csStaticDataInitAndTypeInfo;
145 };
146 typedef _ATL_MODULE70 _ATL_MODULE;
147
148 typedef HRESULT (WINAPI _ATL_CREATORARGFUNC)(void *pv, REFIID riid, LPVOID *ppv, DWORD_PTR dw);
149
150 #define _ATL_SIMPLEMAPENTRY ((ATL::_ATL_CREATORARGFUNC *)1)
151
152 struct _ATL_INTMAP_ENTRY
153 {
154 const IID *piid;
155 DWORD_PTR dw;
156 _ATL_CREATORARGFUNC *pFunc;
157 };
158
159 struct _AtlCreateWndData
160 {
161 void *m_pThis;
162 DWORD m_dwThreadID;
163 _AtlCreateWndData *m_pNext;
164 };
165
166 struct _ATL_COM_MODULE70
167 {
168 UINT cbSize;
169 HINSTANCE m_hInstTypeLib;
170 _ATL_OBJMAP_ENTRY **m_ppAutoObjMapFirst;
171 _ATL_OBJMAP_ENTRY **m_ppAutoObjMapLast;
172 CComCriticalSection m_csObjMap;
173 };
174 typedef _ATL_COM_MODULE70 _ATL_COM_MODULE;
175
176 struct _ATL_WIN_MODULE70
177 {
178 UINT cbSize;
179 CComCriticalSection m_csWindowCreate;
180 _AtlCreateWndData *m_pCreateWndList;
181 #ifdef NOTYET
182 CSimpleArray<ATOM> m_rgWindowClassAtoms;
183 #endif
184 };
185 typedef _ATL_WIN_MODULE70 _ATL_WIN_MODULE;
186
187 struct _ATL_REGMAP_ENTRY
188 {
189 LPCOLESTR szKey;
190 LPCOLESTR szData;
191 };
192
193 HRESULT WINAPI AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule);
194 HRESULT WINAPI AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst);
195 HRESULT WINAPI AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject);
196 void WINAPI AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject);
197 void *WINAPI AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule);
198 HRESULT WINAPI AtlComModuleGetClassObject(_ATL_COM_MODULE *pComModule, REFCLSID rclsid, REFIID riid, LPVOID *ppv);
199
200 HRESULT WINAPI AtlComModuleRegisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid);
201 HRESULT WINAPI AtlComModuleUnregisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid);
202
203 HRESULT WINAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE *module, DWORD context, DWORD flags);
204 HRESULT WINAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE *module);
205
206
207 template<class TLock>
208 class CComCritSecLock
209 {
210 private:
211 bool m_bLocked;
212 TLock &m_cs;
213 public:
214 CComCritSecLock(TLock &cs, bool bInitialLock = true) : m_cs(cs)
215 {
216 HRESULT hResult;
217
218 m_bLocked = false;
219 if (bInitialLock)
220 {
221 hResult = Lock();
222 if (FAILED(hResult))
223 {
224 ATLASSERT(false);
225 }
226 }
227 }
228
229 ~CComCritSecLock()
230 {
231 if (m_bLocked)
232 Unlock();
233 }
234
235 HRESULT Lock()
236 {
237 HRESULT hResult;
238
239 ATLASSERT(!m_bLocked);
240 hResult = m_cs.Lock();
241 if (FAILED(hResult))
242 return hResult;
243 m_bLocked = true;
244
245 return S_OK;
246 }
247
248 void Unlock()
249 {
250 HRESULT hResult;
251
252 ATLASSERT(m_bLocked);
253 hResult = m_cs.Unlock();
254 if (FAILED(hResult))
255 {
256 ATLASSERT(false);
257 }
258 m_bLocked = false;
259 }
260 };
261
262
263 class CHandle
264 {
265 public:
266 HANDLE m_handle;
267
268 public:
269 CHandle() :
270 m_handle(NULL)
271 {
272 }
273
274 CHandle(_Inout_ CHandle& handle) :
275 m_handle(NULL)
276 {
277 Attach(handle.Detach());
278 }
279
280 explicit CHandle(_In_ HANDLE handle) :
281 m_handle(handle)
282 {
283 }
284
285 ~CHandle()
286 {
287 if (m_handle)
288 {
289 Close();
290 }
291 }
292
293 CHandle& operator=(_Inout_ CHandle& handle)
294 {
295 if (this != &handle)
296 {
297 if (m_handle)
298 {
299 Close();
300 }
301 Attach(handle.Detach());
302 }
303
304 return *this;
305 }
306
307 operator HANDLE() const
308 {
309 return m_handle;
310 }
311
312 void Attach(_In_ HANDLE handle)
313 {
314 ATLASSERT(m_handle == NULL);
315 m_handle = handle;
316 }
317
318 HANDLE Detach()
319 {
320 HANDLE handle = m_handle;
321 m_handle = NULL;
322 return handle;
323 }
324
325 void Close()
326 {
327 if (m_handle)
328 {
329 ::CloseHandle(m_handle);
330 m_handle = NULL;
331 }
332 }
333 };
334
335
336 inline BOOL WINAPI InlineIsEqualUnknown(REFGUID rguid1)
337 {
338 return (
339 ((unsigned long *)&rguid1)[0] == 0 &&
340 ((unsigned long *)&rguid1)[1] == 0 &&
341 ((unsigned long *)&rguid1)[2] == 0x000000C0 &&
342 ((unsigned long *)&rguid1)[3] == 0x46000000);
343 }
344
345 class CComMultiThreadModelNoCS
346 {
347 public:
348 typedef CComFakeCriticalSection AutoCriticalSection;
349 typedef CComFakeCriticalSection CriticalSection;
350 typedef CComMultiThreadModelNoCS ThreadModelNoCS;
351 typedef CComFakeCriticalSection AutoDeleteCriticalSection;
352
353 static ULONG WINAPI Increment(LPLONG p)
354 {
355 return InterlockedIncrement(p);
356 }
357
358 static ULONG WINAPI Decrement(LPLONG p)
359 {
360 return InterlockedDecrement(p);
361 }
362 };
363
364 class CComMultiThreadModel
365 {
366 public:
367 typedef CComAutoCriticalSection AutoCriticalSection;
368 typedef CComCriticalSection CriticalSection;
369 typedef CComMultiThreadModelNoCS ThreadModelNoCS;
370 typedef CComAutoDeleteCriticalSection AutoDeleteCriticalSection;
371
372 static ULONG WINAPI Increment(LPLONG p)
373 {
374 return InterlockedIncrement(p);
375 }
376
377 static ULONG WINAPI Decrement(LPLONG p)
378 {
379 return InterlockedDecrement(p);
380 }
381 };
382
383 class CComSingleThreadModel
384 {
385 public:
386 typedef CComFakeCriticalSection AutoCriticalSection;
387 typedef CComFakeCriticalSection CriticalSection;
388 typedef CComSingleThreadModel ThreadModelNoCS;
389 typedef CComFakeCriticalSection AutoDeleteCriticalSection;
390
391 static ULONG WINAPI Increment(LPLONG p)
392 {
393 return ++*p;
394 }
395
396 static ULONG WINAPI Decrement(LPLONG p)
397 {
398 return --*p;
399 }
400 };
401
402 #if defined(_ATL_FREE_THREADED)
403
404 typedef CComMultiThreadModel CComObjectThreadModel;
405 typedef CComMultiThreadModel CComGlobalsThreadModel;
406
407 #elif defined(_ATL_APARTMENT_THREADED)
408
409 typedef CComSingleThreadModel CComObjectThreadModel;
410 typedef CComMultiThreadModel CComGlobalsThreadModel;
411
412 #elif defined(_ATL_SINGLE_THREADED)
413
414 typedef CComSingleThreadModel CComObjectThreadModel;
415 typedef CComSingleThreadModel CComGlobalsThreadModel;
416
417 #else
418 #error No threading model
419 #endif
420
421 class CAtlModule : public _ATL_MODULE
422 {
423 public:
424 static GUID m_libid;
425
426 CAtlModule()
427 {
428 ATLASSERT(_pAtlModule == NULL);
429 _pAtlModule = this;
430 cbSize = sizeof(_ATL_MODULE);
431 m_nLockCnt = 0;
432 }
433
434 virtual LONG GetLockCount()
435 {
436 return m_nLockCnt;
437 }
438
439 virtual LONG Lock()
440 {
441 return CComGlobalsThreadModel::Increment(&m_nLockCnt);
442 }
443
444 virtual LONG Unlock()
445 {
446 return CComGlobalsThreadModel::Decrement(&m_nLockCnt);
447 }
448
449 virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* /*pRegistrar*/) = 0;
450
451 HRESULT WINAPI UpdateRegistryFromResource(LPCTSTR lpszRes, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
452 {
453 CRegObject registrar;
454 WCHAR modulePath[MAX_PATH];
455 HRESULT hResult;
456 PCWSTR lpwszRes;
457
458 hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
459 if (FAILED(hResult))
460 return hResult;
461 #ifdef UNICODE
462 lpwszRes = lpszRes;
463 #else
464 /* FIXME: this is a bit of a hack, need to re-evaluate */
465 WCHAR resid[MAX_PATH];
466 MultiByteToWideChar(CP_ACP, 0, lpszRes, -1, resid, MAX_PATH);
467 lpwszRes = resid;
468 #endif
469 if (bRegister != FALSE)
470 hResult = registrar.ResourceRegisterSz(modulePath, lpwszRes, L"REGISTRY");
471 else
472 hResult = registrar.ResourceUnregisterSz(modulePath, lpwszRes, L"REGISTRY");
473
474 return hResult;
475 }
476
477 HRESULT WINAPI UpdateRegistryFromResource(UINT nResID, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
478 {
479 CRegObject registrar;
480 WCHAR modulePath[MAX_PATH];
481 HRESULT hResult;
482
483 hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
484 if (FAILED(hResult))
485 return hResult;
486
487 if (bRegister != FALSE)
488 hResult = registrar.ResourceRegister(modulePath, nResID, L"REGISTRY");
489 else
490 hResult = registrar.ResourceUnregister(modulePath, nResID, L"REGISTRY");
491
492 return hResult;
493 }
494
495 private:
496 HRESULT CommonInitRegistrar(CRegObject &registrar, WCHAR *modulePath, DWORD modulePathCount, struct _ATL_REGMAP_ENTRY *pMapEntries)
497 {
498 HINSTANCE hInstance;
499 DWORD dwFLen;
500 HRESULT hResult;
501
502 hInstance = _AtlBaseModule.GetModuleInstance();
503 dwFLen = GetModuleFileNameW(hInstance, modulePath, modulePathCount);
504 if (dwFLen == modulePathCount)
505 return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
506 else if (dwFLen == 0)
507 return HRESULT_FROM_WIN32(GetLastError());
508
509 if (pMapEntries != NULL)
510 {
511 while (pMapEntries->szKey != NULL)
512 {
513 ATLASSERT(pMapEntries->szData != NULL);
514 hResult = registrar.AddReplacement(pMapEntries->szKey, pMapEntries->szData);
515 if (FAILED(hResult))
516 return hResult;
517 pMapEntries++;
518 }
519 }
520
521 hResult = AddCommonRGSReplacements(&registrar);
522 if (FAILED(hResult))
523 return hResult;
524
525 hResult = registrar.AddReplacement(L"Module", modulePath);
526 if (FAILED(hResult))
527 return hResult;
528
529 hResult = registrar.AddReplacement(L"Module_Raw", modulePath);
530 if (FAILED(hResult))
531 return hResult;
532
533 return S_OK;
534 }
535 };
536
537 __declspec(selectany) GUID CAtlModule::m_libid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0} };
538
539 template <class T>
540 class CAtlModuleT : public CAtlModule
541 {
542 public:
543
544 HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL);
545 HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL);
546
547
548 virtual HRESULT AddCommonRGSReplacements(IRegistrarBase *pRegistrar)
549 {
550 return pRegistrar->AddReplacement(L"APPID", T::GetAppId());
551 }
552
553 static LPCOLESTR GetAppId()
554 {
555 return L"";
556 }
557 };
558
559 class CAtlComModule : public _ATL_COM_MODULE
560 {
561 public:
562 CAtlComModule()
563 {
564 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInstTypeLib);
565 m_ppAutoObjMapFirst = NULL;
566 m_ppAutoObjMapLast = NULL;
567 if (FAILED(m_csObjMap.Init()))
568 {
569 ATLASSERT(0);
570 CAtlBaseModule::m_bInitFailed = true;
571 return;
572 }
573 cbSize = sizeof(_ATL_COM_MODULE);
574 }
575
576 ~CAtlComModule()
577 {
578 Term();
579 }
580
581 HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
582 {
583 return AtlComModuleRegisterServer(this, bRegTypeLib, pCLSID);
584 }
585
586 HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
587 {
588 return AtlComModuleUnregisterServer(this, bUnRegTypeLib, pCLSID);
589 }
590
591
592 void Term()
593 {
594 if (cbSize != 0)
595 {
596 ATLASSERT(m_ppAutoObjMapFirst == NULL);
597 ATLASSERT(m_ppAutoObjMapLast == NULL);
598 m_csObjMap.Term();
599 cbSize = 0;
600 }
601 }
602 };
603
604 template <class T>
605 HRESULT CAtlModuleT<T>::RegisterServer(BOOL bRegTypeLib, const CLSID *pCLSID)
606 {
607 return _AtlComModule.RegisterServer(bRegTypeLib, pCLSID);
608 }
609
610 template <class T>
611 HRESULT CAtlModuleT<T>::UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID)
612 {
613 return _AtlComModule.UnregisterServer(bUnRegTypeLib, pCLSID);
614 }
615
616 template <class T>
617 class CAtlDllModuleT : public CAtlModuleT<T>
618 {
619 public:
620 CAtlDllModuleT()
621 {
622 }
623
624 HRESULT DllCanUnloadNow()
625 {
626 T *pThis;
627
628 pThis = static_cast<T *>(this);
629 if (pThis->GetLockCount() == 0)
630 return S_OK;
631 return S_FALSE;
632 }
633
634 HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
635 {
636 T *pThis;
637
638 pThis = static_cast<T *>(this);
639 return pThis->GetClassObject(rclsid, riid, ppv);
640 }
641
642 HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
643 {
644 T *pThis;
645 HRESULT hResult;
646
647 pThis = static_cast<T *>(this);
648 hResult = pThis->RegisterServer(bRegTypeLib);
649 return hResult;
650 }
651
652 HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
653 {
654 T *pThis;
655 HRESULT hResult;
656
657 pThis = static_cast<T *>(this);
658 hResult = pThis->UnregisterServer(bUnRegTypeLib);
659 return hResult;
660 }
661
662 HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
663 {
664 return AtlComModuleGetClassObject(&_AtlComModule, rclsid, riid, ppv);
665 }
666 };
667
668
669 template <class T>
670 class CAtlExeModuleT : public CAtlModuleT<T>
671 {
672 public:
673 DWORD m_dwMainThreadID;
674 //DWORD m_dwTimeOut;
675 //DWORD m_dwPause;
676 //bool m_bDelayShutdown;
677
678 CAtlExeModuleT()
679 :m_dwMainThreadID(::GetCurrentThreadId())
680 {
681 }
682
683 ~CAtlExeModuleT()
684 {
685 }
686
687 int WinMain(int nShowCmd)
688 {
689 HRESULT hr = T::InitializeCom();
690 if (FAILED(hr))
691 return hr;
692
693 T* pThis = static_cast<T*>(this);
694
695 LPCTSTR lpCommandLine = GetCommandLine();
696 if (pThis->ParseCommandLine(lpCommandLine, &hr))
697 {
698 hr = pThis->Run(nShowCmd);
699 }
700
701 T::UninitializeCom();
702 return hr;
703 }
704
705
706 HRESULT Run(int nShowCmd = SW_HIDE)
707 {
708 HRESULT hr = S_OK;
709
710 T* pThis = static_cast<T*>(this);
711 hr = pThis->PreMessageLoop(nShowCmd);
712
713 if (hr == S_OK)
714 {
715 pThis->RunMessageLoop();
716 hr = pThis->PostMessageLoop();
717 }
718
719 return hr;
720 }
721
722 LONG Lock()
723 {
724 return CoAddRefServerProcess();
725 }
726
727 LONG Unlock()
728 {
729 LONG lRet = CoReleaseServerProcess();
730 if (lRet == 0)
731 {
732 ::PostThreadMessage(m_dwMainThreadID, WM_QUIT, 0, 0);
733 }
734 return lRet;
735 }
736
737 bool ParseCommandLine(LPCTSTR lpCmdLine, HRESULT* pnRetCode)
738 {
739 // unimplemented!
740 return true;
741 }
742
743 HRESULT PreMessageLoop(int nShowCmd)
744 {
745 T* pThis = static_cast<T*>(this);
746 return pThis->RegisterClassObjects(CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE);
747 }
748
749 void RunMessageLoop()
750 {
751 MSG msg;
752 while (GetMessage(&msg, 0, 0, 0) > 0)
753 {
754 TranslateMessage(&msg);
755 DispatchMessage(&msg);
756 }
757 }
758
759 HRESULT PostMessageLoop()
760 {
761 T* pThis = static_cast<T*>(this);
762 return pThis->RevokeClassObjects();
763 }
764
765 HRESULT RegisterClassObjects(DWORD dwClsContext, DWORD dwFlags)
766 {
767 return AtlComModuleRegisterClassObjects(&_AtlComModule, dwClsContext, dwFlags);
768 }
769
770 HRESULT RevokeClassObjects()
771 {
772 return AtlComModuleRevokeClassObjects(&_AtlComModule);
773 }
774
775 static HRESULT InitializeCom()
776 {
777 return ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
778 }
779
780 static void UninitializeCom()
781 {
782 ::CoUninitialize();
783 }
784
785 };
786
787
788
789 class CComModule : public CAtlModuleT<CComModule>
790 {
791 public:
792 _ATL_OBJMAP_ENTRY *m_pObjMap;
793 public:
794 CComModule()
795 {
796 ATLASSERT(_pModule == NULL);
797 _pModule = this;
798 _pModule->m_pObjMap = NULL;
799 }
800
801 ~CComModule()
802 {
803 _pModule = NULL;
804 }
805
806 HRESULT Init(_ATL_OBJMAP_ENTRY *p, HINSTANCE /* h */, const GUID *plibid)
807 {
808 _ATL_OBJMAP_ENTRY *objectMapEntry;
809
810 if (plibid != NULL)
811 m_libid = *plibid;
812
813 if (p != reinterpret_cast<_ATL_OBJMAP_ENTRY *>(-1))
814 {
815 m_pObjMap = p;
816 if (p != NULL)
817 {
818 objectMapEntry = p;
819 while (objectMapEntry->pclsid != NULL)
820 {
821 objectMapEntry->pfnObjectMain(true);
822 objectMapEntry++;
823 }
824 }
825 }
826 return S_OK;
827 }
828
829 void Term()
830 {
831 _ATL_OBJMAP_ENTRY *objectMapEntry;
832
833 if (m_pObjMap != NULL)
834 {
835 objectMapEntry = m_pObjMap;
836 while (objectMapEntry->pclsid != NULL)
837 {
838 if (objectMapEntry->pCF != NULL)
839 objectMapEntry->pCF->Release();
840 objectMapEntry->pCF = NULL;
841 objectMapEntry->pfnObjectMain(false);
842 objectMapEntry++;
843 }
844 }
845 }
846
847 HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
848 {
849 _ATL_OBJMAP_ENTRY *objectMapEntry;
850 HRESULT hResult;
851
852 ATLASSERT(ppv != NULL);
853 if (ppv == NULL)
854 return E_POINTER;
855 *ppv = NULL;
856 hResult = S_OK;
857 if (m_pObjMap != NULL)
858 {
859 objectMapEntry = m_pObjMap;
860 while (objectMapEntry->pclsid != NULL)
861 {
862 if (objectMapEntry->pfnGetClassObject != NULL && InlineIsEqualGUID(rclsid, *objectMapEntry->pclsid) != FALSE)
863 {
864 if (objectMapEntry->pCF == NULL)
865 {
866 CComCritSecLock<CComCriticalSection> lock(_AtlComModule.m_csObjMap, true);
867
868 if (objectMapEntry->pCF == NULL)
869 hResult = objectMapEntry->pfnGetClassObject(reinterpret_cast<void *>(objectMapEntry->pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&objectMapEntry->pCF));
870 }
871 if (objectMapEntry->pCF != NULL)
872 hResult = objectMapEntry->pCF->QueryInterface(riid, ppv);
873 break;
874 }
875 objectMapEntry++;
876 }
877 }
878 if (hResult == S_OK && *ppv == NULL)
879 {
880 // FIXME: call AtlComModuleGetClassObject
881 hResult = CLASS_E_CLASSNOTAVAILABLE;
882 }
883 return hResult;
884 }
885
886 HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
887 {
888 _ATL_OBJMAP_ENTRY *objectMapEntry;
889 HRESULT hResult;
890
891 hResult = S_OK;
892 objectMapEntry = m_pObjMap;
893 if (objectMapEntry != NULL)
894 {
895 while (objectMapEntry->pclsid != NULL)
896 {
897 if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
898 {
899 hResult = objectMapEntry->pfnUpdateRegistry(TRUE);
900 if (FAILED(hResult))
901 break;
902 }
903 objectMapEntry++;
904 }
905 }
906 if (SUCCEEDED(hResult))
907 hResult = CAtlModuleT<CComModule>::RegisterServer(bRegTypeLib, pCLSID);
908 return hResult;
909 }
910
911 HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
912 {
913 _ATL_OBJMAP_ENTRY *objectMapEntry;
914 HRESULT hResult;
915
916 hResult = S_OK;
917 objectMapEntry = m_pObjMap;
918 if (objectMapEntry != NULL)
919 {
920 while (objectMapEntry->pclsid != NULL)
921 {
922 if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
923 {
924 hResult = objectMapEntry->pfnUpdateRegistry(FALSE); //unregister
925 if (FAILED(hResult))
926 break;
927 }
928 objectMapEntry++;
929 }
930 }
931 if (SUCCEEDED(hResult))
932 hResult = CAtlModuleT<CComModule>::UnregisterServer(bUnRegTypeLib, pCLSID);
933
934 return hResult;
935 }
936
937 HRESULT DllCanUnloadNow()
938 {
939 if (GetLockCount() == 0)
940 return S_OK;
941 return S_FALSE;
942 }
943
944 HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
945 {
946 return GetClassObject(rclsid, riid, ppv);
947 }
948
949 HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
950 {
951 return RegisterServer(bRegTypeLib);
952 }
953
954 HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
955 {
956 return UnregisterServer(bUnRegTypeLib);
957 }
958
959 };
960
961 class CAtlWinModule : public _ATL_WIN_MODULE
962 {
963 public:
964 CAtlWinModule()
965 {
966 HRESULT hResult;
967
968 hResult = AtlWinModuleInit(this);
969 if (FAILED(hResult))
970 {
971 CAtlBaseModule::m_bInitFailed = true;
972 ATLASSERT(0);
973 }
974 }
975
976 ~CAtlWinModule()
977 {
978 Term();
979 }
980
981 void Term()
982 {
983 AtlWinModuleTerm(this, _AtlBaseModule.GetModuleInstance());
984 }
985
986 void AddCreateWndData(_AtlCreateWndData *pData, void *pObject)
987 {
988 AtlWinModuleAddCreateWndData(this, pData, pObject);
989 }
990
991 void *ExtractCreateWndData()
992 {
993 return AtlWinModuleExtractCreateWndData(this);
994 }
995 };
996
997 extern CAtlWinModule _AtlWinModule;
998
999 class CComAllocator
1000 {
1001 public:
1002 static void* Allocate(_In_ size_t size)
1003 {
1004 return ::CoTaskMemAlloc(size);
1005 }
1006
1007 static void* Reallocate(_In_opt_ void* ptr, _In_ size_t size)
1008 {
1009 return ::CoTaskMemRealloc(ptr, size);
1010 }
1011
1012 static void Free(_In_opt_ void* ptr)
1013 {
1014 ::CoTaskMemFree(ptr);
1015 }
1016 };
1017
1018 class CRegKey
1019 {
1020 public:
1021 HKEY m_hKey;
1022 #if 0
1023 // FIXME & TODO:
1024 CAtlTransactionManager* m_pTM;
1025 #endif
1026
1027 public:
1028
1029 CRegKey() throw()
1030 : m_hKey(NULL)
1031 {
1032 }
1033
1034 CRegKey(CRegKey& key) throw()
1035 : m_hKey(key.Detach())
1036 {
1037 }
1038
1039 explicit CRegKey(HKEY hKey) throw()
1040 : m_hKey(hKey)
1041 {
1042 }
1043
1044 #if 0
1045 // FIXME & TODO:
1046 CRegKey(CAtlTransactionManager* pTM) throw()
1047 {
1048 ...
1049 }
1050 #endif
1051
1052 ~CRegKey() throw()
1053 {
1054 }
1055
1056 void Attach(HKEY hKey) throw()
1057 {
1058 m_hKey = hKey;
1059 }
1060
1061 LONG Close() throw()
1062 {
1063 if (m_hKey)
1064 {
1065 HKEY hKey = Detach();
1066 return ::RegCloseKey(hKey);
1067 }
1068 return ERROR_SUCCESS;
1069 }
1070
1071 HKEY Detach() throw()
1072 {
1073 HKEY hKey = m_hKey;
1074 m_hKey = NULL;
1075 return hKey;
1076 }
1077
1078 LONG Open(HKEY hKeyParent, LPCTSTR lpszKeyName,
1079 REGSAM samDesired = KEY_READ | KEY_WRITE) throw()
1080 {
1081 ATLASSERT(hKeyParent);
1082 ATLASSERT(lpszKeyName);
1083
1084 HKEY hKey = NULL;
1085 LONG lRes = ::RegOpenKeyEx(hKeyParent, lpszKeyName, NULL, samDesired, &hKey);
1086 if (lRes != ERROR_SUCCESS)
1087 {
1088 samDesired |= KEY_WOW64_64KEY;
1089 lRes = ::RegOpenKeyEx(hKeyParent, lpszKeyName, NULL, samDesired, &hKey);
1090 }
1091 if (lRes == ERROR_SUCCESS)
1092 {
1093 Close();
1094 m_hKey = hKey;
1095 }
1096 return lRes;
1097 }
1098
1099 LONG Create(HKEY hKeyParent, LPCTSTR lpszKeyName,
1100 LPTSTR lpszClass = REG_NONE,
1101 DWORD dwOptions = REG_OPTION_NON_VOLATILE,
1102 REGSAM samDesired = KEY_READ | KEY_WRITE,
1103 LPSECURITY_ATTRIBUTES lpSecAttr = NULL,
1104 LPDWORD lpdwDisposition = NULL) throw()
1105 {
1106 ATLASSERT(hKeyParent);
1107 ATLASSERT(lpszKeyName);
1108
1109 HKEY hKey = NULL;
1110 LONG lRes = ::RegCreateKeyEx(hKeyParent, lpszKeyName, NULL, lpszClass,
1111 dwOptions, samDesired, lpSecAttr, &hKey,
1112 lpdwDisposition);
1113 if (lRes != ERROR_SUCCESS)
1114 {
1115 samDesired |= KEY_WOW64_64KEY;
1116 lRes = ::RegCreateKeyEx(hKeyParent, lpszKeyName, NULL, lpszClass,
1117 dwOptions, samDesired, lpSecAttr, &hKey,
1118 lpdwDisposition);
1119 }
1120 if (lRes == ERROR_SUCCESS)
1121 {
1122 Close();
1123 m_hKey = hKey;
1124 }
1125 return lRes;
1126 }
1127
1128 LONG QueryValue(LPCTSTR pszValueName, DWORD* pdwType, void* pData, ULONG* pnBytes) throw()
1129 {
1130 ATLASSERT(m_hKey);
1131 return ::RegQueryValueEx(m_hKey, pszValueName, NULL, pdwType, (LPBYTE)pData, pnBytes);
1132 }
1133
1134 LONG QueryDWORDValue(LPCTSTR pszValueName, DWORD& dwValue) throw()
1135 {
1136 ULONG size = sizeof(DWORD);
1137 DWORD type = 0;
1138 LONG lRet = QueryValue(pszValueName, &type, &dwValue, &size);
1139
1140 if (lRet == ERROR_SUCCESS && type != REG_DWORD)
1141 lRet = ERROR_INVALID_DATA;
1142
1143 return lRet;
1144 }
1145
1146 LONG QueryBinaryValue(LPCTSTR pszValueName, void* pValue, ULONG* pnBytes) throw()
1147 {
1148 DWORD type = 0;
1149 LONG lRet = QueryValue(pszValueName, &type, pValue, pnBytes);
1150
1151 if (lRet == ERROR_SUCCESS && type != REG_BINARY)
1152 lRet = ERROR_INVALID_DATA;
1153
1154 return lRet;
1155 }
1156
1157 LONG QueryStringValue(LPCTSTR pszValueName, LPTSTR pszValue, ULONG* pnChars) throw()
1158 {
1159 ULONG size = (*pnChars) * sizeof(TCHAR);
1160 DWORD type = 0;
1161 LONG lRet = QueryValue(pszValueName, &type, pszValue, &size);
1162
1163 if (lRet == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ)
1164 lRet = ERROR_INVALID_DATA;
1165
1166 *pnChars = size / sizeof(TCHAR);
1167 return lRet;
1168 }
1169
1170 LONG QueryGUIDValue(LPCTSTR pszValueName, GUID& guidValue) throw()
1171 {
1172 OLECHAR buf[40] = {0};
1173 ULONG nChars = 39;
1174 LONG lRet;
1175
1176 #ifdef UNICODE
1177 lRet = QueryStringValue(pszValueName, buf, &nChars);
1178 #else
1179 CHAR bufA[40] = {0};
1180 lRet = QueryStringValue(pszValueName, bufA, &nChars);
1181 if (lRet != ERROR_SUCCESS)
1182 return lRet;
1183 if (!::MultiByteToWideChar(CP_THREAD_ACP, 0, bufA, -1, buf, 39))
1184 lRet = ERROR_INVALID_DATA;
1185 #endif
1186 if (lRet != ERROR_SUCCESS)
1187 return lRet;
1188
1189 if (!SUCCEEDED(::CLSIDFromString(buf, &guidValue)))
1190 return ERROR_INVALID_DATA;
1191
1192 return lRet;
1193 }
1194
1195 LONG QueryQWORDValue(LPCTSTR pszValueName, ULONGLONG& qwValue) throw()
1196 {
1197 ULONG size = sizeof(ULONGLONG);
1198 DWORD type = 0;
1199 LONG lRet = QueryValue(pszValueName, &type, &qwValue, &size);
1200
1201 if (lRet == ERROR_SUCCESS && type != REG_QWORD)
1202 lRet = ERROR_INVALID_DATA;
1203
1204 return lRet;
1205 }
1206
1207 LONG QueryMultiStringValue(LPCTSTR pszValueName, LPTSTR pszValue,
1208 ULONG* pnChars) throw()
1209 {
1210 ULONG size = (*pnChars) * sizeof(TCHAR);
1211 DWORD type;
1212 LONG lRet = QueryValue(pszValueName, &type, pszValue, &size);
1213
1214 if (lRet == ERROR_SUCCESS && type != REG_MULTI_SZ)
1215 lRet = ERROR_INVALID_DATA;
1216
1217 *pnChars = size / sizeof(TCHAR);
1218 return lRet;
1219 }
1220
1221 LONG SetValue(LPCTSTR pszValueName, DWORD dwType, const void* pValue, ULONG nBytes) throw()
1222 {
1223 ATLASSERT(m_hKey);
1224 return ::RegSetValueEx(m_hKey, pszValueName, NULL, dwType, (const BYTE*)pValue, nBytes);
1225 }
1226
1227 LONG SetDWORDValue(LPCTSTR pszValueName, DWORD dwValue) throw()
1228 {
1229 return SetValue(pszValueName, REG_DWORD, &dwValue, sizeof(DWORD));
1230 }
1231
1232 LONG SetStringValue(LPCTSTR pszValueName, LPCTSTR pszValue, DWORD dwType = REG_SZ) throw()
1233 {
1234 ULONG length;
1235 switch (dwType)
1236 {
1237 case REG_SZ:
1238 case REG_EXPAND_SZ:
1239 length = (_tcslen(pszValue) + 1) * sizeof(TCHAR);
1240 return SetValue(pszValueName, dwType, pszValue, length);
1241 case REG_MULTI_SZ:
1242 return SetMultiStringValue(pszValueName, pszValue);
1243 default:
1244 return ERROR_INVALID_DATA;
1245 }
1246 }
1247
1248 LONG SetGUIDValue(LPCTSTR pszValueName, REFGUID guidValue) throw()
1249 {
1250 OLECHAR buf[40] = {0};
1251 ::StringFromGUID2(guidValue, buf, 39);
1252 #ifdef UNICODE
1253 return SetStringValue(pszValueName, buf);
1254 #else
1255 CHAR bufA[40] = {0};
1256 ::WideCharToMultiByte(CP_THREAD_ACP, 0, buf, -1, bufA, 40, NULL, NULL);
1257 return SetStringValue(pszValueName, bufA);
1258 #endif
1259 }
1260
1261 LONG SetBinaryValue(LPCTSTR pszValueName, const void* pValue, ULONG nBytes) throw()
1262 {
1263 return SetValue(pszValueName, REG_BINARY, pValue, nBytes);
1264 }
1265
1266 LONG SetMultiStringValue(LPCTSTR pszValueName, LPCTSTR pszValue) throw()
1267 {
1268 ULONG dwSize = CRegKey::_GetMultiStringSize(pszValue);
1269 return SetValue(pszValueName, REG_MULTI_SZ, pszValue, dwSize);
1270 }
1271
1272 LONG SetQWORDValue(LPCTSTR pszValueName, ULONGLONG qwValue) throw()
1273 {
1274 ULONG dwSize = sizeof(ULONGLONG);
1275 return SetValue(pszValueName, REG_QWORD, &qwValue, dwSize);
1276 }
1277
1278 LONG NotifyChangeKeyValue(BOOL bWatchSubtree, DWORD dwNotifyFilter,
1279 HANDLE hEvent, BOOL bAsync = TRUE) throw()
1280 {
1281 ATLASSERT(m_hKey);
1282 LONG ret = ::RegNotifyChangeKeyValue(m_hKey, bWatchSubtree,
1283 dwNotifyFilter, hEvent, bAsync);
1284 return ret;
1285 }
1286
1287 LONG Flush() throw()
1288 {
1289 ATLASSERT(m_hKey);
1290 LONG ret = ::RegFlushKey(m_hKey);
1291 return ret;
1292 }
1293
1294 static LONG WINAPI SetValue(HKEY hKeyParent, LPCTSTR lpszKeyName,
1295 LPCTSTR lpszValue, LPCTSTR lpszValueName = NULL)
1296 {
1297 CRegKey key;
1298 LONG lRet = key.Create(hKeyParent, lpszKeyName);
1299 if (lRet == ERROR_SUCCESS)
1300 {
1301 lRet = key.SetStringValue(lpszValueName, lpszValue);
1302 }
1303 return lRet;
1304 }
1305
1306 LONG SetKeyValue(LPCTSTR lpszKeyName, LPCTSTR lpszValue,
1307 LPCTSTR lpszValueName = NULL) throw()
1308 {
1309 CRegKey key;
1310 LONG lRet = key.Create(m_hKey, lpszKeyName);
1311 if (lRet == ERROR_SUCCESS)
1312 {
1313 lRet = key.SetStringValue(lpszValueName, lpszValue);
1314 }
1315 return lRet;
1316 }
1317
1318 LONG DeleteValue(LPCTSTR lpszValue) throw()
1319 {
1320 ATLASSERT(m_hKey);
1321 return ::RegDeleteValue(m_hKey, lpszValue);
1322 }
1323
1324 LONG DeleteSubKey(LPCTSTR lpszSubKey) throw()
1325 {
1326 ATLASSERT(m_hKey);
1327 ATLASSERT(lpszSubKey);
1328 return ::RegDeleteKey(m_hKey, lpszSubKey);
1329 }
1330
1331 LONG RecurseDeleteKey(LPCTSTR lpszKey) throw()
1332 {
1333 ATLASSERT(m_hKey);
1334 ATLASSERT(lpszKey);
1335 return CRegKey::_DoDeleteKeyTree(m_hKey, lpszKey);
1336 }
1337
1338 LONG EnumKey(DWORD iIndex, LPTSTR pszName, LPDWORD pnNameLength,
1339 FILETIME* pftLastWriteTime = NULL) throw()
1340 {
1341 ATLASSERT(m_hKey);
1342 LONG ret = ::RegEnumKeyEx(m_hKey, iIndex, pszName, pnNameLength, NULL,
1343 NULL, NULL, pftLastWriteTime);
1344 return ret;
1345 }
1346
1347 LONG GetKeySecurity(SECURITY_INFORMATION si, PSECURITY_DESCRIPTOR psd,
1348 LPDWORD pnBytes) throw()
1349 {
1350 ATLASSERT(m_hKey);
1351 LONG ret = ::RegGetKeySecurity(m_hKey, si, psd, pnBytes);
1352 return ret;
1353 }
1354
1355 LONG SetKeySecurity(SECURITY_INFORMATION si,
1356 PSECURITY_DESCRIPTOR psd) throw()
1357 {
1358 ATLASSERT(m_hKey);
1359 LONG ret = ::RegSetKeySecurity(m_hKey, si, psd);
1360 return ret;
1361 }
1362
1363 operator HKEY() const throw()
1364 {
1365 return m_hKey;
1366 }
1367
1368 CRegKey& operator=(CRegKey& key) throw()
1369 {
1370 Attach(key.Detach());
1371 return *this;
1372 }
1373
1374 protected:
1375 // get the total size of a multistring
1376 static ULONG _GetMultiStringSize(LPCTSTR pszz)
1377 {
1378 int count = 0;
1379 do
1380 {
1381 int len = _tcslen(pszz);
1382 count += len + 1;
1383 pszz += len + 1;
1384 } while (*pszz != TEXT('\0'));
1385 ++count;
1386 return count * sizeof(TCHAR);
1387 }
1388
1389 // delete key recursively
1390 static LONG _DoDeleteKeyTree(HKEY hParentKey, LPCTSTR lpszKey)
1391 {
1392 ATLASSERT(hParentKey);
1393 ATLASSERT(lpszKey);
1394
1395 // open the key
1396 CRegKey key;
1397 LONG ret = key.Open(hParentKey, lpszKey);
1398 if (ret != ERROR_SUCCESS)
1399 {
1400 return ret; // failure
1401 }
1402
1403 // get the longest length of subkey names
1404 DWORD NameMax;
1405 ret = ::RegQueryInfoKey(key, NULL, NULL, NULL, NULL, &NameMax, NULL,
1406 NULL, NULL, NULL, NULL, NULL);
1407 if (ret != ERROR_SUCCESS)
1408 {
1409 return ret; // failure
1410 }
1411 ++NameMax; // for NUL
1412
1413 // allocate the string buffer for names if necessary
1414 TCHAR szNameBuf[MAX_PATH], *pszName;
1415 if (NameMax > MAX_PATH)
1416 {
1417 pszName = (TCHAR *)malloc(NameMax * sizeof(TCHAR));
1418 ATLASSERT(pszName);
1419 if (pszName == NULL)
1420 {
1421 return ERROR_OUTOFMEMORY; // failure
1422 }
1423 }
1424 else
1425 {
1426 NameMax = MAX_PATH;
1427 pszName = szNameBuf;
1428 }
1429
1430 // enumerate every subkey and delete
1431 for (;;)
1432 {
1433 DWORD Count = NameMax;
1434 ret = key.EnumKey(0, pszName, &Count);
1435 if (ret != ERROR_SUCCESS)
1436 {
1437 if (ret == ERROR_NO_MORE_ITEMS)
1438 ret = ERROR_SUCCESS;
1439 break;
1440 }
1441
1442 ret = CRegKey::_DoDeleteKeyTree(key, pszName);
1443 if (ret != ERROR_SUCCESS)
1444 break;
1445 }
1446
1447 // close key
1448 key.Close();
1449
1450 // delete the subkey
1451 if (ret == ERROR_SUCCESS)
1452 ret = ::RegDeleteKey(hParentKey, lpszKey);
1453
1454 // delete the buffer if any
1455 if (pszName != szNameBuf)
1456 free(pszName);
1457
1458 return ret;
1459 }
1460 };
1461
1462 template<class T>
1463 class CComHeapPtr : public CHeapPtr<T, CComAllocator>
1464 {
1465 public:
1466 CComHeapPtr()
1467 {
1468 }
1469
1470 explicit CComHeapPtr(T *lp) :
1471 CHeapPtr<T, CComAllocator>(lp)
1472 {
1473 }
1474 };
1475
1476
1477 inline HRESULT __stdcall AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID &iid, LPDWORD pdw)
1478 {
1479 CComPtr<IConnectionPointContainer> container;
1480 CComPtr<IConnectionPoint> connectionPoint;
1481 HRESULT hResult;
1482
1483 if (pUnkCP == NULL)
1484 return E_INVALIDARG;
1485 hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
1486 if (FAILED(hResult))
1487 return hResult;
1488 hResult = container->FindConnectionPoint(iid, &connectionPoint);
1489 if (FAILED(hResult))
1490 return hResult;
1491 return connectionPoint->Advise(pUnk, pdw);
1492 }
1493
1494 inline HRESULT __stdcall AtlUnadvise(IUnknown *pUnkCP, const IID &iid, DWORD dw)
1495 {
1496 CComPtr<IConnectionPointContainer> container;
1497 CComPtr<IConnectionPoint> connectionPoint;
1498 HRESULT hResult;
1499
1500 if (pUnkCP == NULL)
1501 return E_INVALIDARG;
1502 hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
1503 if (FAILED(hResult))
1504 return hResult;
1505 hResult = container->FindConnectionPoint(iid, &connectionPoint);
1506 if (FAILED(hResult))
1507 return hResult;
1508 return connectionPoint->Unadvise(dw);
1509 }
1510
1511 inline HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
1512 {
1513 int i;
1514 IUnknown *resultInterface;
1515 HRESULT hResult;
1516
1517 ATLASSERT(pThis != NULL && pEntries != NULL);
1518 if (pThis == NULL || pEntries == NULL)
1519 return E_INVALIDARG;
1520 ATLASSERT(ppvObject != NULL);
1521 if (ppvObject == NULL)
1522 return E_POINTER;
1523
1524 if (InlineIsEqualUnknown(iid))
1525 {
1526 resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[0].dw);
1527 *ppvObject = resultInterface;
1528 resultInterface->AddRef();
1529 return S_OK;
1530 }
1531
1532 i = 0;
1533 while (pEntries[i].pFunc != 0)
1534 {
1535 if (pEntries[i].piid == NULL || InlineIsEqualGUID(iid, *pEntries[i].piid))
1536 {
1537 if (pEntries[i].pFunc == reinterpret_cast<_ATL_CREATORARGFUNC *>(1))
1538 {
1539 ATLASSERT(pEntries[i].piid != NULL);
1540 resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[i].dw);
1541 *ppvObject = resultInterface;
1542 resultInterface->AddRef();
1543 return S_OK;
1544 }
1545 else
1546 {
1547 hResult = pEntries[i].pFunc(pThis, iid, ppvObject, 0);
1548 if (hResult == S_OK)
1549 return hResult;
1550 if (FAILED(hResult) && pEntries[i].piid != NULL)
1551 break;
1552 }
1553 }
1554 i++;
1555 }
1556 *ppvObject = NULL;
1557 return E_NOINTERFACE;
1558 }
1559
1560 inline HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule)
1561 {
1562 if (pWinModule == NULL)
1563 return E_INVALIDARG;
1564 pWinModule->m_pCreateWndList = NULL;
1565 return pWinModule->m_csWindowCreate.Init();
1566 }
1567
1568 inline HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst)
1569 {
1570 if (pWinModule == NULL)
1571 return E_INVALIDARG;
1572 pWinModule->m_csWindowCreate.Term();
1573 return S_OK;
1574 }
1575
1576 inline void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject)
1577 {
1578 CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
1579
1580 ATLASSERT(pWinModule != NULL);
1581 ATLASSERT(pObject != NULL);
1582
1583 pData->m_pThis = pObject;
1584 pData->m_dwThreadID = ::GetCurrentThreadId();
1585 pData->m_pNext = pWinModule->m_pCreateWndList;
1586 pWinModule->m_pCreateWndList = pData;
1587 }
1588
1589 inline void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule)
1590 {
1591 CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
1592 void *result;
1593 _AtlCreateWndData *currentEntry;
1594 _AtlCreateWndData **previousLink;
1595 DWORD threadID;
1596
1597 ATLASSERT(pWinModule != NULL);
1598
1599 result = NULL;
1600 threadID = GetCurrentThreadId();
1601 currentEntry = pWinModule->m_pCreateWndList;
1602 previousLink = &pWinModule->m_pCreateWndList;
1603 while (currentEntry != NULL)
1604 {
1605 if (currentEntry->m_dwThreadID == threadID)
1606 {
1607 *previousLink = currentEntry->m_pNext;
1608 result = currentEntry->m_pThis;
1609 break;
1610 }
1611 previousLink = &currentEntry->m_pNext;
1612 currentEntry = currentEntry->m_pNext;
1613 }
1614 return result;
1615 }
1616
1617 // Adapted from dll/win32/atl/atl.c
1618 inline HRESULT WINAPI AtlLoadTypeLib(HINSTANCE inst, LPCOLESTR lpszIndex,
1619 BSTR *pbstrPath, ITypeLib **ppTypeLib)
1620 {
1621 size_t index_len = lpszIndex ? wcslen(lpszIndex) : 0;
1622 CComHeapPtr<WCHAR> path;
1623 path.Allocate(MAX_PATH + index_len + wcslen(L".tlb"));
1624
1625 if (!path)
1626 return E_OUTOFMEMORY;
1627
1628 size_t path_len = GetModuleFileNameW(inst, path, MAX_PATH);
1629 if (!path_len)
1630 return HRESULT_FROM_WIN32(GetLastError());
1631
1632 if (index_len)
1633 wcscat(path, lpszIndex);
1634
1635 CComPtr<ITypeLib> typelib;
1636 HRESULT hResult = LoadTypeLib(path, &typelib);
1637 if (FAILED(hResult))
1638 {
1639 WCHAR *ptr;
1640 for (ptr = path+path_len-1; ptr > path && *ptr != '\\' && *ptr != '.'; ptr--)
1641 ;
1642 if (*ptr != '.')
1643 ptr = (WCHAR*)path + path_len;
1644 wcscpy(ptr, L".tlb");
1645
1646 hResult = LoadTypeLib(path, &typelib);
1647 }
1648
1649 if (SUCCEEDED(hResult))
1650 {
1651 *pbstrPath = SysAllocString(path);
1652 if (!*pbstrPath)
1653 {
1654 typelib.Release();
1655 hResult = E_OUTOFMEMORY;
1656 }
1657 }
1658
1659 if (FAILED(hResult))
1660 return hResult;
1661
1662 *ppTypeLib = typelib.Detach();
1663 return S_OK;
1664 }
1665
1666 // Adapted from dll/win32/atl/atl.c
1667 inline HRESULT WINAPI AtlRegisterTypeLib(HINSTANCE inst, const WCHAR *index)
1668 {
1669 CComBSTR path;
1670 CComPtr<ITypeLib> typelib;
1671 HRESULT hResult = AtlLoadTypeLib(inst, index, &path, &typelib);
1672 if (FAILED(hResult))
1673 return hResult;
1674
1675 return RegisterTypeLib(typelib, path, NULL); /* FIXME: pass help directory */
1676 }
1677
1678 // Adapted from dll/win32/atl/atl.c
1679 inline HRESULT WINAPI AtlRegisterClassCategoriesHelper(REFCLSID clsid, const _ATL_CATMAP_ENTRY *catmap, BOOL reg)
1680 {
1681 if (!catmap)
1682 return S_OK;
1683
1684 CComPtr<ICatRegister> catreg;
1685
1686 HRESULT hResult = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER, IID_ICatRegister, (void**)&catreg);
1687 if (FAILED(hResult))
1688 return hResult;
1689
1690 for (const _ATL_CATMAP_ENTRY *iter = catmap; iter->iType != _ATL_CATMAP_ENTRY_END; iter++)
1691 {
1692 CATID catid = *iter->pcatid;
1693
1694 if (iter->iType == _ATL_CATMAP_ENTRY_IMPLEMENTED)
1695 {
1696 if (reg)
1697 hResult = catreg->RegisterClassImplCategories(clsid, 1, &catid);
1698 else
1699 hResult = catreg->UnRegisterClassImplCategories(clsid, 1, &catid);
1700 }
1701 else
1702 {
1703 if (reg)
1704 hResult = catreg->RegisterClassReqCategories(clsid, 1, &catid);
1705 else
1706 hResult = catreg->UnRegisterClassReqCategories(clsid, 1, &catid);
1707 }
1708 if (FAILED(hResult))
1709 return hResult;
1710 }
1711
1712 if (!reg)
1713 {
1714 WCHAR reg_path[256] = L"CLSID\\";
1715
1716 StringFromGUID2(clsid, reg_path + wcslen(reg_path), 64);
1717 wcscat(reg_path, L"\\");
1718 WCHAR* ptr = reg_path + wcslen(reg_path);
1719
1720 wcscpy(ptr, L"Implemented Categories");
1721 RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
1722
1723 wcscpy(ptr, L"Required Categories");
1724 RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
1725 }
1726
1727 return hResult;
1728 }
1729
1730
1731 // Adapted from dll/win32/atl80/atl80.c
1732 inline HRESULT __stdcall AtlComModuleRegisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid)
1733 {
1734 HRESULT hResult = S_OK;
1735
1736 for (_ATL_OBJMAP_ENTRY ** iter = mod->m_ppAutoObjMapFirst; iter < mod->m_ppAutoObjMapLast; iter++)
1737 {
1738 if (!*iter)
1739 continue;
1740 _ATL_OBJMAP_ENTRY* entry = *iter;
1741 if (clsid && !IsEqualCLSID(*entry->pclsid, *clsid))
1742 continue;
1743
1744 hResult = entry->pfnUpdateRegistry(TRUE);
1745 if (FAILED(hResult))
1746 return hResult;
1747
1748 const _ATL_CATMAP_ENTRY *catmap = entry->pfnGetCategoryMap();
1749 if (catmap)
1750 {
1751 hResult = AtlRegisterClassCategoriesHelper(*entry->pclsid, catmap, TRUE);
1752 if (FAILED(hResult))
1753 return hResult;
1754 }
1755 }
1756
1757 if (bRegTypeLib)
1758 {
1759 hResult = AtlRegisterTypeLib(mod->m_hInstTypeLib, NULL);
1760 }
1761
1762 return hResult;
1763 }
1764
1765 // Adapted from dll/win32/atl/atl.c
1766 inline HRESULT WINAPI AtlComModuleUnregisterServer(_ATL_COM_MODULE *mod, BOOL bUnRegTypeLib, const CLSID *clsid)
1767 {
1768 HRESULT hResult = S_OK;
1769
1770 for (_ATL_OBJMAP_ENTRY **iter = mod->m_ppAutoObjMapFirst; iter < mod->m_ppAutoObjMapLast; iter++)
1771 {
1772 if (!*iter)
1773 continue;
1774 _ATL_OBJMAP_ENTRY* entry = *iter;
1775 if (clsid && !IsEqualCLSID(*entry->pclsid, *clsid))
1776 continue;
1777
1778 const _ATL_CATMAP_ENTRY *catmap = entry->pfnGetCategoryMap();
1779 if (catmap)
1780 {
1781 hResult = AtlRegisterClassCategoriesHelper(*entry->pclsid, catmap, FALSE);
1782 if (FAILED(hResult))
1783 return hResult;
1784 }
1785
1786 hResult = entry->pfnUpdateRegistry(FALSE);
1787 if (FAILED(hResult))
1788 return hResult;
1789 }
1790
1791 if (bUnRegTypeLib)
1792 {
1793 CComPtr<ITypeLib> typelib;
1794 TLIBATTR *attr;
1795 CComBSTR path;
1796
1797 hResult = AtlLoadTypeLib(mod->m_hInstTypeLib, NULL, &path, &typelib);
1798 if (FAILED(hResult))
1799 return hResult;
1800
1801 hResult = typelib->GetLibAttr(&attr);
1802 if (SUCCEEDED(hResult))
1803 {
1804 hResult = UnRegisterTypeLib(attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, attr->lcid, attr->syskind);
1805 typelib->ReleaseTLibAttr(attr);
1806 }
1807 }
1808
1809 return hResult;
1810 }
1811
1812
1813 // Adapted from dll/win32/atl/atl.c
1814 inline HRESULT WINAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE *module, DWORD context, DWORD flags)
1815 {
1816 _ATL_OBJMAP_ENTRY **iter;
1817 IUnknown* unk = NULL;
1818 HRESULT hr;
1819
1820 if (!module)
1821 return E_INVALIDARG;
1822
1823 for (iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++)
1824 {
1825 if (!(*iter)->pfnGetClassObject)
1826 continue;
1827
1828 hr = (*iter)->pfnGetClassObject((void*)(*iter)->pfnCreateInstance, IID_IUnknown, (void**)&unk);
1829 if (FAILED(hr))
1830 return hr;
1831
1832 hr = CoRegisterClassObject(*(*iter)->pclsid, unk, context, flags, &(*iter)->dwRegister);
1833 unk->Release();
1834 if (FAILED(hr))
1835 return hr;
1836 }
1837
1838 return S_OK;
1839 }
1840
1841
1842 // Adapted from dll/win32/atl/atl.c
1843 inline HRESULT WINAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE *module)
1844 {
1845 _ATL_OBJMAP_ENTRY **iter;
1846 HRESULT hr;
1847
1848 if (!module)
1849 return E_INVALIDARG;
1850
1851 for (iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++)
1852 {
1853 hr = CoRevokeClassObject((*iter)->dwRegister);
1854 if (FAILED(hr))
1855 return hr;
1856 }
1857
1858 return S_OK;
1859 }
1860
1861
1862 }; // namespace ATL
1863
1864 #ifndef _ATL_NO_AUTOMATIC_NAMESPACE
1865 using namespace ATL;
1866 #endif //!_ATL_NO_AUTOMATIC_NAMESPACE