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