reactos/lib/atl/atlbase.h

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