[ATL]
authorTimo Kreuzer <timo.kreuzer@reactos.org>
Sun, 3 May 2015 15:10:09 +0000 (15:10 +0000)
committerTimo Kreuzer <timo.kreuzer@reactos.org>
Sun, 3 May 2015 15:10:09 +0000 (15:10 +0000)
- Convert tabs to spaces
- Remove excessive local variable indentation for alignment, since that doesn't help to improve readability
- No code changes

svn path=/trunk/; revision=67534

reactos/lib/atl/atlbase.cpp
reactos/lib/atl/atlbase.h
reactos/lib/atl/atlcom.h
reactos/lib/atl/atlcore.h
reactos/lib/atl/atlwin.h
reactos/lib/atl/statreg.h

index bac93d9..b9d16e8 100644 (file)
@@ -24,8 +24,8 @@
 namespace ATL
 {
 
-CAtlBaseModule                                                         _AtlBaseModule;
-CAtlWinModule                                                          _AtlWinModule = CAtlWinModule();
-CAtlComModule                                                          _AtlComModule;
+CAtlBaseModule _AtlBaseModule;
+CAtlWinModule _AtlWinModule = CAtlWinModule();
+CAtlComModule _AtlComModule;
 
 };  // namespace ATL
index 232507b..fdb576b 100644 (file)
@@ -58,8 +58,8 @@ namespace ATL
 class CAtlModule;
 class CComModule;
 class CAtlComModule;
-__declspec(selectany) CAtlModule                       *_pAtlModule = NULL;
-__declspec(selectany) CComModule                       *_pModule = NULL;
+__declspec(selectany) CAtlModule *_pAtlModule = NULL;
+__declspec(selectany) CComModule *_pModule = NULL;
 extern CAtlComModule _AtlComModule;
 
 typedef HRESULT (WINAPI _ATL_CREATORFUNC)(void *pv, REFIID riid, LPVOID *ppv);
@@ -68,41 +68,41 @@ typedef const struct _ATL_CATMAP_ENTRY * (_ATL_CATMAPFUNC)();
 
 struct _ATL_OBJMAP_ENTRY30
 {
-       const CLSID                                                             *pclsid;
-       HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister);
-       _ATL_CREATORFUNC                                                *pfnGetClassObject;
-       _ATL_CREATORFUNC                                                *pfnCreateInstance;
-       IUnknown                                                                *pCF;
-       DWORD                                                                   dwRegister;
-       _ATL_DESCRIPTIONFUNC                                    *pfnGetObjectDescription;
-       _ATL_CATMAPFUNC                                                 *pfnGetCategoryMap;
-       void (WINAPI *pfnObjectMain)(bool bStarting);
-
-       HRESULT WINAPI RevokeClassObject()
-       {
-               if (dwRegister == 0)
-                       return S_OK;
-               return CoRevokeClassObject(dwRegister);
-       }
-
-       HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
-       {
-               IUnknown                                                        *p;
-               HRESULT                                                         hResult;
-
-               p = NULL;
-               if (pfnGetClassObject == NULL)
-                       return S_OK;
-
-               hResult = pfnGetClassObject(reinterpret_cast<LPVOID *>(pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&p));
-               if (SUCCEEDED(hResult))
-                       hResult = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
-
-               if (p != NULL)
-                       p->Release();
-
-               return hResult;
-       }
+    const CLSID *pclsid;
+    HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister);
+    _ATL_CREATORFUNC *pfnGetClassObject;
+    _ATL_CREATORFUNC *pfnCreateInstance;
+    IUnknown *pCF;
+    DWORD dwRegister;
+    _ATL_DESCRIPTIONFUNC *pfnGetObjectDescription;
+    _ATL_CATMAPFUNC *pfnGetCategoryMap;
+    void (WINAPI *pfnObjectMain)(bool bStarting);
+
+    HRESULT WINAPI RevokeClassObject()
+    {
+        if (dwRegister == 0)
+            return S_OK;
+        return CoRevokeClassObject(dwRegister);
+    }
+
+    HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
+    {
+        IUnknown *p;
+        HRESULT hResult;
+
+        p = NULL;
+        if (pfnGetClassObject == NULL)
+            return S_OK;
+
+        hResult = pfnGetClassObject(reinterpret_cast<LPVOID *>(pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&p));
+        if (SUCCEEDED(hResult))
+            hResult = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
+
+        if (p != NULL)
+            p->Release();
+
+        return hResult;
+    }
 };
 
 typedef _ATL_OBJMAP_ENTRY30 _ATL_OBJMAP_ENTRY;
@@ -111,17 +111,17 @@ typedef void (__stdcall _ATL_TERMFUNC)(DWORD_PTR dw);
 
 struct _ATL_TERMFUNC_ELEM
 {
-       _ATL_TERMFUNC                                                   *pFunc;
-       DWORD_PTR                                                               dw;
-       _ATL_TERMFUNC_ELEM                                              *pNext;
+    _ATL_TERMFUNC *pFunc;
+    DWORD_PTR dw;
+    _ATL_TERMFUNC_ELEM *pNext;
 };
 
 struct _ATL_MODULE70
 {
-       UINT                                                                    cbSize;
-       LONG                                                                    m_nLockCnt;
-       _ATL_TERMFUNC_ELEM                                              *m_pTermFuncs;
-       CComCriticalSection                                             m_csStaticDataInitAndTypeInfo;
+    UINT cbSize;
+    LONG m_nLockCnt;
+    _ATL_TERMFUNC_ELEM *m_pTermFuncs;
+    CComCriticalSection m_csStaticDataInitAndTypeInfo;
 };
 typedef _ATL_MODULE70 _ATL_MODULE;
 
@@ -131,43 +131,43 @@ typedef HRESULT (WINAPI _ATL_CREATORARGFUNC)(void *pv, REFIID riid, LPVOID *ppv,
 
 struct _ATL_INTMAP_ENTRY
 {
-       const IID                                                               *piid;
-       DWORD_PTR                                                               dw;
-       _ATL_CREATORARGFUNC                                             *pFunc;
+    const IID *piid;
+    DWORD_PTR dw;
+    _ATL_CREATORARGFUNC *pFunc;
 };
 
 struct _AtlCreateWndData
 {
-       void                                                                    *m_pThis;
-       DWORD                                                                   m_dwThreadID;
-       _AtlCreateWndData                                               *m_pNext;
+    void *m_pThis;
+    DWORD m_dwThreadID;
+    _AtlCreateWndData *m_pNext;
 };
 
 struct _ATL_COM_MODULE70
 {
-       UINT                                                                    cbSize;
-       HINSTANCE                                                               m_hInstTypeLib;
-       _ATL_OBJMAP_ENTRY                                               **m_ppAutoObjMapFirst;
-       _ATL_OBJMAP_ENTRY                                               **m_ppAutoObjMapLast;
-       CComCriticalSection                                             m_csObjMap;
+    UINT cbSize;
+    HINSTANCE m_hInstTypeLib;
+    _ATL_OBJMAP_ENTRY **m_ppAutoObjMapFirst;
+    _ATL_OBJMAP_ENTRY **m_ppAutoObjMapLast;
+    CComCriticalSection m_csObjMap;
 };
 typedef _ATL_COM_MODULE70 _ATL_COM_MODULE;
 
 struct _ATL_WIN_MODULE70
 {
-       UINT                                                                    cbSize;
-       CComCriticalSection                                             m_csWindowCreate;
-       _AtlCreateWndData                                               *m_pCreateWndList;
+    UINT cbSize;
+    CComCriticalSection m_csWindowCreate;
+    _AtlCreateWndData *m_pCreateWndList;
 #ifdef NOTYET
-       CSimpleArray<ATOM>                                              m_rgWindowClassAtoms;
+    CSimpleArray<ATOM>                        m_rgWindowClassAtoms;
 #endif
 };
 typedef _ATL_WIN_MODULE70 _ATL_WIN_MODULE;
 
 struct _ATL_REGMAP_ENTRY
 {
-       LPCOLESTR                                                               szKey;
-       LPCOLESTR                                                               szData;
+    LPCOLESTR szKey;
+    LPCOLESTR szData;
 };
 
 HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule);
@@ -181,137 +181,137 @@ template<class TLock>
 class CComCritSecLock
 {
 private:
-       bool                                                                            m_bLocked;
-       TLock                                                                           &m_cs;
+    bool m_bLocked;
+    TLock &m_cs;
 public:
-       CComCritSecLock(TLock &cs, bool bInitialLock = true) : m_cs(cs)
-       {
-               HRESULT                                                                 hResult;
-
-               m_bLocked = false;
-               if (bInitialLock)
-               {
-                       hResult = Lock();
-                       if (FAILED(hResult))
-                       {
-                               ATLASSERT(false);
-                       }
-               }
-       }
-
-       ~CComCritSecLock()
-       {
-               if (m_bLocked)
-                       Unlock();
-       }
-
-       HRESULT Lock()
-       {
-               HRESULT                                                                 hResult;
-
-               ATLASSERT(!m_bLocked);
-               hResult = m_cs.Lock();
-               if (FAILED(hResult))
-                       return hResult;
-               m_bLocked = true;
-
-               return S_OK;
-       }
-
-       void Unlock()
-       {
-               HRESULT                                                                 hResult;
-
-               ATLASSERT(m_bLocked);
-               hResult = m_cs.Unlock();
-               if (FAILED(hResult))
-               {
-                       ATLASSERT(false);
-               }
-               m_bLocked = false;
-       }
+    CComCritSecLock(TLock &cs, bool bInitialLock = true) : m_cs(cs)
+    {
+        HRESULT hResult;
+
+        m_bLocked = false;
+        if (bInitialLock)
+        {
+            hResult = Lock();
+            if (FAILED(hResult))
+            {
+                ATLASSERT(false);
+            }
+        }
+    }
+
+    ~CComCritSecLock()
+    {
+        if (m_bLocked)
+            Unlock();
+    }
+
+    HRESULT Lock()
+    {
+        HRESULT                                    hResult;
+
+        ATLASSERT(!m_bLocked);
+        hResult = m_cs.Lock();
+        if (FAILED(hResult))
+            return hResult;
+        m_bLocked = true;
+
+        return S_OK;
+    }
+
+    void Unlock()
+    {
+        HRESULT                                    hResult;
+
+        ATLASSERT(m_bLocked);
+        hResult = m_cs.Unlock();
+        if (FAILED(hResult))
+        {
+            ATLASSERT(false);
+        }
+        m_bLocked = false;
+    }
 };
 
 inline BOOL WINAPI InlineIsEqualUnknown(REFGUID rguid1)
 {
    return (
-         ((unsigned long *)&rguid1)[0] == 0 &&
-         ((unsigned long *)&rguid1)[1] == 0 &&
-         ((unsigned long *)&rguid1)[2] == 0x000000C0 &&
-         ((unsigned long *)&rguid1)[3] == 0x46000000);
+      ((unsigned long *)&rguid1)[0] == 0 &&
+      ((unsigned long *)&rguid1)[1] == 0 &&
+      ((unsigned long *)&rguid1)[2] == 0x000000C0 &&
+      ((unsigned long *)&rguid1)[3] == 0x46000000);
 }
 
 class CComMultiThreadModelNoCS
 {
 public:
-       typedef CComFakeCriticalSection AutoCriticalSection;
-       typedef CComFakeCriticalSection CriticalSection;
-       typedef CComMultiThreadModelNoCS ThreadModelNoCS;
-       typedef CComFakeCriticalSection AutoDeleteCriticalSection;
-
-       static ULONG WINAPI Increment(LPLONG p)
-       {
-               return InterlockedIncrement(p);
-       }
-
-       static ULONG WINAPI Decrement(LPLONG p)
-       {
-               return InterlockedDecrement(p);
-       }
+    typedef CComFakeCriticalSection AutoCriticalSection;
+    typedef CComFakeCriticalSection CriticalSection;
+    typedef CComMultiThreadModelNoCS ThreadModelNoCS;
+    typedef CComFakeCriticalSection AutoDeleteCriticalSection;
+
+    static ULONG WINAPI Increment(LPLONG p)
+    {
+        return InterlockedIncrement(p);
+    }
+
+    static ULONG WINAPI Decrement(LPLONG p)
+    {
+        return InterlockedDecrement(p);
+    }
 };
 
 class CComMultiThreadModel
 {
 public:
-       typedef CComAutoCriticalSection AutoCriticalSection;
-       typedef CComCriticalSection CriticalSection;
-       typedef CComMultiThreadModelNoCS ThreadModelNoCS;
-       typedef CComAutoDeleteCriticalSection AutoDeleteCriticalSection;
-
-       static ULONG WINAPI Increment(LPLONG p)
-       {
-               return InterlockedIncrement(p);
-       }
-
-       static ULONG WINAPI Decrement(LPLONG p)
-       {
-               return InterlockedDecrement(p);
-       }
+    typedef CComAutoCriticalSection AutoCriticalSection;
+    typedef CComCriticalSection CriticalSection;
+    typedef CComMultiThreadModelNoCS ThreadModelNoCS;
+    typedef CComAutoDeleteCriticalSection AutoDeleteCriticalSection;
+
+    static ULONG WINAPI Increment(LPLONG p)
+    {
+        return InterlockedIncrement(p);
+    }
+
+    static ULONG WINAPI Decrement(LPLONG p)
+    {
+        return InterlockedDecrement(p);
+    }
 };
 
 class CComSingleThreadModel
 {
 public:
-       typedef CComFakeCriticalSection AutoCriticalSection;
-       typedef CComFakeCriticalSection CriticalSection;
-       typedef CComSingleThreadModel ThreadModelNoCS;
-       typedef CComFakeCriticalSection AutoDeleteCriticalSection;
-
-       static ULONG WINAPI Increment(LPLONG p)
-       {
-               return ++*p;
-       }
-
-       static ULONG WINAPI Decrement(LPLONG p)
-       {
-               return --*p;
-       }
+    typedef CComFakeCriticalSection AutoCriticalSection;
+    typedef CComFakeCriticalSection CriticalSection;
+    typedef CComSingleThreadModel ThreadModelNoCS;
+    typedef CComFakeCriticalSection AutoDeleteCriticalSection;
+
+    static ULONG WINAPI Increment(LPLONG p)
+    {
+        return ++*p;
+    }
+
+    static ULONG WINAPI Decrement(LPLONG p)
+    {
+        return --*p;
+    }
 };
 
 #if defined(_ATL_FREE_THREADED)
 
-       typedef CComMultiThreadModel CComObjectThreadModel;
-       typedef CComMultiThreadModel CComGlobalsThreadModel;
+    typedef CComMultiThreadModel CComObjectThreadModel;
+    typedef CComMultiThreadModel CComGlobalsThreadModel;
 
 #elif defined(_ATL_APARTMENT_THREADED)
 
-       typedef CComSingleThreadModel CComObjectThreadModel;
-       typedef CComMultiThreadModel CComGlobalsThreadModel;
+    typedef CComSingleThreadModel CComObjectThreadModel;
+    typedef CComMultiThreadModel CComGlobalsThreadModel;
 
 #elif defined(_ATL_SINGLE_THREADED)
 
-       typedef CComSingleThreadModel CComObjectThreadModel;
-       typedef CComSingleThreadModel CComGlobalsThreadModel;
+    typedef CComSingleThreadModel CComObjectThreadModel;
+    typedef CComSingleThreadModel CComGlobalsThreadModel;
 
 #else
 #error No threading model
@@ -320,416 +320,416 @@ public:
 class CAtlModule : public _ATL_MODULE
 {
 protected:
-       static GUID                                                             m_libid;
+    static GUID m_libid;
 public:
-       CAtlModule()
-       {
-               ATLASSERT(_pAtlModule == NULL);
-               _pAtlModule = this;
-               cbSize = sizeof(_ATL_MODULE);
-               m_nLockCnt = 0;
-       }
-
-       virtual LONG GetLockCount()
-       {
-               return m_nLockCnt;
-       }
-
-       virtual LONG Lock()
-       {
-               return CComGlobalsThreadModel::Increment(&m_nLockCnt);
-       }
-
-       virtual LONG Unlock()
-       {
-               return CComGlobalsThreadModel::Decrement(&m_nLockCnt);
-       }
-
-       virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* /*pRegistrar*/) = 0;
-
-       HRESULT WINAPI UpdateRegistryFromResource(LPCTSTR lpszRes, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
-       {
-               CRegObject                                                              registrar;
-               TCHAR                                                                   modulePath[MAX_PATH];
-               HRESULT                                                                 hResult;
-
-               hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
-               if (FAILED(hResult))
-                       return hResult;
-
-               if (bRegister != FALSE)
-                       hResult = registrar.ResourceRegisterSz(modulePath, lpszRes, _T("REGISTRY"));
-               else
-                       hResult = registrar.ResourceUnregisterSz(modulePath, lpszRes, _T("REGISTRY"));
-
-               return hResult;
-       }
-
-       HRESULT WINAPI UpdateRegistryFromResource(UINT nResID, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
-       {
-               CRegObject                                                              registrar;
-               TCHAR                                                                   modulePath[MAX_PATH];
-               HRESULT                                                                 hResult;
-
-               hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
-               if (FAILED(hResult))
-                       return hResult;
-
-               if (bRegister != FALSE)
-                       hResult = registrar.ResourceRegister(modulePath, nResID, _T("REGISTRY"));
-               else
-                       hResult = registrar.ResourceUnregister(modulePath, nResID, _T("REGISTRY"));
-
-               return hResult;
-       }
+    CAtlModule()
+    {
+        ATLASSERT(_pAtlModule == NULL);
+        _pAtlModule = this;
+        cbSize = sizeof(_ATL_MODULE);
+        m_nLockCnt = 0;
+    }
+
+    virtual LONG GetLockCount()
+    {
+        return m_nLockCnt;
+    }
+
+    virtual LONG Lock()
+    {
+        return CComGlobalsThreadModel::Increment(&m_nLockCnt);
+    }
+
+    virtual LONG Unlock()
+    {
+        return CComGlobalsThreadModel::Decrement(&m_nLockCnt);
+    }
+
+    virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* /*pRegistrar*/) = 0;
+
+    HRESULT WINAPI UpdateRegistryFromResource(LPCTSTR lpszRes, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
+    {
+        CRegObject registrar;
+        TCHAR modulePath[MAX_PATH];
+        HRESULT hResult;
+
+        hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
+        if (FAILED(hResult))
+            return hResult;
+
+        if (bRegister != FALSE)
+            hResult = registrar.ResourceRegisterSz(modulePath, lpszRes, _T("REGISTRY"));
+        else
+            hResult = registrar.ResourceUnregisterSz(modulePath, lpszRes, _T("REGISTRY"));
+
+        return hResult;
+    }
+
+    HRESULT WINAPI UpdateRegistryFromResource(UINT nResID, BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries = NULL)
+    {
+        CRegObject registrar;
+        TCHAR modulePath[MAX_PATH];
+        HRESULT hResult;
+
+        hResult = CommonInitRegistrar(registrar, modulePath, sizeof(modulePath) / sizeof(modulePath[0]), pMapEntries);
+        if (FAILED(hResult))
+            return hResult;
+
+        if (bRegister != FALSE)
+            hResult = registrar.ResourceRegister(modulePath, nResID, _T("REGISTRY"));
+        else
+            hResult = registrar.ResourceUnregister(modulePath, nResID, _T("REGISTRY"));
+
+        return hResult;
+    }
 
 private:
-       HRESULT CommonInitRegistrar(CRegObject &registrar, TCHAR *modulePath, DWORD modulePathCount, struct _ATL_REGMAP_ENTRY *pMapEntries)
-       {
-               HINSTANCE                                                               hInstance;
-               DWORD                                                                   dwFLen;
-               HRESULT                                                                 hResult;
-
-               hInstance = _AtlBaseModule.GetModuleInstance();
-               dwFLen = GetModuleFileName(hInstance, modulePath, modulePathCount);
-               if (dwFLen == modulePathCount)
-                       return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-               else if (dwFLen == 0)
-                       return HRESULT_FROM_WIN32(GetLastError());
-
-               if (pMapEntries != NULL)
-               {
-                       while (pMapEntries->szKey != NULL)
-                       {
-                               ATLASSERT(pMapEntries->szData != NULL);
-                               hResult = registrar.AddReplacement(pMapEntries->szKey, pMapEntries->szData);
-                               if (FAILED(hResult))
-                                       return hResult;
-                               pMapEntries++;
-                       }
-               }
-
-               hResult = AddCommonRGSReplacements(&registrar);
-               if (FAILED(hResult))
-                       return hResult;
-
-               hResult = registrar.AddReplacement(_T("Module"), modulePath);
-               if (FAILED(hResult))
-                       return hResult;
-
-               hResult = registrar.AddReplacement(_T("Module_Raw"), modulePath);
-               if (FAILED(hResult))
-                       return hResult;
-
-               return S_OK;
-       }
+    HRESULT CommonInitRegistrar(CRegObject &registrar, TCHAR *modulePath, DWORD modulePathCount, struct _ATL_REGMAP_ENTRY *pMapEntries)
+    {
+        HINSTANCE hInstance;
+        DWORD dwFLen;
+        HRESULT hResult;
+
+        hInstance = _AtlBaseModule.GetModuleInstance();
+        dwFLen = GetModuleFileName(hInstance, modulePath, modulePathCount);
+        if (dwFLen == modulePathCount)
+            return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+        else if (dwFLen == 0)
+            return HRESULT_FROM_WIN32(GetLastError());
+
+        if (pMapEntries != NULL)
+        {
+            while (pMapEntries->szKey != NULL)
+            {
+                ATLASSERT(pMapEntries->szData != NULL);
+                hResult = registrar.AddReplacement(pMapEntries->szKey, pMapEntries->szData);
+                if (FAILED(hResult))
+                    return hResult;
+                pMapEntries++;
+            }
+        }
+
+        hResult = AddCommonRGSReplacements(&registrar);
+        if (FAILED(hResult))
+            return hResult;
+
+        hResult = registrar.AddReplacement(_T("Module"), modulePath);
+        if (FAILED(hResult))
+            return hResult;
+
+        hResult = registrar.AddReplacement(_T("Module_Raw"), modulePath);
+        if (FAILED(hResult))
+            return hResult;
+
+        return S_OK;
+    }
 };
 
-__declspec(selectany) GUID                                     CAtlModule::m_libid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0} };
+__declspec(selectany) GUID CAtlModule::m_libid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0} };
 
 template <class T>
 class CAtlModuleT : public CAtlModule
 {
 public:
 
-       virtual HRESULT AddCommonRGSReplacements(IRegistrarBase *pRegistrar)
-       {
-               return pRegistrar->AddReplacement(L"APPID", T::GetAppId());
-       }
+    virtual HRESULT AddCommonRGSReplacements(IRegistrarBase *pRegistrar)
+    {
+        return pRegistrar->AddReplacement(L"APPID", T::GetAppId());
+    }
 
-       static LPCOLESTR GetAppId()
-       {
-               return L"";
-       }
+    static LPCOLESTR GetAppId()
+    {
+        return L"";
+    }
 };
 
 class CAtlComModule : public _ATL_COM_MODULE
 {
 public:
-       CAtlComModule()
-       {
-               GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInstTypeLib);
-               m_ppAutoObjMapFirst = NULL;
-               m_ppAutoObjMapLast = NULL;
-               if (FAILED(m_csObjMap.Init()))
-               {
-                       ATLASSERT(0);
-                       CAtlBaseModule::m_bInitFailed = true;
-                       return;
-               }
-               cbSize = sizeof(_ATL_COM_MODULE);
-       }
-
-       ~CAtlComModule()
-       {
-               Term();
-       }
-
-       void Term()
-       {
-               if (cbSize != 0)
-               {
-                       ATLASSERT(m_ppAutoObjMapFirst == NULL);
-                       ATLASSERT(m_ppAutoObjMapLast == NULL);
-                       m_csObjMap.Term();
-                       cbSize = 0;
-               }
-       }
+    CAtlComModule()
+    {
+        GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInstTypeLib);
+        m_ppAutoObjMapFirst = NULL;
+        m_ppAutoObjMapLast = NULL;
+        if (FAILED(m_csObjMap.Init()))
+        {
+            ATLASSERT(0);
+            CAtlBaseModule::m_bInitFailed = true;
+            return;
+        }
+        cbSize = sizeof(_ATL_COM_MODULE);
+    }
+
+    ~CAtlComModule()
+    {
+        Term();
+    }
+
+    void Term()
+    {
+        if (cbSize != 0)
+        {
+            ATLASSERT(m_ppAutoObjMapFirst == NULL);
+            ATLASSERT(m_ppAutoObjMapLast == NULL);
+            m_csObjMap.Term();
+            cbSize = 0;
+        }
+    }
 };
 
 template <class T>
 class CAtlDllModuleT : public CAtlModuleT<T>
 {
 public:
-       CAtlDllModuleT()
-       {
-       }
-
-       HRESULT DllCanUnloadNow()
-       {
-               T                                                                       *pThis;
-
-               pThis = static_cast<T *>(this);
-               if (pThis->GetLockCount() == 0)
-                       return S_OK;
-               return S_FALSE;
-       }
-
-       HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
-       {
-               T                                                                       *pThis;
-
-               pThis = static_cast<T *>(this);
-               return pThis->GetClassObject(rclsid, riid, ppv);
-       }
-
-       HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
-       {
-               T                                                                       *pThis;
-               HRESULT                                                         hResult;
-
-               pThis = static_cast<T *>(this);
-               hResult = pThis->RegisterServer(bRegTypeLib);
-               return hResult;
-       }
-
-       HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
-       {
-               T                                                                       *pThis;
-               HRESULT                                                         hResult;
-
-               pThis = static_cast<T *>(this);
-               hResult = pThis->UnregisterServer(bUnRegTypeLib);
-               return hResult;
-       }
-
-       HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
-       {
-               return AtlComModuleGetClassObject(&_AtlComModule, rclsid, riid, ppv);
-       }
+    CAtlDllModuleT()
+    {
+    }
+
+    HRESULT DllCanUnloadNow()
+    {
+        T *pThis;
+
+        pThis = static_cast<T *>(this);
+        if (pThis->GetLockCount() == 0)
+            return S_OK;
+        return S_FALSE;
+    }
+
+    HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
+    {
+        T *pThis;
+
+        pThis = static_cast<T *>(this);
+        return pThis->GetClassObject(rclsid, riid, ppv);
+    }
+
+    HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
+    {
+        T *pThis;
+        HRESULT hResult;
+
+        pThis = static_cast<T *>(this);
+        hResult = pThis->RegisterServer(bRegTypeLib);
+        return hResult;
+    }
+
+    HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
+    {
+        T *pThis;
+        HRESULT hResult;
+
+        pThis = static_cast<T *>(this);
+        hResult = pThis->UnregisterServer(bUnRegTypeLib);
+        return hResult;
+    }
+
+    HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
+    {
+        return AtlComModuleGetClassObject(&_AtlComModule, rclsid, riid, ppv);
+    }
 };
 
 class CComModule : public CAtlModuleT<CComModule>
 {
 public:
-       _ATL_OBJMAP_ENTRY                                               *m_pObjMap;
+    _ATL_OBJMAP_ENTRY *m_pObjMap;
 public:
-       CComModule()
-       {
-               ATLASSERT(_pModule == NULL);
-               _pModule = this;
-               _pModule->m_pObjMap = NULL;
-       }
-
-       ~CComModule()
-       {
-               _pModule = NULL;
-       }
-
-       HRESULT Init(_ATL_OBJMAP_ENTRY *p, HINSTANCE /* h */, const GUID *plibid)
-       {
-               _ATL_OBJMAP_ENTRY                                       *objectMapEntry;
-
-               if (plibid != NULL)
-                       m_libid = *plibid;
-
-               if (p != reinterpret_cast<_ATL_OBJMAP_ENTRY *>(-1))
-               {
-                       m_pObjMap = p;
-                       if (p != NULL)
-                       {
-                               objectMapEntry = p;
-                               while (objectMapEntry->pclsid != NULL)
-                               {
-                                       objectMapEntry->pfnObjectMain(true);
-                                       objectMapEntry++;
-                               }
-                       }
-               }
-               return S_OK;
-       }
-
-       void Term()
-       {
-               _ATL_OBJMAP_ENTRY                                       *objectMapEntry;
-
-               if (m_pObjMap != NULL)
-               {
-                       objectMapEntry = m_pObjMap;
-                       while (objectMapEntry->pclsid != NULL)
-                       {
-                               if (objectMapEntry->pCF != NULL)
-                                       objectMapEntry->pCF->Release();
-                               objectMapEntry->pCF = NULL;
-                               objectMapEntry->pfnObjectMain(false);
-                               objectMapEntry++;
-                       }
-               }
-       }
-
-       HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
-       {
-               _ATL_OBJMAP_ENTRY                                       *objectMapEntry;
-               HRESULT                                                         hResult;
-
-               ATLASSERT(ppv != NULL);
-               if (ppv == NULL)
-                       return E_POINTER;
-               *ppv = NULL;
-               hResult = S_OK;
-               if (m_pObjMap != NULL)
-               {
-                       objectMapEntry = m_pObjMap;
-                       while (objectMapEntry->pclsid != NULL)
-                       {
-                               if (objectMapEntry->pfnGetClassObject != NULL && InlineIsEqualGUID(rclsid, *objectMapEntry->pclsid) != FALSE)
-                               {
-                                       if (objectMapEntry->pCF == NULL)
-                                       {
-                                               CComCritSecLock<CComCriticalSection> lock(_AtlComModule.m_csObjMap, true);
-
-                                               if (objectMapEntry->pCF == NULL)
-                                                       hResult = objectMapEntry->pfnGetClassObject(reinterpret_cast<void *>(objectMapEntry->pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&objectMapEntry->pCF));
-                                       }
-                                       if (objectMapEntry->pCF != NULL)
-                                               hResult = objectMapEntry->pCF->QueryInterface(riid, ppv);
-                                       break;
-                               }
-                               objectMapEntry++;
-                       }
-               }
-               if (hResult == S_OK && *ppv == NULL)
-               {
-                       // FIXME: call AtlComModuleGetClassObject
-                       hResult = CLASS_E_CLASSNOTAVAILABLE;
-               }
-               return hResult;
-       }
-
-       HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
-       {
-               _ATL_OBJMAP_ENTRY                                       *objectMapEntry;
-               HRESULT                                                         hResult;
-
-               hResult = S_OK;
-               objectMapEntry = m_pObjMap;
-               if (objectMapEntry != NULL)
-               {
-                       while (objectMapEntry->pclsid != NULL)
-                       {
-                               if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
-                               {
-                                       hResult = objectMapEntry->pfnUpdateRegistry(TRUE);
-                                       if (FAILED(hResult))
-                                               break;
-                               }
-                               objectMapEntry++;
-                       }
-               }
-               return hResult;
-       }
-
-       HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
-       {
-               _ATL_OBJMAP_ENTRY                                       *objectMapEntry;
-               HRESULT                                                         hResult;
-
-               hResult = S_OK;
-               objectMapEntry = m_pObjMap;
-               if (objectMapEntry != NULL)
-               {
-                       while (objectMapEntry->pclsid != NULL)
-                       {
-                               if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
-                               {
-                                       hResult = objectMapEntry->pfnUpdateRegistry(FALSE); //unregister
-                                       if (FAILED(hResult))
-                                               break;
-                               }
-                               objectMapEntry++;
-                       }
-               }
-               return hResult;
-       }
-
-       HRESULT DllCanUnloadNow()
-       {
-               if (GetLockCount() == 0)
-                       return S_OK;
-               return S_FALSE;
-       }
-
-       HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
-       {
-               return GetClassObject(rclsid, riid, ppv);
-       }
-
-       HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
-       {
-               return RegisterServer(bRegTypeLib);
-       }
-
-       HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
-       {
-               return UnregisterServer(bUnRegTypeLib);
-       }
+    CComModule()
+    {
+        ATLASSERT(_pModule == NULL);
+        _pModule = this;
+        _pModule->m_pObjMap = NULL;
+    }
+
+    ~CComModule()
+    {
+        _pModule = NULL;
+    }
+
+    HRESULT Init(_ATL_OBJMAP_ENTRY *p, HINSTANCE /* h */, const GUID *plibid)
+    {
+        _ATL_OBJMAP_ENTRY *objectMapEntry;
+
+        if (plibid != NULL)
+            m_libid = *plibid;
+
+        if (p != reinterpret_cast<_ATL_OBJMAP_ENTRY *>(-1))
+        {
+            m_pObjMap = p;
+            if (p != NULL)
+            {
+                objectMapEntry = p;
+                while (objectMapEntry->pclsid != NULL)
+                {
+                    objectMapEntry->pfnObjectMain(true);
+                    objectMapEntry++;
+                }
+            }
+        }
+        return S_OK;
+    }
+
+    void Term()
+    {
+        _ATL_OBJMAP_ENTRY                    *objectMapEntry;
+
+        if (m_pObjMap != NULL)
+        {
+            objectMapEntry = m_pObjMap;
+            while (objectMapEntry->pclsid != NULL)
+            {
+                if (objectMapEntry->pCF != NULL)
+                    objectMapEntry->pCF->Release();
+                objectMapEntry->pCF = NULL;
+                objectMapEntry->pfnObjectMain(false);
+                objectMapEntry++;
+            }
+        }
+    }
+
+    HRESULT GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
+    {
+        _ATL_OBJMAP_ENTRY                    *objectMapEntry;
+        HRESULT                                hResult;
+
+        ATLASSERT(ppv != NULL);
+        if (ppv == NULL)
+            return E_POINTER;
+        *ppv = NULL;
+        hResult = S_OK;
+        if (m_pObjMap != NULL)
+        {
+            objectMapEntry = m_pObjMap;
+            while (objectMapEntry->pclsid != NULL)
+            {
+                if (objectMapEntry->pfnGetClassObject != NULL && InlineIsEqualGUID(rclsid, *objectMapEntry->pclsid) != FALSE)
+                {
+                    if (objectMapEntry->pCF == NULL)
+                    {
+                        CComCritSecLock<CComCriticalSection> lock(_AtlComModule.m_csObjMap, true);
+
+                        if (objectMapEntry->pCF == NULL)
+                            hResult = objectMapEntry->pfnGetClassObject(reinterpret_cast<void *>(objectMapEntry->pfnCreateInstance), IID_IUnknown, reinterpret_cast<LPVOID *>(&objectMapEntry->pCF));
+                    }
+                    if (objectMapEntry->pCF != NULL)
+                        hResult = objectMapEntry->pCF->QueryInterface(riid, ppv);
+                    break;
+                }
+                objectMapEntry++;
+            }
+        }
+        if (hResult == S_OK && *ppv == NULL)
+        {
+            // FIXME: call AtlComModuleGetClassObject
+            hResult = CLASS_E_CLASSNOTAVAILABLE;
+        }
+        return hResult;
+    }
+
+    HRESULT RegisterServer(BOOL bRegTypeLib = FALSE, const CLSID *pCLSID = NULL)
+    {
+        _ATL_OBJMAP_ENTRY *objectMapEntry;
+        HRESULT hResult;
+
+        hResult = S_OK;
+        objectMapEntry = m_pObjMap;
+        if (objectMapEntry != NULL)
+        {
+            while (objectMapEntry->pclsid != NULL)
+            {
+                if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
+                {
+                    hResult = objectMapEntry->pfnUpdateRegistry(TRUE);
+                    if (FAILED(hResult))
+                        break;
+                }
+                objectMapEntry++;
+            }
+        }
+        return hResult;
+    }
+
+    HRESULT UnregisterServer(BOOL bUnRegTypeLib, const CLSID *pCLSID = NULL)
+    {
+        _ATL_OBJMAP_ENTRY *objectMapEntry;
+        HRESULT hResult;
+
+        hResult = S_OK;
+        objectMapEntry = m_pObjMap;
+        if (objectMapEntry != NULL)
+        {
+            while (objectMapEntry->pclsid != NULL)
+            {
+                if (pCLSID == NULL || IsEqualGUID(*pCLSID, *objectMapEntry->pclsid) != FALSE)
+                {
+                    hResult = objectMapEntry->pfnUpdateRegistry(FALSE); //unregister
+                    if (FAILED(hResult))
+                        break;
+                }
+                objectMapEntry++;
+            }
+        }
+        return hResult;
+    }
+
+    HRESULT DllCanUnloadNow()
+    {
+        if (GetLockCount() == 0)
+            return S_OK;
+        return S_FALSE;
+    }
+
+    HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
+    {
+        return GetClassObject(rclsid, riid, ppv);
+    }
+
+    HRESULT DllRegisterServer(BOOL bRegTypeLib = TRUE)
+    {
+        return RegisterServer(bRegTypeLib);
+    }
+
+    HRESULT DllUnregisterServer(BOOL bUnRegTypeLib = TRUE)
+    {
+        return UnregisterServer(bUnRegTypeLib);
+    }
 
 };
 
 class CAtlWinModule : public _ATL_WIN_MODULE
 {
 public:
-       CAtlWinModule()
-       {
-               HRESULT                                                         hResult;
-
-               hResult = AtlWinModuleInit(this);
-               if (FAILED(hResult))
-               {
-                       CAtlBaseModule::m_bInitFailed = true;
-                       ATLASSERT(0);
-               }
-       }
-
-       ~CAtlWinModule()
-       {
-               Term();
-       }
-
-       void Term()
-       {
+    CAtlWinModule()
+    {
+        HRESULT hResult;
+
+        hResult = AtlWinModuleInit(this);
+        if (FAILED(hResult))
+        {
+            CAtlBaseModule::m_bInitFailed = true;
+            ATLASSERT(0);
+        }
+    }
+
+    ~CAtlWinModule()
+    {
+        Term();
+    }
+
+    void Term()
+    {
         AtlWinModuleTerm(this, _AtlBaseModule.GetModuleInstance());
-       }
+    }
 
-       void AddCreateWndData(_AtlCreateWndData *pData, void *pObject)
-       {
-               AtlWinModuleAddCreateWndData(this, pData, pObject);
-       }
+    void AddCreateWndData(_AtlCreateWndData *pData, void *pObject)
+    {
+        AtlWinModuleAddCreateWndData(this, pData, pObject);
+    }
 
-       void *ExtractCreateWndData()
-       {
-               return AtlWinModuleExtractCreateWndData(this);
-       }
+    void *ExtractCreateWndData()
+    {
+        return AtlWinModuleExtractCreateWndData(this);
+    }
 };
 
 extern CAtlWinModule _AtlWinModule;
@@ -738,271 +738,271 @@ template<class T>
 class CComPtr
 {
 public:
-       T                                                                               *p;
+    T *p;
 public:
-       CComPtr()
-       {
-               p = NULL;
-       }
-
-       CComPtr(T *lp)
-       {
-               p = lp;
-               if (p != NULL)
-                       p->AddRef();
-       }
-
-       CComPtr(const CComPtr<T> &lp)
-       {
-               p = lp.p;
-               if (p != NULL)
-                       p->AddRef();
-       }
-
-       ~CComPtr()
-       {
-               if (p != NULL)
-                       p->Release();
-       }
-
-       T *operator = (T *lp)
-       {
-               if (p != NULL)
-                       p->Release();
-               p = lp;
-               if (p != NULL)
-                       p->AddRef();
+    CComPtr()
+    {
+        p = NULL;
+    }
+
+    CComPtr(T *lp)
+    {
+        p = lp;
+        if (p != NULL)
+            p->AddRef();
+    }
+
+    CComPtr(const CComPtr<T> &lp)
+    {
+        p = lp.p;
+        if (p != NULL)
+            p->AddRef();
+    }
+
+    ~CComPtr()
+    {
+        if (p != NULL)
+            p->Release();
+    }
+
+    T *operator = (T *lp)
+    {
+        if (p != NULL)
+            p->Release();
+        p = lp;
+        if (p != NULL)
+            p->AddRef();
         return *this;
-       }
-
-       T *operator = (const CComPtr<T> &lp)
-       {
-               if (p != NULL)
-                       p->Release();
-               p = lp.p;
-               if (p != NULL)
-                       p->AddRef();
+    }
+
+    T *operator = (const CComPtr<T> &lp)
+    {
+        if (p != NULL)
+            p->Release();
+        p = lp.p;
+        if (p != NULL)
+            p->AddRef();
         return *this;
-       }
-
-       void Release()
-       {
-               if (p != NULL)
-               {
-                       p->Release();
-                       p = NULL;
-               }
-       }
-
-       void Attach(T *lp)
-       {
-               if (p != NULL)
-                       p->Release();
-               p = lp;
-       }
-
-       T *Detach()
-       {
-               T                                                                       *saveP;
-
-               saveP = p;
-               p = NULL;
-               return saveP;
-       }
-
-       T **operator & ()
-       {
-               ATLASSERT(p == NULL);
-               return &p;
-       }
-
-       operator T * ()
-       {
-               return p;
-       }
-
-       T *operator -> ()
-       {
-               ATLASSERT(p != NULL);
-               return p;
-       }
+    }
+
+    void Release()
+    {
+        if (p != NULL)
+        {
+            p->Release();
+            p = NULL;
+        }
+    }
+
+    void Attach(T *lp)
+    {
+        if (p != NULL)
+            p->Release();
+        p = lp;
+    }
+
+    T *Detach()
+    {
+        T *saveP;
+
+        saveP = p;
+        p = NULL;
+        return saveP;
+    }
+
+    T **operator & ()
+    {
+        ATLASSERT(p == NULL);
+        return &p;
+    }
+
+    operator T * ()
+    {
+        return p;
+    }
+
+    T *operator -> ()
+    {
+        ATLASSERT(p != NULL);
+        return p;
+    }
 };
 
 class CComBSTR
 {
 public:
-       BSTR                                                                    m_str;
+    BSTR m_str;
 public:
-       CComBSTR(LPCOLESTR pSrc)
-       {
-               if (pSrc == NULL)
-                       m_str = NULL;
-               else
-                       m_str = ::SysAllocString(pSrc);
-       }
-       ~CComBSTR()
-       {
-               ::SysFreeString(m_str);
-               m_str = NULL;
-       }
+    CComBSTR(LPCOLESTR pSrc)
+    {
+        if (pSrc == NULL)
+            m_str = NULL;
+        else
+            m_str = ::SysAllocString(pSrc);
+    }
+    ~CComBSTR()
+    {
+        ::SysFreeString(m_str);
+        m_str = NULL;
+    }
 };
 
 class CComVariant : public tagVARIANT
 {
 public:
-       CComVariant()
-       {
-               ::VariantInit(this);
-       }
-
-       ~CComVariant()
-       {
-               Clear();
-       }
-
-       HRESULT Clear()
-       {
-               return ::VariantClear(this);
-       }
+    CComVariant()
+    {
+        ::VariantInit(this);
+    }
+
+    ~CComVariant()
+    {
+        Clear();
+    }
+
+    HRESULT Clear()
+    {
+        return ::VariantClear(this);
+    }
 };
 
 inline HRESULT __stdcall AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID &iid, LPDWORD pdw)
 {
-       CComPtr<IConnectionPointContainer>              container;
-       CComPtr<IConnectionPoint>                               connectionPoint;
-       HRESULT                                                                 hResult;
-
-       if (pUnkCP == NULL)
-               return E_INVALIDARG;
-       hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
-       if (FAILED(hResult))
-               return hResult;
-       hResult = container->FindConnectionPoint(iid, &connectionPoint);
-       if (FAILED(hResult))
-               return hResult;
-       return connectionPoint->Advise(pUnk, pdw);
+    CComPtr<IConnectionPointContainer>        container;
+    CComPtr<IConnectionPoint>                connectionPoint;
+    HRESULT                                    hResult;
+
+    if (pUnkCP == NULL)
+        return E_INVALIDARG;
+    hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
+    if (FAILED(hResult))
+        return hResult;
+    hResult = container->FindConnectionPoint(iid, &connectionPoint);
+    if (FAILED(hResult))
+        return hResult;
+    return connectionPoint->Advise(pUnk, pdw);
 }
 
 inline HRESULT __stdcall AtlUnadvise(IUnknown *pUnkCP, const IID &iid, DWORD dw)
 {
-       CComPtr<IConnectionPointContainer>              container;
-       CComPtr<IConnectionPoint>                               connectionPoint;
-       HRESULT                                                                 hResult;
-
-       if (pUnkCP == NULL)
-               return E_INVALIDARG;
-       hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
-       if (FAILED(hResult))
-               return hResult;
-       hResult = container->FindConnectionPoint(iid, &connectionPoint);
-       if (FAILED(hResult))
-               return hResult;
-       return connectionPoint->Unadvise(dw);
+    CComPtr<IConnectionPointContainer>        container;
+    CComPtr<IConnectionPoint>                connectionPoint;
+    HRESULT                                    hResult;
+
+    if (pUnkCP == NULL)
+        return E_INVALIDARG;
+    hResult = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
+    if (FAILED(hResult))
+        return hResult;
+    hResult = container->FindConnectionPoint(iid, &connectionPoint);
+    if (FAILED(hResult))
+        return hResult;
+    return connectionPoint->Unadvise(dw);
 }
 
 inline HRESULT __stdcall AtlInternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
 {
-       int                                                     i;
-       IUnknown                                        *resultInterface;
-       HRESULT                                         hResult;
-
-       ATLASSERT(pThis != NULL && pEntries != NULL);
-       if (pThis == NULL || pEntries == NULL)
-               return E_INVALIDARG;
-       ATLASSERT(ppvObject != NULL);
-       if (ppvObject == NULL)
-               return E_POINTER;
-
-       if (InlineIsEqualUnknown(iid))
-       {
-               resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[0].dw);
-               *ppvObject = resultInterface;
-               resultInterface->AddRef();
-               return S_OK;
-       }
-
-       i = 0;
-       while (pEntries[i].pFunc != 0)
-       {
-               if (pEntries[i].piid == NULL || InlineIsEqualGUID(iid, *pEntries[i].piid))
-               {
-                       if (pEntries[i].pFunc == reinterpret_cast<_ATL_CREATORARGFUNC *>(1))
-                       {
-                               ATLASSERT(pEntries[i].piid != NULL);
-                               resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[i].dw);
-                               *ppvObject = resultInterface;
-                               resultInterface->AddRef();
-                               return S_OK;
-                       }
-                       else
-                       {
-                               hResult = pEntries[i].pFunc(pThis, iid, ppvObject, 0);
-                               if (hResult == S_OK || (FAILED(hResult) && pEntries[i].piid != NULL))
-                                       return hResult;
-                       }
-                       break;
-               }
-               i++;
-       }
-       *ppvObject = NULL;
-       return E_NOINTERFACE;
+    int i;
+    IUnknown *resultInterface;
+    HRESULT hResult;
+
+    ATLASSERT(pThis != NULL && pEntries != NULL);
+    if (pThis == NULL || pEntries == NULL)
+        return E_INVALIDARG;
+    ATLASSERT(ppvObject != NULL);
+    if (ppvObject == NULL)
+        return E_POINTER;
+
+    if (InlineIsEqualUnknown(iid))
+    {
+        resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[0].dw);
+        *ppvObject = resultInterface;
+        resultInterface->AddRef();
+        return S_OK;
+    }
+
+    i = 0;
+    while (pEntries[i].pFunc != 0)
+    {
+        if (pEntries[i].piid == NULL || InlineIsEqualGUID(iid, *pEntries[i].piid))
+        {
+            if (pEntries[i].pFunc == reinterpret_cast<_ATL_CREATORARGFUNC *>(1))
+            {
+                ATLASSERT(pEntries[i].piid != NULL);
+                resultInterface = reinterpret_cast<IUnknown *>(reinterpret_cast<char *>(pThis) + pEntries[i].dw);
+                *ppvObject = resultInterface;
+                resultInterface->AddRef();
+                return S_OK;
+            }
+            else
+            {
+                hResult = pEntries[i].pFunc(pThis, iid, ppvObject, 0);
+                if (hResult == S_OK || (FAILED(hResult) && pEntries[i].piid != NULL))
+                    return hResult;
+            }
+            break;
+        }
+        i++;
+    }
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
 }
 
 inline HRESULT __stdcall AtlWinModuleInit(_ATL_WIN_MODULE *pWinModule)
 {
-       if (pWinModule == NULL)
-               return E_INVALIDARG;
-       pWinModule->m_pCreateWndList = NULL;
-       return pWinModule->m_csWindowCreate.Init();
+    if (pWinModule == NULL)
+        return E_INVALIDARG;
+    pWinModule->m_pCreateWndList = NULL;
+    return pWinModule->m_csWindowCreate.Init();
 }
 
 inline HRESULT __stdcall AtlWinModuleTerm(_ATL_WIN_MODULE *pWinModule, HINSTANCE hInst)
 {
-       if (pWinModule == NULL)
-               return E_INVALIDARG;
-       pWinModule->m_csWindowCreate.Term();
-       return S_OK;
+    if (pWinModule == NULL)
+        return E_INVALIDARG;
+    pWinModule->m_csWindowCreate.Term();
+    return S_OK;
 }
 
 inline void __stdcall AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pWinModule, _AtlCreateWndData *pData, void *pObject)
 {
-       CComCritSecLock<CComCriticalSection>    lock(pWinModule->m_csWindowCreate, true);
+    CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
 
-       ATLASSERT(pWinModule != NULL);
-       ATLASSERT(pObject != NULL);
+    ATLASSERT(pWinModule != NULL);
+    ATLASSERT(pObject != NULL);
 
-       pData->m_pThis = pObject;
-       pData->m_dwThreadID = ::GetCurrentThreadId();
-       pData->m_pNext = pWinModule->m_pCreateWndList;
-       pWinModule->m_pCreateWndList = pData;
+    pData->m_pThis = pObject;
+    pData->m_dwThreadID = ::GetCurrentThreadId();
+    pData->m_pNext = pWinModule->m_pCreateWndList;
+    pWinModule->m_pCreateWndList = pData;
 }
 
 inline void *__stdcall AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *pWinModule)
 {
-       CComCritSecLock<CComCriticalSection>    lock(pWinModule->m_csWindowCreate, true);
-       void                                                                    *result;
-       _AtlCreateWndData                                               *currentEntry;
-       _AtlCreateWndData                                               **previousLink;
-       DWORD                                                                   threadID;
-
-       ATLASSERT(pWinModule != NULL);
-
-       result = NULL;
-       threadID = GetCurrentThreadId();
-       currentEntry = pWinModule->m_pCreateWndList;
-       previousLink = &pWinModule->m_pCreateWndList;
-       while (currentEntry != NULL)
-       {
-               if (currentEntry->m_dwThreadID == threadID)
-               {
-                       *previousLink = currentEntry->m_pNext;
-                       result = currentEntry->m_pThis;
-                       break;
-               }
-               previousLink = &currentEntry->m_pNext;
-               currentEntry = currentEntry->m_pNext;
-       }
-       return result;
+    CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, true);
+    void *result;
+    _AtlCreateWndData *currentEntry;
+    _AtlCreateWndData **previousLink;
+    DWORD threadID;
+
+    ATLASSERT(pWinModule != NULL);
+
+    result = NULL;
+    threadID = GetCurrentThreadId();
+    currentEntry = pWinModule->m_pCreateWndList;
+    previousLink = &pWinModule->m_pCreateWndList;
+    while (currentEntry != NULL)
+    {
+        if (currentEntry->m_dwThreadID == threadID)
+        {
+            *previousLink = currentEntry->m_pNext;
+            result = currentEntry->m_pThis;
+            break;
+        }
+        previousLink = &currentEntry->m_pNext;
+        currentEntry = currentEntry->m_pNext;
+    }
+    return result;
 }
 
 }; // namespace ATL
index b260e20..336a607 100644 (file)
@@ -33,56 +33,56 @@ class CComEnum;
 class CComObjectRootBase
 {
 public:
-       LONG                                                                    m_dwRef;
+    LONG m_dwRef;
 public:
-       CComObjectRootBase()
-       {
-               m_dwRef = 0;
-       }
-
-       ~CComObjectRootBase()
-       {
-       }
-
-       void SetVoid(void *)
-       {
-       }
-
-       HRESULT _AtlFinalConstruct()
-       {
-               return S_OK;
-       }
-
-       HRESULT FinalConstruct()
-       {
-               return S_OK;
-       }
-
-       void InternalFinalConstructAddRef()
-       {
-       }
-
-       void InternalFinalConstructRelease()
-       {
-       }
-
-       void FinalRelease()
-       {
-       }
-
-       static void WINAPI ObjectMain(bool)
-       {
-       }
-
-       static const struct _ATL_CATMAP_ENTRY *GetCategoryMap()
-       {
-               return NULL;
-       }
-
-       static HRESULT WINAPI InternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
-       {
-               return AtlInternalQueryInterface(pThis, pEntries, iid, ppvObject);
-       }
+    CComObjectRootBase()
+    {
+        m_dwRef = 0;
+    }
+
+    ~CComObjectRootBase()
+    {
+    }
+
+    void SetVoid(void *)
+    {
+    }
+
+    HRESULT _AtlFinalConstruct()
+    {
+        return S_OK;
+    }
+
+    HRESULT FinalConstruct()
+    {
+        return S_OK;
+    }
+
+    void InternalFinalConstructAddRef()
+    {
+    }
+
+    void InternalFinalConstructRelease()
+    {
+    }
+
+    void FinalRelease()
+    {
+    }
+
+    static void WINAPI ObjectMain(bool)
+    {
+    }
+
+    static const struct _ATL_CATMAP_ENTRY *GetCategoryMap()
+    {
+        return NULL;
+    }
+
+    static HRESULT WINAPI InternalQueryInterface(void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
+    {
+        return AtlInternalQueryInterface(pThis, pEntries, iid, ppvObject);
+    }
 
 };
 
@@ -90,106 +90,106 @@ template <class ThreadModel>
 class CComObjectRootEx : public CComObjectRootBase
 {
 private:
-       typename ThreadModel::AutoDeleteCriticalSection         m_critsec;
+    typename ThreadModel::AutoDeleteCriticalSection m_critsec;
 public:
-       ~CComObjectRootEx()
-       {
-       }
-
-       ULONG InternalAddRef()
-       {
-               ATLASSERT(m_dwRef >= 0);
-               return ThreadModel::Increment(&m_dwRef);
-       }
-
-       ULONG InternalRelease()
-       {
-               ATLASSERT(m_dwRef > 0);
-               return ThreadModel::Decrement(&m_dwRef);
-       }
-
-       void Lock()
-       {
-               m_critsec.Lock();
-       }
-
-       void Unlock()
-       {
-               m_critsec.Unlock();
-       }
-
-       HRESULT _AtlInitialConstruct()
-       {
-               return m_critsec.Init();
-       }
+    ~CComObjectRootEx()
+    {
+    }
+
+    ULONG InternalAddRef()
+    {
+        ATLASSERT(m_dwRef >= 0);
+        return ThreadModel::Increment(&m_dwRef);
+    }
+
+    ULONG InternalRelease()
+    {
+        ATLASSERT(m_dwRef > 0);
+        return ThreadModel::Decrement(&m_dwRef);
+    }
+
+    void Lock()
+    {
+        m_critsec.Lock();
+    }
+
+    void Unlock()
+    {
+        m_critsec.Unlock();
+    }
+
+    HRESULT _AtlInitialConstruct()
+    {
+        return m_critsec.Init();
+    }
 };
 
 template <class Base>
 class CComObject : public Base
 {
 public:
-       CComObject(void * = NULL)
-       {
-               _pAtlModule->Lock();
-       }
-
-       virtual ~CComObject()
-       {
-               this->FinalRelease();
-               _pAtlModule->Unlock();
-       }
-
-       STDMETHOD_(ULONG, AddRef)()
-       {
-               return this->InternalAddRef();
-       }
-
-       STDMETHOD_(ULONG, Release)()
-       {
-               ULONG                                                           newRefCount;
-
-               newRefCount = this->InternalRelease();
-               if (newRefCount == 0)
-                       delete this;
-               return newRefCount;
-       }
-
-       STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
-       {
-               return this->_InternalQueryInterface(iid, ppvObject);
-       }
-
-       static HRESULT WINAPI CreateInstance(CComObject<Base> **pp)
-       {
-               CComObject<Base>                                        *newInstance;
-               HRESULT                                                         hResult;
-
-               ATLASSERT(pp != NULL);
-               if (pp == NULL)
-                       return E_POINTER;
-
-               hResult = E_OUTOFMEMORY;
-               newInstance = NULL;
-               ATLTRY(newInstance = new CComObject<Base>())
-               if (newInstance != NULL)
-               {
-                       newInstance->SetVoid(NULL);
-                       newInstance->InternalFinalConstructAddRef();
-                       hResult = newInstance->_AtlInitialConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->FinalConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->_AtlFinalConstruct();
-                       newInstance->InternalFinalConstructRelease();
-                       if (hResult != S_OK)
-                       {
-                               delete newInstance;
-                               newInstance = NULL;
-                       }
-               }
-               *pp = newInstance;
-               return hResult;
-       }
+    CComObject(void * = NULL)
+    {
+        _pAtlModule->Lock();
+    }
+
+    virtual ~CComObject()
+    {
+        this->FinalRelease();
+        _pAtlModule->Unlock();
+    }
+
+    STDMETHOD_(ULONG, AddRef)()
+    {
+        return this->InternalAddRef();
+    }
+
+    STDMETHOD_(ULONG, Release)()
+    {
+        ULONG newRefCount;
+
+        newRefCount = this->InternalRelease();
+        if (newRefCount == 0)
+            delete this;
+        return newRefCount;
+    }
+
+    STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
+    {
+        return this->_InternalQueryInterface(iid, ppvObject);
+    }
+
+    static HRESULT WINAPI CreateInstance(CComObject<Base> **pp)
+    {
+        CComObject<Base> *newInstance;
+        HRESULT hResult;
+
+        ATLASSERT(pp != NULL);
+        if (pp == NULL)
+            return E_POINTER;
+
+        hResult = E_OUTOFMEMORY;
+        newInstance = NULL;
+        ATLTRY(newInstance = new CComObject<Base>())
+        if (newInstance != NULL)
+        {
+            newInstance->SetVoid(NULL);
+            newInstance->InternalFinalConstructAddRef();
+            hResult = newInstance->_AtlInitialConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->FinalConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->_AtlFinalConstruct();
+            newInstance->InternalFinalConstructRelease();
+            if (hResult != S_OK)
+            {
+                delete newInstance;
+                newInstance = NULL;
+            }
+        }
+        *pp = newInstance;
+        return hResult;
+    }
 
 
 };
@@ -198,750 +198,750 @@ template <class Base>
 class CComContainedObject : public Base
 {
 public:
-       IUnknown* m_pUnkOuter;
-       CComContainedObject(void * pv = NULL) : m_pUnkOuter(static_cast<IUnknown*>(pv))
-       {
-       }
-
-       STDMETHOD_(ULONG, AddRef)()
-       {
-               return m_pUnkOuter->AddRef();
-       }
-
-       STDMETHOD_(ULONG, Release)()
-       {
-               return m_pUnkOuter->Release();
-       }
-
-       STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
-       {
-               return m_pUnkOuter->QueryInterface(iid, ppvObject);
-       }
-
-       IUnknown* GetControllingUnknown()
-       {
-               return m_pUnkOuter;
-       }
+    IUnknown* m_pUnkOuter;
+    CComContainedObject(void * pv = NULL) : m_pUnkOuter(static_cast<IUnknown*>(pv))
+    {
+    }
+
+    STDMETHOD_(ULONG, AddRef)()
+    {
+        return m_pUnkOuter->AddRef();
+    }
+
+    STDMETHOD_(ULONG, Release)()
+    {
+        return m_pUnkOuter->Release();
+    }
+
+    STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
+    {
+        return m_pUnkOuter->QueryInterface(iid, ppvObject);
+    }
+
+    IUnknown* GetControllingUnknown()
+    {
+        return m_pUnkOuter;
+    }
 };
 
 template <class contained>
 class CComAggObject : public contained
 {
 public:
-       CComContainedObject<contained> m_contained;
-
-       CComAggObject(void * pv = NULL) : m_contained(static_cast<contained*>(pv))
-       {
-               _pAtlModule->Lock();
-       }
-
-       virtual ~CComAggObject()
-       {
-               this->FinalRelease();
-               _pAtlModule->Unlock();
-       }
-
-       HRESULT FinalConstruct()
-       {
-               return m_contained.FinalConstruct();
-       }
-       void FinalRelease()
-       {
-               m_contained.FinalRelease();
-       }
-
-       STDMETHOD_(ULONG, AddRef)()
-       {
-               return this->InternalAddRef();
-       }
-
-       STDMETHOD_(ULONG, Release)()
-       {
-               ULONG newRefCount;
-               newRefCount = this->InternalRelease();
-               if (newRefCount == 0)
-                       delete this;
-               return newRefCount;
-       }
-
-       STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
-       {
-               if (ppvObject == NULL)
-                       return E_POINTER;
-               if (iid == IID_IUnknown)
-                       *ppvObject = reinterpret_cast<void*>(this);
-               else
-                       return m_contained._InternalQueryInterface(iid, ppvObject);
-               return S_OK;
-       }
-
-       static HRESULT WINAPI CreateInstance(IUnknown * punkOuter, CComAggObject<contained> **pp)
-       {
-               CComAggObject<contained>        *newInstance;
-               HRESULT                                         hResult;
-
-               ATLASSERT(pp != NULL);
-               if (pp == NULL)
-                       return E_POINTER;
-
-               hResult = E_OUTOFMEMORY;
-               newInstance = NULL;
-               ATLTRY(newInstance = new CComAggObject<contained>(punkOuter))
-               if (newInstance != NULL)
-               {
-                       newInstance->SetVoid(NULL);
-                       newInstance->InternalFinalConstructAddRef();
-                       hResult = newInstance->_AtlInitialConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->FinalConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->_AtlFinalConstruct();
-                       newInstance->InternalFinalConstructRelease();
-                       if (hResult != S_OK)
-                       {
-                               delete newInstance;
-                               newInstance = NULL;
-                       }
-               }
-               *pp = newInstance;
-               return hResult;
-       }
+    CComContainedObject<contained> m_contained;
+
+    CComAggObject(void * pv = NULL) : m_contained(static_cast<contained*>(pv))
+    {
+        _pAtlModule->Lock();
+    }
+
+    virtual ~CComAggObject()
+    {
+        this->FinalRelease();
+        _pAtlModule->Unlock();
+    }
+
+    HRESULT FinalConstruct()
+    {
+        return m_contained.FinalConstruct();
+    }
+    void FinalRelease()
+    {
+        m_contained.FinalRelease();
+    }
+
+    STDMETHOD_(ULONG, AddRef)()
+    {
+        return this->InternalAddRef();
+    }
+
+    STDMETHOD_(ULONG, Release)()
+    {
+        ULONG newRefCount;
+        newRefCount = this->InternalRelease();
+        if (newRefCount == 0)
+            delete this;
+        return newRefCount;
+    }
+
+    STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
+    {
+        if (ppvObject == NULL)
+            return E_POINTER;
+        if (iid == IID_IUnknown)
+            *ppvObject = reinterpret_cast<void*>(this);
+        else
+            return m_contained._InternalQueryInterface(iid, ppvObject);
+        return S_OK;
+    }
+
+    static HRESULT WINAPI CreateInstance(IUnknown * punkOuter, CComAggObject<contained> **pp)
+    {
+        CComAggObject<contained> *newInstance;
+        HRESULT hResult;
+
+        ATLASSERT(pp != NULL);
+        if (pp == NULL)
+            return E_POINTER;
+
+        hResult = E_OUTOFMEMORY;
+        newInstance = NULL;
+        ATLTRY(newInstance = new CComAggObject<contained>(punkOuter))
+        if (newInstance != NULL)
+        {
+            newInstance->SetVoid(NULL);
+            newInstance->InternalFinalConstructAddRef();
+            hResult = newInstance->_AtlInitialConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->FinalConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->_AtlFinalConstruct();
+            newInstance->InternalFinalConstructRelease();
+            if (hResult != S_OK)
+            {
+                delete newInstance;
+                newInstance = NULL;
+            }
+        }
+        *pp = newInstance;
+        return hResult;
+    }
 };
 
 template <class contained>
 class CComPolyObject : public contained
 {
 public:
-       CComContainedObject<contained> m_contained;
-
-       CComPolyObject(void * pv = NULL)
-               : m_contained(pv ? static_cast<contained*>(pv) : this)
-       {
-               _pAtlModule->Lock();
-       }
-
-       virtual ~CComPolyObject()
-       {
-               this->FinalRelease();
-               _pAtlModule->Unlock();
-       }
-
-       HRESULT FinalConstruct()
-       {
-               return m_contained.FinalConstruct();
-       }
-       void FinalRelease()
-       {
-               m_contained.FinalRelease();
-       }
-
-       STDMETHOD_(ULONG, AddRef)()
-       {
-               return this->InternalAddRef();
-       }
-
-       STDMETHOD_(ULONG, Release)()
-       {
-               ULONG newRefCount;
-               newRefCount = this->InternalRelease();
-               if (newRefCount == 0)
-                       delete this;
-               return newRefCount;
-       }
-
-       STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
-       {
-               if (ppvObject == NULL)
-                       return E_POINTER;
-               if (iid == IID_IUnknown)
-                       *ppvObject = reinterpret_cast<void*>(this);
-               else
-                       return m_contained._InternalQueryInterface(iid, ppvObject);
-               return S_OK;
-       }
-
-       static HRESULT WINAPI CreateInstance(IUnknown * punkOuter, CComPolyObject<contained> **pp)
-       {
-               CComPolyObject<contained>       *newInstance;
-               HRESULT                                         hResult;
-
-               ATLASSERT(pp != NULL);
-               if (pp == NULL)
-                       return E_POINTER;
-
-               hResult = E_OUTOFMEMORY;
-               newInstance = NULL;
-               ATLTRY(newInstance = new CComPolyObject<contained>(punkOuter))
-               if (newInstance != NULL)
-               {
-                       newInstance->SetVoid(NULL);
-                       newInstance->InternalFinalConstructAddRef();
-                       hResult = newInstance->_AtlInitialConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->FinalConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->_AtlFinalConstruct();
-                       newInstance->InternalFinalConstructRelease();
-                       if (hResult != S_OK)
-                       {
-                               delete newInstance;
-                               newInstance = NULL;
-                       }
-               }
-               *pp = newInstance;
-               return hResult;
-       }
+    CComContainedObject<contained> m_contained;
+
+    CComPolyObject(void * pv = NULL)
+        : m_contained(pv ? static_cast<contained*>(pv) : this)
+    {
+        _pAtlModule->Lock();
+    }
+
+    virtual ~CComPolyObject()
+    {
+        this->FinalRelease();
+        _pAtlModule->Unlock();
+    }
+
+    HRESULT FinalConstruct()
+    {
+        return m_contained.FinalConstruct();
+    }
+    void FinalRelease()
+    {
+        m_contained.FinalRelease();
+    }
+
+    STDMETHOD_(ULONG, AddRef)()
+    {
+        return this->InternalAddRef();
+    }
+
+    STDMETHOD_(ULONG, Release)()
+    {
+        ULONG newRefCount;
+        newRefCount = this->InternalRelease();
+        if (newRefCount == 0)
+            delete this;
+        return newRefCount;
+    }
+
+    STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
+    {
+        if (ppvObject == NULL)
+            return E_POINTER;
+        if (iid == IID_IUnknown)
+            *ppvObject = reinterpret_cast<void*>(this);
+        else
+            return m_contained._InternalQueryInterface(iid, ppvObject);
+        return S_OK;
+    }
+
+    static HRESULT WINAPI CreateInstance(IUnknown * punkOuter, CComPolyObject<contained> **pp)
+    {
+        CComPolyObject<contained> *newInstance;
+        HRESULT hResult;
+
+        ATLASSERT(pp != NULL);
+        if (pp == NULL)
+            return E_POINTER;
+
+        hResult = E_OUTOFMEMORY;
+        newInstance = NULL;
+        ATLTRY(newInstance = new CComPolyObject<contained>(punkOuter))
+        if (newInstance != NULL)
+        {
+            newInstance->SetVoid(NULL);
+            newInstance->InternalFinalConstructAddRef();
+            hResult = newInstance->_AtlInitialConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->FinalConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->_AtlFinalConstruct();
+            newInstance->InternalFinalConstructRelease();
+            if (hResult != S_OK)
+            {
+                delete newInstance;
+                newInstance = NULL;
+            }
+        }
+        *pp = newInstance;
+        return hResult;
+    }
 };
 
 template <HRESULT hResult>
 class CComFailCreator
 {
 public:
-       static HRESULT WINAPI CreateInstance(void *, REFIID, LPVOID *ppv)
-       {
-               ATLASSERT(ppv != NULL);
-               if (ppv == NULL)
-                       return E_POINTER;
-               *ppv = NULL;
-
-               return hResult;
-       }
+    static HRESULT WINAPI CreateInstance(void *, REFIID, LPVOID *ppv)
+    {
+        ATLASSERT(ppv != NULL);
+        if (ppv == NULL)
+            return E_POINTER;
+        *ppv = NULL;
+
+        return hResult;
+    }
 };
 
 template <class T1>
 class CComCreator
 {
 public:
-       static HRESULT WINAPI CreateInstance(void *pv, REFIID riid, LPVOID *ppv)
-       {
-               T1                                                                      *newInstance;
-               HRESULT                                                         hResult;
-
-               ATLASSERT(ppv != NULL);
-               if (ppv == NULL)
-                       return E_POINTER;
-               *ppv = NULL;
-
-               hResult = E_OUTOFMEMORY;
-               newInstance = NULL;
-               ATLTRY(newInstance = new T1(pv))
-               if (newInstance != NULL)
-               {
-                       newInstance->SetVoid(pv);
-                       newInstance->InternalFinalConstructAddRef();
-                       hResult = newInstance->_AtlInitialConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->FinalConstruct();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->_AtlFinalConstruct();
-                       newInstance->InternalFinalConstructRelease();
-                       if (SUCCEEDED(hResult))
-                               hResult = newInstance->QueryInterface(riid, ppv);
-                       if (FAILED(hResult))
-                       {
-                               delete newInstance;
-                               newInstance = NULL;
-                       }
-               }
-               return hResult;
-       }
+    static HRESULT WINAPI CreateInstance(void *pv, REFIID riid, LPVOID *ppv)
+    {
+        T1 *newInstance;
+        HRESULT hResult;
+
+        ATLASSERT(ppv != NULL);
+        if (ppv == NULL)
+            return E_POINTER;
+        *ppv = NULL;
+
+        hResult = E_OUTOFMEMORY;
+        newInstance = NULL;
+        ATLTRY(newInstance = new T1(pv))
+        if (newInstance != NULL)
+        {
+            newInstance->SetVoid(pv);
+            newInstance->InternalFinalConstructAddRef();
+            hResult = newInstance->_AtlInitialConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->FinalConstruct();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->_AtlFinalConstruct();
+            newInstance->InternalFinalConstructRelease();
+            if (SUCCEEDED(hResult))
+                hResult = newInstance->QueryInterface(riid, ppv);
+            if (FAILED(hResult))
+            {
+                delete newInstance;
+                newInstance = NULL;
+            }
+        }
+        return hResult;
+    }
 };
 
 template <class T1, class T2>
 class CComCreator2
 {
 public:
-       static HRESULT WINAPI CreateInstance(void *pv, REFIID riid, LPVOID *ppv)
-       {
-               ATLASSERT(ppv != NULL && riid != NULL);
-
-               if (pv == NULL)
-                       return T1::CreateInstance(NULL, riid, ppv);
-               else
-                       return T2::CreateInstance(pv, riid, ppv);
-       }
+    static HRESULT WINAPI CreateInstance(void *pv, REFIID riid, LPVOID *ppv)
+    {
+        ATLASSERT(ppv != NULL && riid != NULL);
+
+        if (pv == NULL)
+            return T1::CreateInstance(NULL, riid, ppv);
+        else
+            return T2::CreateInstance(pv, riid, ppv);
+    }
 };
 
 template <class Base>
 class CComObjectCached : public Base
 {
 public:
-       CComObjectCached(void * = NULL)
-       {
-       }
-
-       STDMETHOD_(ULONG, AddRef)()
-       {
-               ULONG                                                           newRefCount;
-
-               newRefCount = this->InternalAddRef();
-               if (newRefCount == 2)
-                       _pAtlModule->Lock();
-               return newRefCount;
-       }
-
-       STDMETHOD_(ULONG, Release)()
-       {
-               ULONG                                                           newRefCount;
-
-               newRefCount = this->InternalRelease();
-               if (newRefCount == 0)
-                       delete this;
-               else if (newRefCount == 1)
-                       _pAtlModule->Unlock();
-               return newRefCount;
-       }
-
-       STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
-       {
-               return this->_InternalQueryInterface(iid, ppvObject);
-       }
+    CComObjectCached(void * = NULL)
+    {
+    }
+
+    STDMETHOD_(ULONG, AddRef)()
+    {
+        ULONG newRefCount;
+
+        newRefCount = this->InternalAddRef();
+        if (newRefCount == 2)
+            _pAtlModule->Lock();
+        return newRefCount;
+    }
+
+    STDMETHOD_(ULONG, Release)()
+    {
+        ULONG newRefCount;
+
+        newRefCount = this->InternalRelease();
+        if (newRefCount == 0)
+            delete this;
+        else if (newRefCount == 1)
+            _pAtlModule->Unlock();
+        return newRefCount;
+    }
+
+    STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
+    {
+        return this->_InternalQueryInterface(iid, ppvObject);
+    }
 };
 
-#define BEGIN_COM_MAP(x)                                                                                                               \
-public:                                                                                                                                                        \
-       typedef x _ComMapClass;                                                                                                         \
-       HRESULT _InternalQueryInterface(REFIID iid, void **ppvObject)                           \
-       {                                                                                                                                                       \
-               return this->InternalQueryInterface(this, _GetEntries(), iid, ppvObject);               \
-       }                                                                                                                                                       \
-       const static ATL::_ATL_INTMAP_ENTRY *WINAPI _GetEntries()                                       \
-       {                                                                                                                                                       \
-               static const ATL::_ATL_INTMAP_ENTRY _entries[] = {
-
-#define END_COM_MAP()                                                                                                                  \
-                       {NULL, 0, 0}                                                                                                            \
-               };                                                                                                                                              \
-               return _entries;                                                                                                                \
-       }                                                                                                                                                       \
-       virtual ULONG STDMETHODCALLTYPE AddRef() = 0;                                                           \
-       virtual ULONG STDMETHODCALLTYPE Release() = 0;                                                          \
-       STDMETHOD(QueryInterface)(REFIID, void **) = 0;
-
-#define COM_INTERFACE_ENTRY_IID(iid, x)                                                                                        \
-       {&iid, offsetofclass(x, _ComMapClass), _ATL_SIMPLEMAPENTRY},
+#define BEGIN_COM_MAP(x)                                                        \
+public:                                                                            \
+    typedef x _ComMapClass;                                                        \
+    HRESULT _InternalQueryInterface(REFIID iid, void **ppvObject)                \
+    {                                                                            \
+        return this->InternalQueryInterface(this, _GetEntries(), iid, ppvObject);        \
+    }                                                                            \
+    const static ATL::_ATL_INTMAP_ENTRY *WINAPI _GetEntries()                    \
+    {                                                                            \
+        static const ATL::_ATL_INTMAP_ENTRY _entries[] = {
+
+#define END_COM_MAP()                                                            \
+            {NULL, 0, 0}                                                        \
+        };                                                                        \
+        return _entries;                                                        \
+    }                                                                            \
+    virtual ULONG STDMETHODCALLTYPE AddRef() = 0;                                \
+    virtual ULONG STDMETHODCALLTYPE Release() = 0;                                \
+    STDMETHOD(QueryInterface)(REFIID, void **) = 0;
+
+#define COM_INTERFACE_ENTRY_IID(iid, x)                                            \
+    {&iid, offsetofclass(x, _ComMapClass), _ATL_SIMPLEMAPENTRY},
 
 #define COM_INTERFACE_ENTRY(x)                                                  \
-       {&_ATL_IIDOF(x),                                                            \
-       offsetofclass(x, _ComMapClass),                                             \
-       _ATL_SIMPLEMAPENTRY},
-
-#define COM_INTERFACE_ENTRY2_IID(iid, x, x2)                                                                   \
-       {&iid,                                                                                                                                          \
-                       reinterpret_cast<DWORD_PTR>(static_cast<x *>(static_cast<x2 *>(reinterpret_cast<_ComMapClass *>(_ATL_PACKING)))) - _ATL_PACKING,        \
-                       _ATL_SIMPLEMAPENTRY},
-
-#define COM_INTERFACE_ENTRY_BREAK(x)                                                                                   \
-    {&_ATL_IIDOF(x),                                                                                                                   \
-    NULL,                                                                                                                                              \
+    {&_ATL_IIDOF(x),                                                            \
+    offsetofclass(x, _ComMapClass),                                             \
+    _ATL_SIMPLEMAPENTRY},
+
+#define COM_INTERFACE_ENTRY2_IID(iid, x, x2)                                    \
+    {&iid,                                                                        \
+            reinterpret_cast<DWORD_PTR>(static_cast<x *>(static_cast<x2 *>(reinterpret_cast<_ComMapClass *>(_ATL_PACKING)))) - _ATL_PACKING,    \
+            _ATL_SIMPLEMAPENTRY},
+
+#define COM_INTERFACE_ENTRY_BREAK(x)                                            \
+    {&_ATL_IIDOF(x),                                                            \
+    NULL,                                                                        \
     _Break},    // Break is a function that issues int 3.
 
-#define COM_INTERFACE_ENTRY_NOINTERFACE(x)                                                                             \
-    {&_ATL_IIDOF(x),                                                                                                                   \
-    NULL,                                                                                                                                              \
+#define COM_INTERFACE_ENTRY_NOINTERFACE(x)                                        \
+    {&_ATL_IIDOF(x),                                                            \
+    NULL,                                                                        \
     _NoInterface}, // NoInterface returns E_NOINTERFACE.
 
-#define COM_INTERFACE_ENTRY_FUNC(iid, dw, func)                                                                        \
-    {&iid,                                                                                                                                             \
-    dw,                                                                                                                                                        \
+#define COM_INTERFACE_ENTRY_FUNC(iid, dw, func)                                    \
+    {&iid,                                                                        \
+    dw,                                                                            \
     func},
 
-#define COM_INTERFACE_ENTRY_FUNC_BLIND(dw, func)                                                               \
-    {NULL,                                                                                                                                             \
-    dw,                                                                                                                                                        \
+#define COM_INTERFACE_ENTRY_FUNC_BLIND(dw, func)                                \
+    {NULL,                                                                        \
+    dw,                                                                            \
     func},
 
-#define COM_INTERFACE_ENTRY_CHAIN(classname)                                                                   \
-    {NULL,                                                                                                                                             \
-    reinterpret_cast<DWORD>(&_CComChainData<classname, _ComMapClass>::data),   \
+#define COM_INTERFACE_ENTRY_CHAIN(classname)                                    \
+    {NULL,                                                                        \
+    reinterpret_cast<DWORD>(&_CComChainData<classname, _ComMapClass>::data),    \
     _Chain},
 
 #define DECLARE_NO_REGISTRY()\
-       static HRESULT WINAPI UpdateRegistry(BOOL /*bRegister*/)                                        \
-       {                                                                                                                                                       \
-               return S_OK;                                                                                                                    \
-       }
+    static HRESULT WINAPI UpdateRegistry(BOOL /*bRegister*/)                    \
+    {                                                                            \
+        return S_OK;                                                            \
+    }
 
-#define DECLARE_REGISTRY_RESOURCEID(x)                                                                                 \
-       static HRESULT WINAPI UpdateRegistry(BOOL bRegister)                                            \
-       {                                                                                                                                                       \
-               return ATL::_pAtlModule->UpdateRegistryFromResource(x, bRegister);              \
-       }
+#define DECLARE_REGISTRY_RESOURCEID(x)                                            \
+    static HRESULT WINAPI UpdateRegistry(BOOL bRegister)                        \
+    {                                                                            \
+        return ATL::_pAtlModule->UpdateRegistryFromResource(x, bRegister);        \
+    }
 
-#define DECLARE_NOT_AGGREGATABLE(x)                                                                                            \
-public:                                                                                                                                                        \
-       typedef ATL::CComCreator2<ATL::CComCreator<ATL::CComObject<x> >, ATL::CComFailCreator<CLASS_E_NOAGGREGATION> > _CreatorClass;
+#define DECLARE_NOT_AGGREGATABLE(x)                                                \
+public:                                                                            \
+    typedef ATL::CComCreator2<ATL::CComCreator<ATL::CComObject<x> >, ATL::CComFailCreator<CLASS_E_NOAGGREGATION> > _CreatorClass;
 
-#define DECLARE_AGGREGATABLE(x)                                                                                                        \
-public:                                                                                                                                                        \
-       typedef ATL::CComCreator2<ATL::CComCreator<ATL::CComObject<x> >, ATL::CComCreator<ATL::CComAggObject<x> > > _CreatorClass;
+#define DECLARE_AGGREGATABLE(x)                                                    \
+public:                                                                            \
+    typedef ATL::CComCreator2<ATL::CComCreator<ATL::CComObject<x> >, ATL::CComCreator<ATL::CComAggObject<x> > > _CreatorClass;
 
-#define DECLARE_ONLY_AGGREGATABLE(x)                                                                                   \
-public:                                                                                                                                                        \
-       typedef ATL::CComCreator2<ATL::CComFailCreator<E_FAIL>, ATL::CComCreator<ATL::CComAggObject<x> > > _CreatorClass;
+#define DECLARE_ONLY_AGGREGATABLE(x)                                            \
+public:                                                                            \
+    typedef ATL::CComCreator2<ATL::CComFailCreator<E_FAIL>, ATL::CComCreator<ATL::CComAggObject<x> > > _CreatorClass;
 
-#define DECLARE_POLY_AGGREGATABLE(x)                                                                                   \
-public:                                                                                                                                                        \
-       typedef ATL::CComCreator<ATL::CComPolyObject<x> > _CreatorClass;
+#define DECLARE_POLY_AGGREGATABLE(x)                                            \
+public:                                                                            \
+    typedef ATL::CComCreator<ATL::CComPolyObject<x> > _CreatorClass;
 
 #define COM_INTERFACE_ENTRY_AGGREGATE(iid, punk)                                \
-       {&iid,                                                                      \
-       (DWORD_PTR)offsetof(_ComMapClass, punk),                                    \
-       _Delegate},
-
-#define DECLARE_GET_CONTROLLING_UNKNOWN()                                                                              \
-public:                                                                                                                                                        \
-       virtual IUnknown *GetControllingUnknown()                                                                       \
-       {                                                                                                                                                       \
-               return GetUnknown();                                                                                                    \
-       }
-
-#define DECLARE_PROTECT_FINAL_CONSTRUCT()                                                                              \
-       void InternalFinalConstructAddRef()                                                                                     \
-       {                                                                                                                                                       \
-               InternalAddRef();                                                                                                               \
-       }                                                                                                                                                       \
-       void InternalFinalConstructRelease()                                                                            \
-       {                                                                                                                                                       \
-               InternalRelease();                                                                                                              \
-       }
+    {&iid,                                                                      \
+    (DWORD_PTR)offsetof(_ComMapClass, punk),                                    \
+    _Delegate},
+
+#define DECLARE_GET_CONTROLLING_UNKNOWN()                                        \
+public:                                                                            \
+    virtual IUnknown *GetControllingUnknown()                                    \
+    {                                                                            \
+        return GetUnknown();                                                    \
+    }
+
+#define DECLARE_PROTECT_FINAL_CONSTRUCT()                                        \
+    void InternalFinalConstructAddRef()                                            \
+    {                                                                            \
+        InternalAddRef();                                                        \
+    }                                                                            \
+    void InternalFinalConstructRelease()                                        \
+    {                                                                            \
+        InternalRelease();                                                        \
+    }
 
 #define BEGIN_OBJECT_MAP(x) static ATL::_ATL_OBJMAP_ENTRY x[] = {
 
 #define END_OBJECT_MAP()   {NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL}};
 
-#define OBJECT_ENTRY(clsid, class)                                                                                             \
-{                                                                                                                                                              \
-       &clsid,                                                                                                                                         \
-       class::UpdateRegistry,                                                                                                          \
-       class::_ClassFactoryCreatorClass::CreateInstance,                                                       \
-       class::_CreatorClass::CreateInstance,                                                                           \
-       NULL,                                                                                                                                           \
-       0,                                                                                                                                                      \
-       class::GetObjectDescription,                                                                                            \
-       class::GetCategoryMap,                                                                                                          \
-       class::ObjectMain },
+#define OBJECT_ENTRY(clsid, class)                                                \
+{                                                                                \
+    &clsid,                                                                        \
+    class::UpdateRegistry,                                                        \
+    class::_ClassFactoryCreatorClass::CreateInstance,                            \
+    class::_CreatorClass::CreateInstance,                                        \
+    NULL,                                                                        \
+    0,                                                                            \
+    class::GetObjectDescription,                                                \
+    class::GetCategoryMap,                                                        \
+    class::ObjectMain },
 
 class CComClassFactory :
-       public IClassFactory,
-       public CComObjectRootEx<CComGlobalsThreadModel>
+    public IClassFactory,
+    public CComObjectRootEx<CComGlobalsThreadModel>
 {
 public:
-       _ATL_CREATORFUNC                                                *m_pfnCreateInstance;
+    _ATL_CREATORFUNC *m_pfnCreateInstance;
 
-       virtual ~CComClassFactory()
-       {
-       }
+    virtual ~CComClassFactory()
+    {
+    }
 
 public:
-       STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void **ppvObj)
-       {
-               HRESULT                                                         hResult;
-
-               ATLASSERT(m_pfnCreateInstance != NULL);
-
-               if (ppvObj == NULL)
-                       return E_POINTER;
-               *ppvObj = NULL;
-
-               if (pUnkOuter != NULL && InlineIsEqualUnknown(riid) == FALSE)
-                       hResult = CLASS_E_NOAGGREGATION;
-               else
-                       hResult = m_pfnCreateInstance(pUnkOuter, riid, ppvObj);
-               return hResult;
-       }
-
-       STDMETHOD(LockServer)(BOOL fLock)
-       {
-               if (fLock)
-                       _pAtlModule->Lock();
-               else
-                       _pAtlModule->Unlock();
-               return S_OK;
-       }
-
-       void SetVoid(void *pv)
-       {
-               m_pfnCreateInstance = (_ATL_CREATORFUNC *)pv;
-       }
-
-       BEGIN_COM_MAP(CComClassFactory)
-               COM_INTERFACE_ENTRY_IID(IID_IClassFactory, IClassFactory)
-       END_COM_MAP()
+    STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void **ppvObj)
+    {
+        HRESULT hResult;
+
+        ATLASSERT(m_pfnCreateInstance != NULL);
+
+        if (ppvObj == NULL)
+            return E_POINTER;
+        *ppvObj = NULL;
+
+        if (pUnkOuter != NULL && InlineIsEqualUnknown(riid) == FALSE)
+            hResult = CLASS_E_NOAGGREGATION;
+        else
+            hResult = m_pfnCreateInstance(pUnkOuter, riid, ppvObj);
+        return hResult;
+    }
+
+    STDMETHOD(LockServer)(BOOL fLock)
+    {
+        if (fLock)
+            _pAtlModule->Lock();
+        else
+            _pAtlModule->Unlock();
+        return S_OK;
+    }
+
+    void SetVoid(void *pv)
+    {
+        m_pfnCreateInstance = (_ATL_CREATORFUNC *)pv;
+    }
+
+    BEGIN_COM_MAP(CComClassFactory)
+        COM_INTERFACE_ENTRY_IID(IID_IClassFactory, IClassFactory)
+    END_COM_MAP()
 };
 
 template <class T, const CLSID *pclsid = &CLSID_NULL>
 class CComCoClass
 {
 public:
-       DECLARE_CLASSFACTORY()
+    DECLARE_CLASSFACTORY()
 
-       static LPCTSTR WINAPI GetObjectDescription()
-       {
-               return NULL;
-       }
+    static LPCTSTR WINAPI GetObjectDescription()
+    {
+        return NULL;
+    }
 };
 
 template <class T>
 class _Copy
 {
 public:
-       static HRESULT copy(T *pTo, const T *pFrom)
-       {
-               memcpy(pTo, pFrom, sizeof(T));
-               return S_OK;
-       }
-
-       static void init(T *)
-       {
-       }
-
-       static void destroy(T *)
-       {
-       }
+    static HRESULT copy(T *pTo, const T *pFrom)
+    {
+        memcpy(pTo, pFrom, sizeof(T));
+        return S_OK;
+    }
+
+    static void init(T *)
+    {
+    }
+
+    static void destroy(T *)
+    {
+    }
 };
 
 template<>
 class _Copy<CONNECTDATA>
 {
 public:
-       static HRESULT copy(CONNECTDATA *pTo, const CONNECTDATA *pFrom)
-       {
-               *pTo = *pFrom;
-               if (pTo->pUnk)
-                       pTo->pUnk->AddRef();
-               return S_OK;
-       }
-
-       static void init(CONNECTDATA *)
-       {
-       }
-
-       static void destroy(CONNECTDATA *p)
-       {
-               if (p->pUnk)
-                       p->pUnk->Release();
-       }
+    static HRESULT copy(CONNECTDATA *pTo, const CONNECTDATA *pFrom)
+    {
+        *pTo = *pFrom;
+        if (pTo->pUnk)
+            pTo->pUnk->AddRef();
+        return S_OK;
+    }
+
+    static void init(CONNECTDATA *)
+    {
+    }
+
+    static void destroy(CONNECTDATA *p)
+    {
+        if (p->pUnk)
+            p->pUnk->Release();
+    }
 };
 
 template <class T>
 class _CopyInterface
 {
 public:
-       static HRESULT copy(T **pTo, T **pFrom)
-       {
-               *pTo = *pFrom;
-               if (*pTo)
-                       (*pTo)->AddRef();
-               return S_OK;
-       }
-
-       static void init(T **)
-       {
-       }
-
-       static void destroy(T **p)
-       {
-               if (*p)
-                       (*p)->Release();
-       }
+    static HRESULT copy(T **pTo, T **pFrom)
+    {
+        *pTo = *pFrom;
+        if (*pTo)
+            (*pTo)->AddRef();
+        return S_OK;
+    }
+
+    static void init(T **)
+    {
+    }
+
+    static void destroy(T **p)
+    {
+        if (*p)
+            (*p)->Release();
+    }
 };
 
 enum CComEnumFlags
 {
-       AtlFlagNoCopy = 0,
-       AtlFlagTakeOwnership = 2,               // BitOwn
-       AtlFlagCopy = 3                                 // BitOwn | BitCopy
+    AtlFlagNoCopy = 0,
+    AtlFlagTakeOwnership = 2,        // BitOwn
+    AtlFlagCopy = 3                    // BitOwn | BitCopy
 };
 
 template <class Base, const IID *piid, class T, class Copy>
 class CComEnumImpl : public Base
 {
 private:
-       typedef CComObject<CComEnum<Base, piid, T, Copy> > enumeratorClass;
+    typedef CComObject<CComEnum<Base, piid, T, Copy> > enumeratorClass;
 public:
-       CComPtr<IUnknown>                                               m_spUnk;
-       DWORD                                                                   m_dwFlags;
-       T                                                                               *m_begin;
-       T                                                                               *m_end;
-       T                                                                               *m_iter;
+    CComPtr<IUnknown> m_spUnk;
+    DWORD m_dwFlags;
+    T *m_begin;
+    T *m_end;
+    T *m_iter;
 public:
-       CComEnumImpl()
-       {
-               m_dwFlags = 0;
-               m_begin = NULL;
-               m_end = NULL;
-               m_iter = NULL;
-       }
-
-       virtual ~CComEnumImpl()
-       {
-               T                                                                       *x;
-
-               if ((m_dwFlags & BitOwn) != 0)
-               {
-                       for (x = m_begin; x != m_end; x++)
-                               Copy::destroy(x);
-                       delete [] m_begin;
-               }
-       }
-
-       HRESULT Init(T *begin, T *end, IUnknown *pUnk, CComEnumFlags flags = AtlFlagNoCopy)
-       {
-               T                                                                       *newBuffer;
-               T                                                                       *sourcePtr;
-               T                                                                       *destPtr;
-               T                                                                       *cleanupPtr;
-               HRESULT                                                         hResult;
-
-               if (flags == AtlFlagCopy)
-               {
-                       ATLTRY(newBuffer = new T[end - begin])
-                       if (newBuffer == NULL)
-                               return E_OUTOFMEMORY;
-                       destPtr = newBuffer;
-                       for (sourcePtr = begin; sourcePtr != end; sourcePtr++)
-                       {
-                               Copy::init(destPtr);
-                               hResult = Copy::copy(destPtr, sourcePtr);
-                               if (FAILED(hResult))
-                               {
-                                       cleanupPtr = m_begin;
-                                       while (cleanupPtr < destPtr)
-                                               Copy::destroy(cleanupPtr++);
-                                       delete [] newBuffer;
-                                       return hResult;
-                               }
-                               destPtr++;
-                       }
-                       m_begin = newBuffer;
-                       m_end = m_begin + (end - begin);
-               }
-               else
-               {
-                       m_begin = begin;
-                       m_end = end;
-               }
-               m_spUnk = pUnk;
-               m_dwFlags = flags;
-               m_iter = m_begin;
-               return S_OK;
-       }
-
-       STDMETHOD(Next)(ULONG celt, T *rgelt, ULONG *pceltFetched)
-       {
-               ULONG                                                           numAvailable;
-               ULONG                                                           numToFetch;
-               T                                                                       *rgeltTemp;
-               HRESULT                                                         hResult;
-
-               if (pceltFetched != NULL)
-                       *pceltFetched = 0;
-               if (celt == 0)
-                       return E_INVALIDARG;
-               if (rgelt == NULL || (celt != 1 && pceltFetched == NULL))
-                       return E_POINTER;
-               if (m_begin == NULL || m_end == NULL || m_iter == NULL)
-                       return E_FAIL;
-
-               numAvailable = static_cast<ULONG>(m_end - m_iter);
-               if (celt < numAvailable)
-                       numToFetch = celt;
-               else
-                       numToFetch = numAvailable;
-               if (pceltFetched != NULL)
-                       *pceltFetched = numToFetch;
-               rgeltTemp = rgelt;
-               while (numToFetch != 0)
-               {
-                       hResult = Copy::copy(rgeltTemp, m_iter);
-                       if (FAILED(hResult))
-                       {
-                               while (rgelt < rgeltTemp)
-                                       Copy::destroy(rgelt++);
-                               if (pceltFetched != NULL)
-                                       *pceltFetched = 0;
-                               return hResult;
-                       }
-                       rgeltTemp++;
-                       m_iter++;
-                       numToFetch--;
-               }
-               if (numAvailable < celt)
-                       return S_FALSE;
-               return S_OK;
-       }
-
-       STDMETHOD(Skip)(ULONG celt)
-       {
-               ULONG                                                           numAvailable;
-               ULONG                                                           numToSkip;
-
-               if (celt == 0)
-                       return E_INVALIDARG;
-
-               numAvailable = static_cast<ULONG>(m_end - m_iter);
-               if (celt < numAvailable)
-                       numToSkip = celt;
-               else
-                       numToSkip = numAvailable;
-               m_iter += numToSkip;
-               if (numAvailable < celt)
-                       return S_FALSE;
-               return S_OK;
-       }
-
-       STDMETHOD(Reset)()
-       {
-               m_iter = m_begin;
-               return S_OK;
-       }
-
-       STDMETHOD(Clone)(Base **ppEnum)
-       {
-               enumeratorClass                                         *newInstance;
-               HRESULT                                                         hResult;
-
-               hResult = E_POINTER;
-               if (ppEnum != NULL)
-               {
-                       *ppEnum = NULL;
-                       hResult = enumeratorClass::CreateInstance(&newInstance);
-                       if (SUCCEEDED(hResult))
-                       {
-                               hResult = newInstance->Init(m_begin, m_end, (m_dwFlags & BitOwn) ? this : m_spUnk);
-                               if (SUCCEEDED(hResult))
-                               {
-                                       newInstance->m_iter = m_iter;
-                                       hResult = newInstance->_InternalQueryInterface(*piid, (void **)ppEnum);
-                               }
-                               if (FAILED(hResult))
-                                       delete newInstance;
-                       }
-               }
-               return hResult;
-       }
+    CComEnumImpl()
+    {
+        m_dwFlags = 0;
+        m_begin = NULL;
+        m_end = NULL;
+        m_iter = NULL;
+    }
+
+    virtual ~CComEnumImpl()
+    {
+        T *x;
+
+        if ((m_dwFlags & BitOwn) != 0)
+        {
+            for (x = m_begin; x != m_end; x++)
+                Copy::destroy(x);
+            delete [] m_begin;
+        }
+    }
+
+    HRESULT Init(T *begin, T *end, IUnknown *pUnk, CComEnumFlags flags = AtlFlagNoCopy)
+    {
+        T *newBuffer;
+        T *sourcePtr;
+        T *destPtr;
+        T *cleanupPtr;
+        HRESULT hResult;
+
+        if (flags == AtlFlagCopy)
+        {
+            ATLTRY(newBuffer = new T[end - begin])
+            if (newBuffer == NULL)
+                return E_OUTOFMEMORY;
+            destPtr = newBuffer;
+            for (sourcePtr = begin; sourcePtr != end; sourcePtr++)
+            {
+                Copy::init(destPtr);
+                hResult = Copy::copy(destPtr, sourcePtr);
+                if (FAILED(hResult))
+                {
+                    cleanupPtr = m_begin;
+                    while (cleanupPtr < destPtr)
+                        Copy::destroy(cleanupPtr++);
+                    delete [] newBuffer;
+                    return hResult;
+                }
+                destPtr++;
+            }
+            m_begin = newBuffer;
+            m_end = m_begin + (end - begin);
+        }
+        else
+        {
+            m_begin = begin;
+            m_end = end;
+        }
+        m_spUnk = pUnk;
+        m_dwFlags = flags;
+        m_iter = m_begin;
+        return S_OK;
+    }
+
+    STDMETHOD(Next)(ULONG celt, T *rgelt, ULONG *pceltFetched)
+    {
+        ULONG numAvailable;
+        ULONG numToFetch;
+        T *rgeltTemp;
+        HRESULT hResult;
+
+        if (pceltFetched != NULL)
+            *pceltFetched = 0;
+        if (celt == 0)
+            return E_INVALIDARG;
+        if (rgelt == NULL || (celt != 1 && pceltFetched == NULL))
+            return E_POINTER;
+        if (m_begin == NULL || m_end == NULL || m_iter == NULL)
+            return E_FAIL;
+
+        numAvailable = static_cast<ULONG>(m_end - m_iter);
+        if (celt < numAvailable)
+            numToFetch = celt;
+        else
+            numToFetch = numAvailable;
+        if (pceltFetched != NULL)
+            *pceltFetched = numToFetch;
+        rgeltTemp = rgelt;
+        while (numToFetch != 0)
+        {
+            hResult = Copy::copy(rgeltTemp, m_iter);
+            if (FAILED(hResult))
+            {
+                while (rgelt < rgeltTemp)
+                    Copy::destroy(rgelt++);
+                if (pceltFetched != NULL)
+                    *pceltFetched = 0;
+                return hResult;
+            }
+            rgeltTemp++;
+            m_iter++;
+            numToFetch--;
+        }
+        if (numAvailable < celt)
+            return S_FALSE;
+        return S_OK;
+    }
+
+    STDMETHOD(Skip)(ULONG celt)
+    {
+        ULONG numAvailable;
+        ULONG numToSkip;
+
+        if (celt == 0)
+            return E_INVALIDARG;
+
+        numAvailable = static_cast<ULONG>(m_end - m_iter);
+        if (celt < numAvailable)
+            numToSkip = celt;
+        else
+            numToSkip = numAvailable;
+        m_iter += numToSkip;
+        if (numAvailable < celt)
+            return S_FALSE;
+        return S_OK;
+    }
+
+    STDMETHOD(Reset)()
+    {
+        m_iter = m_begin;
+        return S_OK;
+    }
+
+    STDMETHOD(Clone)(Base **ppEnum)
+    {
+        enumeratorClass *newInstance;
+        HRESULT hResult;
+
+        hResult = E_POINTER;
+        if (ppEnum != NULL)
+        {
+            *ppEnum = NULL;
+            hResult = enumeratorClass::CreateInstance(&newInstance);
+            if (SUCCEEDED(hResult))
+            {
+                hResult = newInstance->Init(m_begin, m_end, (m_dwFlags & BitOwn) ? this : m_spUnk);
+                if (SUCCEEDED(hResult))
+                {
+                    newInstance->m_iter = m_iter;
+                    hResult = newInstance->_InternalQueryInterface(*piid, (void **)ppEnum);
+                }
+                if (FAILED(hResult))
+                    delete newInstance;
+            }
+        }
+        return hResult;
+    }
 
 protected:
-       enum FlagBits
-       {
-               BitCopy = 1,
-               BitOwn = 2
-       };
+    enum FlagBits
+    {
+        BitCopy = 1,
+        BitOwn = 2
+    };
 };
 
 template <class Base, const IID *piid, class T, class Copy, class ThreadModel>
 class CComEnum :
-       public CComEnumImpl<Base, piid, T, Copy>,
-       public CComObjectRootEx<ThreadModel>
+    public CComEnumImpl<Base, piid, T, Copy>,
+    public CComObjectRootEx<ThreadModel>
 {
 public:
-       typedef CComEnum<Base, piid, T, Copy > _CComEnum;
-       typedef CComEnumImpl<Base, piid, T, Copy > _CComEnumBase;
+    typedef CComEnum<Base, piid, T, Copy > _CComEnum;
+    typedef CComEnumImpl<Base, piid, T, Copy > _CComEnumBase;
 
-       BEGIN_COM_MAP(_CComEnum)
-               COM_INTERFACE_ENTRY_IID(*piid, _CComEnumBase)
-       END_COM_MAP()
+    BEGIN_COM_MAP(_CComEnum)
+        COM_INTERFACE_ENTRY_IID(*piid, _CComEnumBase)
+    END_COM_MAP()
 };
 
 #ifndef _DEFAULT_VECTORLENGTH
@@ -951,393 +951,393 @@ public:
 class CComDynamicUnkArray
 {
 public:
-       int                                                                             m_nSize;
-       IUnknown                                                                **m_ppUnk;
+    int m_nSize;
+    IUnknown **m_ppUnk;
 public:
-       CComDynamicUnkArray()
-       {
-               m_nSize = 0;
-               m_ppUnk = NULL;
-       }
-
-       ~CComDynamicUnkArray()
-       {
-               free(m_ppUnk);
-       }
-
-       IUnknown **begin()
-       {
-               return m_ppUnk;
-       }
-
-       IUnknown **end()
-       {
-               return &m_ppUnk[m_nSize];
-       }
-
-       IUnknown *GetAt(int nIndex)
-       {
-               ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
-               if (nIndex >= 0 && nIndex < m_nSize)
-                       return m_ppUnk[nIndex];
-               else
-                       return NULL;
-       }
-
-       IUnknown *WINAPI GetUnknown(DWORD dwCookie)
-       {
-               ATLASSERT(dwCookie != 0 && dwCookie <= static_cast<DWORD>(m_nSize));
-               if (dwCookie != 0 && dwCookie <= static_cast<DWORD>(m_nSize))
-                       return GetAt(dwCookie - 1);
-               else
-                       return NULL;
-       }
-
-       DWORD WINAPI GetCookie(IUnknown **ppFind)
-       {
-               IUnknown                                                        **x;
-               DWORD                                                           curCookie;
-
-               ATLASSERT(ppFind != NULL && *ppFind != NULL);
-               if (ppFind != NULL && *ppFind != NULL)
-               {
-                       curCookie = 1;
-                       for (x = begin(); x < end(); x++)
-                       {
-                               if (*x == *ppFind)
-                                       return curCookie;
-                               curCookie++;
-                       }
-               }
-               return 0;
-       }
-
-       DWORD Add(IUnknown *pUnk)
-       {
-               IUnknown                                                        **x;
-               IUnknown                                                        **newArray;
-               int                                                                     newSize;
-               DWORD                                                           curCookie;
-
-               ATLASSERT(pUnk != NULL);
-               if (m_nSize == 0)
-               {
-                       newSize = _DEFAULT_VECTORLENGTH * sizeof(IUnknown *);
-                       ATLTRY(newArray = reinterpret_cast<IUnknown **>(malloc(newSize)));
-                       if (newArray == NULL)
-                               return 0;
-                       memset(newArray, 0, newSize);
-                       m_ppUnk = newArray;
-                       m_nSize = _DEFAULT_VECTORLENGTH;
-               }
-               curCookie = 1;
-               for (x = begin(); x < end(); x++)
-               {
-                       if (*x == NULL)
-                       {
-                               *x = pUnk;
-                               return curCookie;
-                       }
-                       curCookie++;
-               }
-               newSize = m_nSize * 2;
-               newArray = reinterpret_cast<IUnknown **>(realloc(m_ppUnk, newSize * sizeof(IUnknown *)));
-               if (newArray == NULL)
-                       return 0;
-               m_ppUnk = newArray;
-               memset(&m_ppUnk[m_nSize], 0, (newSize - m_nSize) * sizeof(IUnknown *));
-               curCookie = m_nSize + 1;
-               m_nSize = newSize;
-               m_ppUnk[curCookie - 1] = pUnk;
-               return curCookie;
-       }
-
-       BOOL Remove(DWORD dwCookie)
-       {
-               DWORD                                                           index;
-
-               index = dwCookie - 1;
-               ATLASSERT(index < dwCookie && index < static_cast<DWORD>(m_nSize));
-               if (index < dwCookie && index < static_cast<DWORD>(m_nSize) && m_ppUnk[index] != NULL)
-               {
-                       m_ppUnk[index] = NULL;
-                       return TRUE;
-               }
-               return FALSE;
-       }
+    CComDynamicUnkArray()
+    {
+        m_nSize = 0;
+        m_ppUnk = NULL;
+    }
+
+    ~CComDynamicUnkArray()
+    {
+        free(m_ppUnk);
+    }
+
+    IUnknown **begin()
+    {
+        return m_ppUnk;
+    }
+
+    IUnknown **end()
+    {
+        return &m_ppUnk[m_nSize];
+    }
+
+    IUnknown *GetAt(int nIndex)
+    {
+        ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+        if (nIndex >= 0 && nIndex < m_nSize)
+            return m_ppUnk[nIndex];
+        else
+            return NULL;
+    }
+
+    IUnknown *WINAPI GetUnknown(DWORD dwCookie)
+    {
+        ATLASSERT(dwCookie != 0 && dwCookie <= static_cast<DWORD>(m_nSize));
+        if (dwCookie != 0 && dwCookie <= static_cast<DWORD>(m_nSize))
+            return GetAt(dwCookie - 1);
+        else
+            return NULL;
+    }
+
+    DWORD WINAPI GetCookie(IUnknown **ppFind)
+    {
+        IUnknown **x;
+        DWORD curCookie;
+
+        ATLASSERT(ppFind != NULL && *ppFind != NULL);
+        if (ppFind != NULL && *ppFind != NULL)
+        {
+            curCookie = 1;
+            for (x = begin(); x < end(); x++)
+            {
+                if (*x == *ppFind)
+                    return curCookie;
+                curCookie++;
+            }
+        }
+        return 0;
+    }
+
+    DWORD Add(IUnknown *pUnk)
+    {
+        IUnknown **x;
+        IUnknown **newArray;
+        int newSize;
+        DWORD curCookie;
+
+        ATLASSERT(pUnk != NULL);
+        if (m_nSize == 0)
+        {
+            newSize = _DEFAULT_VECTORLENGTH * sizeof(IUnknown *);
+            ATLTRY(newArray = reinterpret_cast<IUnknown **>(malloc(newSize)));
+            if (newArray == NULL)
+                return 0;
+            memset(newArray, 0, newSize);
+            m_ppUnk = newArray;
+            m_nSize = _DEFAULT_VECTORLENGTH;
+        }
+        curCookie = 1;
+        for (x = begin(); x < end(); x++)
+        {
+            if (*x == NULL)
+            {
+                *x = pUnk;
+                return curCookie;
+            }
+            curCookie++;
+        }
+        newSize = m_nSize * 2;
+        newArray = reinterpret_cast<IUnknown **>(realloc(m_ppUnk, newSize * sizeof(IUnknown *)));
+        if (newArray == NULL)
+            return 0;
+        m_ppUnk = newArray;
+        memset(&m_ppUnk[m_nSize], 0, (newSize - m_nSize) * sizeof(IUnknown *));
+        curCookie = m_nSize + 1;
+        m_nSize = newSize;
+        m_ppUnk[curCookie - 1] = pUnk;
+        return curCookie;
+    }
+
+    BOOL Remove(DWORD dwCookie)
+    {
+        DWORD index;
+
+        index = dwCookie - 1;
+        ATLASSERT(index < dwCookie && index < static_cast<DWORD>(m_nSize));
+        if (index < dwCookie && index < static_cast<DWORD>(m_nSize) && m_ppUnk[index] != NULL)
+        {
+            m_ppUnk[index] = NULL;
+            return TRUE;
+        }
+        return FALSE;
+    }
 
 private:
-       CComDynamicUnkArray &operator = (const CComDynamicUnkArray &)
-       {
-               return *this;
-       }
-
-       CComDynamicUnkArray(const CComDynamicUnkArray &)
-       {
-       }
+    CComDynamicUnkArray &operator = (const CComDynamicUnkArray &)
+    {
+        return *this;
+    }
+
+    CComDynamicUnkArray(const CComDynamicUnkArray &)
+    {
+    }
 };
 
 struct _ATL_CONNMAP_ENTRY
 {
-       DWORD_PTR                                                               dwOffset;
+    DWORD_PTR dwOffset;
 };
 
 template <const IID *piid>
 class _ICPLocator
 {
 public:
-       STDMETHOD(_LocCPQueryInterface)(REFIID riid, void **ppvObject) = 0;
-       virtual ULONG STDMETHODCALLTYPE AddRef() = 0;
-       virtual ULONG STDMETHODCALLTYPE Release() = 0;
+    STDMETHOD(_LocCPQueryInterface)(REFIID riid, void **ppvObject) = 0;
+    virtual ULONG STDMETHODCALLTYPE AddRef() = 0;
+    virtual ULONG STDMETHODCALLTYPE Release() = 0;
 };
 
 template<class T, const IID *piid, class CDV = CComDynamicUnkArray>
 class IConnectionPointImpl : public _ICPLocator<piid>
 {
-       typedef CComEnum<IEnumConnections, &IID_IEnumConnections, CONNECTDATA, _Copy<CONNECTDATA> > CComEnumConnections;
+    typedef CComEnum<IEnumConnections, &IID_IEnumConnections, CONNECTDATA, _Copy<CONNECTDATA> > CComEnumConnections;
 public:
-       CDV                                                                             m_vec;
+    CDV m_vec;
 public:
-       ~IConnectionPointImpl()
-       {
-               IUnknown                                                        **x;
-
-               for (x = m_vec.begin(); x < m_vec.end(); x++)
-                       if (*x != NULL)
-                               (*x)->Release();
-       }
-
-       STDMETHOD(_LocCPQueryInterface)(REFIID riid, void **ppvObject)
-       {
-               IConnectionPointImpl<T, piid, CDV>      *pThis;
-
-               pThis = reinterpret_cast<IConnectionPointImpl<T, piid, CDV>*>(this);
-
-               ATLASSERT(ppvObject != NULL);
-               if (ppvObject == NULL)
-                       return E_POINTER;
-
-               if (InlineIsEqualGUID(riid, IID_IConnectionPoint) || InlineIsEqualUnknown(riid))
-               {
-                       *ppvObject = this;
-                       pThis->AddRef();
-                       return S_OK;
-               }
-               else
-               {
-                       *ppvObject = NULL;
-                       return E_NOINTERFACE;
-               }
-       }
-
-       STDMETHOD(GetConnectionInterface)(IID *piid2)
-       {
-               if (piid2 == NULL)
-                       return E_POINTER;
-               *piid2 = *piid;
-               return S_OK;
-       }
-
-       STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer **ppCPC)
-       {
-               T                                                                       *pThis;
-
-               pThis = static_cast<T *>(this);
-               return pThis->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<void **>(ppCPC));
-       }
-
-       STDMETHOD(Advise)(IUnknown *pUnkSink, DWORD *pdwCookie)
-       {
-               IUnknown                                                        *adviseTarget;
-               IID                                                                     interfaceID;
-               HRESULT                                                         hResult;
-
-               if (pdwCookie != NULL)
-                       *pdwCookie = 0;
-               if (pUnkSink == NULL || pdwCookie == NULL)
-                       return E_POINTER;
-               GetConnectionInterface(&interfaceID);                   // can't fail
-               hResult = pUnkSink->QueryInterface(interfaceID, reinterpret_cast<void **>(&adviseTarget));
-               if (SUCCEEDED(hResult))
-               {
-                       *pdwCookie = m_vec.Add(adviseTarget);
-                       if (*pdwCookie != 0)
-                               hResult = S_OK;
-                       else
-                       {
-                               adviseTarget->Release();
-                               hResult = CONNECT_E_ADVISELIMIT;
-                       }
-               }
-               else if (hResult == E_NOINTERFACE)
-                       hResult = CONNECT_E_CANNOTCONNECT;
-               return hResult;
-       }
-
-       STDMETHOD(Unadvise)(DWORD dwCookie)
-       {
-               IUnknown                                                        *adviseTarget;
-               HRESULT                                                         hResult;
-
-               adviseTarget = m_vec.GetUnknown(dwCookie);
-               if (m_vec.Remove(dwCookie))
-               {
-                       if (adviseTarget != NULL)
-                               adviseTarget->Release();
-                       hResult = S_OK;
-               }
-               else
-                       hResult = CONNECT_E_NOCONNECTION;
-               return hResult;
-       }
-
-       STDMETHOD(EnumConnections)(IEnumConnections **ppEnum)
-       {
-               CComObject<CComEnumConnections>         *newEnumerator;
-               CONNECTDATA                                                     *itemBuffer;
-               CONNECTDATA                                                     *itemBufferEnd;
-               IUnknown                                                        **x;
-               HRESULT                                                         hResult;
-
-               ATLASSERT(ppEnum != NULL);
-               if (ppEnum == NULL)
-                       return E_POINTER;
-               *ppEnum = NULL;
-
-               ATLTRY(itemBuffer = new CONNECTDATA[m_vec.end() - m_vec.begin()])
-               if (itemBuffer == NULL)
-                       return E_OUTOFMEMORY;
-               itemBufferEnd = itemBuffer;
-               for (x = m_vec.begin(); x < m_vec.end(); x++)
-               {
-                       if (*x != NULL)
-                       {
-                               (*x)->AddRef();
-                               itemBufferEnd->pUnk = *x;
-                               itemBufferEnd->dwCookie = m_vec.GetCookie(x);
-                               itemBufferEnd++;
-                       }
-               }
-               ATLTRY(newEnumerator = new CComObject<CComEnumConnections>)
-               if (newEnumerator == NULL)
-                       return E_OUTOFMEMORY;
-               newEnumerator->Init(itemBuffer, itemBufferEnd, NULL, AtlFlagTakeOwnership);             // can't fail
-               hResult = newEnumerator->_InternalQueryInterface(IID_IEnumConnections, (void **)ppEnum);
-               if (FAILED(hResult))
-                       delete newEnumerator;
-               return hResult;
-       }
+    ~IConnectionPointImpl()
+    {
+        IUnknown **x;
+
+        for (x = m_vec.begin(); x < m_vec.end(); x++)
+            if (*x != NULL)
+                (*x)->Release();
+    }
+
+    STDMETHOD(_LocCPQueryInterface)(REFIID riid, void **ppvObject)
+    {
+        IConnectionPointImpl<T, piid, CDV> *pThis;
+
+        pThis = reinterpret_cast<IConnectionPointImpl<T, piid, CDV>*>(this);
+
+        ATLASSERT(ppvObject != NULL);
+        if (ppvObject == NULL)
+            return E_POINTER;
+
+        if (InlineIsEqualGUID(riid, IID_IConnectionPoint) || InlineIsEqualUnknown(riid))
+        {
+            *ppvObject = this;
+            pThis->AddRef();
+            return S_OK;
+        }
+        else
+        {
+            *ppvObject = NULL;
+            return E_NOINTERFACE;
+        }
+    }
+
+    STDMETHOD(GetConnectionInterface)(IID *piid2)
+    {
+        if (piid2 == NULL)
+            return E_POINTER;
+        *piid2 = *piid;
+        return S_OK;
+    }
+
+    STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer **ppCPC)
+    {
+        T *pThis;
+
+        pThis = static_cast<T *>(this);
+        return pThis->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<void **>(ppCPC));
+    }
+
+    STDMETHOD(Advise)(IUnknown *pUnkSink, DWORD *pdwCookie)
+    {
+        IUnknown *adviseTarget;
+        IID interfaceID;
+        HRESULT hResult;
+
+        if (pdwCookie != NULL)
+            *pdwCookie = 0;
+        if (pUnkSink == NULL || pdwCookie == NULL)
+            return E_POINTER;
+        GetConnectionInterface(&interfaceID);            // can't fail
+        hResult = pUnkSink->QueryInterface(interfaceID, reinterpret_cast<void **>(&adviseTarget));
+        if (SUCCEEDED(hResult))
+        {
+            *pdwCookie = m_vec.Add(adviseTarget);
+            if (*pdwCookie != 0)
+                hResult = S_OK;
+            else
+            {
+                adviseTarget->Release();
+                hResult = CONNECT_E_ADVISELIMIT;
+            }
+        }
+        else if (hResult == E_NOINTERFACE)
+            hResult = CONNECT_E_CANNOTCONNECT;
+        return hResult;
+    }
+
+    STDMETHOD(Unadvise)(DWORD dwCookie)
+    {
+        IUnknown *adviseTarget;
+        HRESULT hResult;
+
+        adviseTarget = m_vec.GetUnknown(dwCookie);
+        if (m_vec.Remove(dwCookie))
+        {
+            if (adviseTarget != NULL)
+                adviseTarget->Release();
+            hResult = S_OK;
+        }
+        else
+            hResult = CONNECT_E_NOCONNECTION;
+        return hResult;
+    }
+
+    STDMETHOD(EnumConnections)(IEnumConnections **ppEnum)
+    {
+        CComObject<CComEnumConnections> *newEnumerator;
+        CONNECTDATA *itemBuffer;
+        CONNECTDATA *itemBufferEnd;
+        IUnknown **x;
+        HRESULT hResult;
+
+        ATLASSERT(ppEnum != NULL);
+        if (ppEnum == NULL)
+            return E_POINTER;
+        *ppEnum = NULL;
+
+        ATLTRY(itemBuffer = new CONNECTDATA[m_vec.end() - m_vec.begin()])
+        if (itemBuffer == NULL)
+            return E_OUTOFMEMORY;
+        itemBufferEnd = itemBuffer;
+        for (x = m_vec.begin(); x < m_vec.end(); x++)
+        {
+            if (*x != NULL)
+            {
+                (*x)->AddRef();
+                itemBufferEnd->pUnk = *x;
+                itemBufferEnd->dwCookie = m_vec.GetCookie(x);
+                itemBufferEnd++;
+            }
+        }
+        ATLTRY(newEnumerator = new CComObject<CComEnumConnections>)
+        if (newEnumerator == NULL)
+            return E_OUTOFMEMORY;
+        newEnumerator->Init(itemBuffer, itemBufferEnd, NULL, AtlFlagTakeOwnership);        // can't fail
+        hResult = newEnumerator->_InternalQueryInterface(IID_IEnumConnections, (void **)ppEnum);
+        if (FAILED(hResult))
+            delete newEnumerator;
+        return hResult;
+    }
 };
 
 template <class T>
 class IConnectionPointContainerImpl : public IConnectionPointContainer
 {
-               typedef const _ATL_CONNMAP_ENTRY * (*handlerFunctionType)(int *);
-               typedef CComEnum<IEnumConnectionPoints, &IID_IEnumConnectionPoints, IConnectionPoint *, _CopyInterface<IConnectionPoint> >
-                                               CComEnumConnectionPoints;
+        typedef const _ATL_CONNMAP_ENTRY * (*handlerFunctionType)(int *);
+        typedef CComEnum<IEnumConnectionPoints, &IID_IEnumConnectionPoints, IConnectionPoint *, _CopyInterface<IConnectionPoint> >
+                        CComEnumConnectionPoints;
 
 public:
-       STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints **ppEnum)
-       {
-               const _ATL_CONNMAP_ENTRY                        *entryPtr;
-               int                                                                     connectionPointCount;
-               IConnectionPoint                                        **itemBuffer;
-               int                                                                     destIndex;
-               handlerFunctionType                                     handlerFunction;
-               CComEnumConnectionPoints                        *newEnumerator;
-               HRESULT                                                         hResult;
-
-               ATLASSERT(ppEnum != NULL);
-               if (ppEnum == NULL)
-                       return E_POINTER;
-               *ppEnum = NULL;
-
-               entryPtr = T::GetConnMap(&connectionPointCount);
-               ATLTRY(itemBuffer = new IConnectionPoint * [connectionPointCount])
-               if (itemBuffer == NULL)
-                       return E_OUTOFMEMORY;
-
-               destIndex = 0;
-               while (entryPtr->dwOffset != static_cast<DWORD_PTR>(-1))
-               {
-                       if (entryPtr->dwOffset == static_cast<DWORD_PTR>(-2))
-                       {
-                               entryPtr++;
-                               handlerFunction = reinterpret_cast<handlerFunctionType>(entryPtr->dwOffset);
-                               entryPtr = handlerFunction(NULL);
-                       }
-                       else
-                       {
-                               itemBuffer[destIndex++] = reinterpret_cast<IConnectionPoint *>((char *)this + entryPtr->dwOffset);
-                               entryPtr++;
-                       }
-               }
-
-               ATLTRY(newEnumerator = new CComObject<CComEnumConnectionPoints>)
-               if (newEnumerator == NULL)
-               {
-                       delete [] itemBuffer;
-                       return E_OUTOFMEMORY;
-               }
-
-               newEnumerator->Init(&itemBuffer[0], &itemBuffer[destIndex], NULL, AtlFlagTakeOwnership);        // can't fail
-               hResult = newEnumerator->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum);
-               if (FAILED(hResult))
-                       delete newEnumerator;
-               return hResult;
-       }
-
-       STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint **ppCP)
-       {
-               IID                                                                     interfaceID;
-               const _ATL_CONNMAP_ENTRY                        *entryPtr;
-               handlerFunctionType                                     handlerFunction;
-               IConnectionPoint                                        *connectionPoint;
-               HRESULT                                                         hResult;
-
-               if (ppCP == NULL)
-                       return E_POINTER;
-               *ppCP = NULL;
-               hResult = CONNECT_E_NOCONNECTION;
-               entryPtr = T::GetConnMap(NULL);
-               while (entryPtr->dwOffset != static_cast<DWORD_PTR>(-1))
-               {
-                       if (entryPtr->dwOffset == static_cast<DWORD_PTR>(-2))
-                       {
-                               entryPtr++;
-                               handlerFunction = reinterpret_cast<handlerFunctionType>(entryPtr->dwOffset);
-                               entryPtr = handlerFunction(NULL);
-                       }
-                       else
-                       {
-                               connectionPoint = reinterpret_cast<IConnectionPoint *>(reinterpret_cast<char *>(this) + entryPtr->dwOffset);
-                               if (SUCCEEDED(connectionPoint->GetConnectionInterface(&interfaceID)) && InlineIsEqualGUID(riid, interfaceID))
-                               {
-                                       *ppCP = connectionPoint;
-                                       connectionPoint->AddRef();
-                                       hResult = S_OK;
-                                       break;
-                               }
-                               entryPtr++;
-                       }
-               }
-               return hResult;
-       }
+    STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints **ppEnum)
+    {
+        const _ATL_CONNMAP_ENTRY *entryPtr;
+        int connectionPointCount;
+        IConnectionPoint **itemBuffer;
+        int destIndex;
+        handlerFunctionType handlerFunction;
+        CComEnumConnectionPoints *newEnumerator;
+        HRESULT hResult;
+
+        ATLASSERT(ppEnum != NULL);
+        if (ppEnum == NULL)
+            return E_POINTER;
+        *ppEnum = NULL;
+
+        entryPtr = T::GetConnMap(&connectionPointCount);
+        ATLTRY(itemBuffer = new IConnectionPoint * [connectionPointCount])
+        if (itemBuffer == NULL)
+            return E_OUTOFMEMORY;
+
+        destIndex = 0;
+        while (entryPtr->dwOffset != static_cast<DWORD_PTR>(-1))
+        {
+            if (entryPtr->dwOffset == static_cast<DWORD_PTR>(-2))
+            {
+                entryPtr++;
+                handlerFunction = reinterpret_cast<handlerFunctionType>(entryPtr->dwOffset);
+                entryPtr = handlerFunction(NULL);
+            }
+            else
+            {
+                itemBuffer[destIndex++] = reinterpret_cast<IConnectionPoint *>((char *)this + entryPtr->dwOffset);
+                entryPtr++;
+            }
+        }
+
+        ATLTRY(newEnumerator = new CComObject<CComEnumConnectionPoints>)
+        if (newEnumerator == NULL)
+        {
+            delete [] itemBuffer;
+            return E_OUTOFMEMORY;
+        }
+
+        newEnumerator->Init(&itemBuffer[0], &itemBuffer[destIndex], NULL, AtlFlagTakeOwnership);    // can't fail
+        hResult = newEnumerator->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum);
+        if (FAILED(hResult))
+            delete newEnumerator;
+        return hResult;
+    }
+
+    STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint **ppCP)
+    {
+        IID interfaceID;
+        const _ATL_CONNMAP_ENTRY *entryPtr;
+        handlerFunctionType handlerFunction;
+        IConnectionPoint *connectionPoint;
+        HRESULT hResult;
+
+        if (ppCP == NULL)
+            return E_POINTER;
+        *ppCP = NULL;
+        hResult = CONNECT_E_NOCONNECTION;
+        entryPtr = T::GetConnMap(NULL);
+        while (entryPtr->dwOffset != static_cast<DWORD_PTR>(-1))
+        {
+            if (entryPtr->dwOffset == static_cast<DWORD_PTR>(-2))
+            {
+                entryPtr++;
+                handlerFunction = reinterpret_cast<handlerFunctionType>(entryPtr->dwOffset);
+                entryPtr = handlerFunction(NULL);
+            }
+            else
+            {
+                connectionPoint = reinterpret_cast<IConnectionPoint *>(reinterpret_cast<char *>(this) + entryPtr->dwOffset);
+                if (SUCCEEDED(connectionPoint->GetConnectionInterface(&interfaceID)) && InlineIsEqualGUID(riid, interfaceID))
+                {
+                    *ppCP = connectionPoint;
+                    connectionPoint->AddRef();
+                    hResult = S_OK;
+                    break;
+                }
+                entryPtr++;
+            }
+        }
+        return hResult;
+    }
 };
 
-#define BEGIN_CONNECTION_POINT_MAP(x)                                                                                  \
-       typedef x _atl_conn_classtype;                                                                                          \
-       static const ATL::_ATL_CONNMAP_ENTRY *GetConnMap(int *pnEntries) {                      \
-       static const ATL::_ATL_CONNMAP_ENTRY _entries[] = {
+#define BEGIN_CONNECTION_POINT_MAP(x)                                            \
+    typedef x _atl_conn_classtype;                                                \
+    static const ATL::_ATL_CONNMAP_ENTRY *GetConnMap(int *pnEntries) {            \
+    static const ATL::_ATL_CONNMAP_ENTRY _entries[] = {
 
-#define END_CONNECTION_POINT_MAP()                                                                                             \
-       {(DWORD_PTR)-1} };                                                                                                                      \
-       if (pnEntries)                                                                                                                          \
-               *pnEntries = sizeof(_entries) / sizeof(ATL::_ATL_CONNMAP_ENTRY) - 1;    \
-       return _entries;}
+#define END_CONNECTION_POINT_MAP()                                                \
+    {(DWORD_PTR)-1} };                                                            \
+    if (pnEntries)                                                                \
+        *pnEntries = sizeof(_entries) / sizeof(ATL::_ATL_CONNMAP_ENTRY) - 1;    \
+    return _entries;}
 
-#define CONNECTION_POINT_ENTRY(iid)                                                                                            \
-       {offsetofclass(ATL::_ICPLocator<&iid>, _atl_conn_classtype) -                           \
-       offsetofclass(ATL::IConnectionPointContainerImpl<_atl_conn_classtype>, _atl_conn_classtype)},
+#define CONNECTION_POINT_ENTRY(iid)                                                \
+    {offsetofclass(ATL::_ICPLocator<&iid>, _atl_conn_classtype) -                \
+    offsetofclass(ATL::IConnectionPointContainerImpl<_atl_conn_classtype>, _atl_conn_classtype)},
 
 }; // namespace ATL
index 895863c..5b7dbbe 100644 (file)
@@ -44,141 +44,141 @@ namespace ATL
 class CComCriticalSection
 {
 public:
-       CRITICAL_SECTION                                                m_sec;
+    CRITICAL_SECTION m_sec;
 public:
-       CComCriticalSection()
-       {
-               memset(&m_sec, 0, sizeof(CRITICAL_SECTION));
-       }
-
-       virtual ~CComCriticalSection()
-       {
-       }
-
-       HRESULT Lock()
-       {
-               EnterCriticalSection(&m_sec);
-               return S_OK;
-       }
-
-       HRESULT Unlock()
-       {
-               LeaveCriticalSection(&m_sec);
-               return S_OK;
-       }
-
-       HRESULT Init()
-       {
-               InitializeCriticalSection(&m_sec);
-               return S_OK;
-       }
-
-       HRESULT Term()
-       {
-               DeleteCriticalSection(&m_sec);
-               return S_OK;
-       }
+    CComCriticalSection()
+    {
+        memset(&m_sec, 0, sizeof(CRITICAL_SECTION));
+    }
+
+    virtual ~CComCriticalSection()
+    {
+    }
+
+    HRESULT Lock()
+    {
+        EnterCriticalSection(&m_sec);
+        return S_OK;
+    }
+
+    HRESULT Unlock()
+    {
+        LeaveCriticalSection(&m_sec);
+        return S_OK;
+    }
+
+    HRESULT Init()
+    {
+        InitializeCriticalSection(&m_sec);
+        return S_OK;
+    }
+
+    HRESULT Term()
+    {
+        DeleteCriticalSection(&m_sec);
+        return S_OK;
+    }
 };
 
 class CComFakeCriticalSection
 {
 public:
-       HRESULT Lock()
-       {
-               return S_OK;
-       }
-
-       HRESULT Unlock()
-       {
-               return S_OK;
-       }
-
-       HRESULT Init()
-       {
-               return S_OK;
-       }
-
-       HRESULT Term()
-       {
-               return S_OK;
-       }
+    HRESULT Lock()
+    {
+        return S_OK;
+    }
+
+    HRESULT Unlock()
+    {
+        return S_OK;
+    }
+
+    HRESULT Init()
+    {
+        return S_OK;
+    }
+
+    HRESULT Term()
+    {
+        return S_OK;
+    }
 };
 
 class CComAutoCriticalSection : public CComCriticalSection
 {
 public:
-       CComAutoCriticalSection()
-       {
-               HRESULT hResult __MINGW_ATTRIB_UNUSED;
-
-               hResult = CComCriticalSection::Init();
-               ATLASSERT(SUCCEEDED(hResult));
-       }
-       ~CComAutoCriticalSection()
-       {
-               CComCriticalSection::Term();
-       }
+    CComAutoCriticalSection()
+    {
+        HRESULT hResult __MINGW_ATTRIB_UNUSED;
+
+        hResult = CComCriticalSection::Init();
+        ATLASSERT(SUCCEEDED(hResult));
+    }
+    ~CComAutoCriticalSection()
+    {
+        CComCriticalSection::Term();
+    }
 };
 
 class CComSafeDeleteCriticalSection : public CComCriticalSection
 {
 private:
-       bool                                                                    m_bInitialized;
+    bool m_bInitialized;
 public:
-       CComSafeDeleteCriticalSection()
-       {
-               m_bInitialized = false;
-       }
-
-       ~CComSafeDeleteCriticalSection()
-       {
-               Term();
-       }
-
-       HRESULT Lock()
-       {
-               ATLASSERT(m_bInitialized);
-               return CComCriticalSection::Lock();
-       }
-
-       HRESULT Init()
-       {
-               HRESULT                                                         hResult;
-
-               ATLASSERT(!m_bInitialized);
-               hResult = CComCriticalSection::Init();
-               if (SUCCEEDED(hResult))
-                       m_bInitialized = true;
-               return hResult;
-       }
-
-       HRESULT Term()
-       {
-               if (!m_bInitialized)
-                       return S_OK;
-               m_bInitialized = false;
-               return CComCriticalSection::Term();
-       }
+    CComSafeDeleteCriticalSection()
+    {
+        m_bInitialized = false;
+    }
+
+    ~CComSafeDeleteCriticalSection()
+    {
+        Term();
+    }
+
+    HRESULT Lock()
+    {
+        ATLASSERT(m_bInitialized);
+        return CComCriticalSection::Lock();
+    }
+
+    HRESULT Init()
+    {
+        HRESULT hResult;
+
+        ATLASSERT(!m_bInitialized);
+        hResult = CComCriticalSection::Init();
+        if (SUCCEEDED(hResult))
+            m_bInitialized = true;
+        return hResult;
+    }
+
+    HRESULT Term()
+    {
+        if (!m_bInitialized)
+            return S_OK;
+        m_bInitialized = false;
+        return CComCriticalSection::Term();
+    }
 };
 
 class CComAutoDeleteCriticalSection : public CComSafeDeleteCriticalSection
 {
 private:
-       // CComAutoDeleteCriticalSection::Term should never be called
-       HRESULT Term();
+    // CComAutoDeleteCriticalSection::Term should never be called
+    HRESULT Term();
 };
 
 struct _ATL_BASE_MODULE70
 {
-       UINT                                                                    cbSize;
-       HINSTANCE                                                               m_hInst;
-       HINSTANCE                                                               m_hInstResource;
-       bool                                                                    m_bNT5orWin98;
-       DWORD                                                                   dwAtlBuildVer;
-       GUID                                                                    *pguidVer;
-       CRITICAL_SECTION                                                m_csResource;
+    UINT cbSize;
+    HINSTANCE m_hInst;
+    HINSTANCE m_hInstResource;
+    bool m_bNT5orWin98;
+    DWORD dwAtlBuildVer;
+    GUID *pguidVer;
+    CRITICAL_SECTION m_csResource;
 #ifdef NOTYET
-       CSimpleArray<HINSTANCE>                                 m_rgResourceInstance;
+    CSimpleArray<HINSTANCE> m_rgResourceInstance;
 #endif
 };
 typedef _ATL_BASE_MODULE70 _ATL_BASE_MODULE;
@@ -186,24 +186,24 @@ typedef _ATL_BASE_MODULE70 _ATL_BASE_MODULE;
 class CAtlBaseModule : public _ATL_BASE_MODULE
 {
 public :
-       static bool                                                             m_bInitFailed;
+    static bool m_bInitFailed;
 public:
-       CAtlBaseModule()
-       {
-               cbSize = sizeof(_ATL_BASE_MODULE);
-               GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInst);
-               m_hInstResource = m_hInst;
-       }
-
-       HINSTANCE GetModuleInstance()
-       {
-               return m_hInst;
-       }
-
-       HINSTANCE GetResourceInstance()
-       {
-               return m_hInstResource;
-       }
+    CAtlBaseModule()
+    {
+        cbSize = sizeof(_ATL_BASE_MODULE);
+        GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)this, &m_hInst);
+        m_hInstResource = m_hInst;
+    }
+
+    HINSTANCE GetModuleInstance()
+    {
+        return m_hInst;
+    }
+
+    HINSTANCE GetResourceInstance()
+    {
+        return m_hInstResource;
+    }
 };
 
 extern CAtlBaseModule _AtlBaseModule;
index 7cfc38d..ab5a63d 100644 (file)
 #pragma once
 
 #ifdef __GNUC__
-#define GCCU(x)        x __attribute__((unused))
+#define GCCU(x)    x __attribute__((unused))
 #define Unused(x)
 #else
-#define GCCU(x) (x) 
-#define Unused(x)      (x);
+#define GCCU(x) (x)
+#define Unused(x)    (x);
 #endif // __GNUC__
 
 #ifdef SetWindowLongPtr
 #undef SetWindowLongPtr
 inline LONG_PTR SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong)
 {
-       return SetWindowLong(hWnd, nIndex, (LONG)dwNewLong);
+    return SetWindowLong(hWnd, nIndex, (LONG)dwNewLong);
 }
 #endif
 
@@ -40,7 +40,7 @@ inline LONG_PTR SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong)
 #undef GetWindowLongPtr
 inline LONG_PTR GetWindowLongPtr(HWND hWnd, int nIndex)
 {
-       return (LONG_PTR)GetWindowLong(hWnd, nIndex);
+    return (LONG_PTR)GetWindowLong(hWnd, nIndex);
 }
 #endif
 
@@ -54,19 +54,19 @@ template <DWORD t_dwStyle = 0, DWORD t_dwExStyle = 0>
 class CWinTraits
 {
 public:
-       static DWORD GetWndStyle(DWORD dwStyle)
-       {
-               if (dwStyle == 0)
-                       return t_dwStyle;
-               return dwStyle;
-       }
-
-       static DWORD GetWndExStyle(DWORD dwExStyle)
-       {
-               if (dwExStyle == 0)
-                       return t_dwExStyle;
-               return dwExStyle;
-       }
+    static DWORD GetWndStyle(DWORD dwStyle)
+    {
+        if (dwStyle == 0)
+            return t_dwStyle;
+        return dwStyle;
+    }
+
+    static DWORD GetWndExStyle(DWORD dwExStyle)
+    {
+        if (dwExStyle == 0)
+            return t_dwExStyle;
+        return dwExStyle;
+    }
 };
 
 typedef CWinTraits<WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0> CControlWinTraits;
@@ -77,65 +77,65 @@ template <DWORD t_dwStyle = 0, DWORD t_dwExStyle = 0, class TWinTraits = CContro
 class CWinTraitsOR
 {
 public:
-       static DWORD GetWndStyle(DWORD dwStyle)
-       {
-               return dwStyle | t_dwStyle | TWinTraits::GetWndStyle(dwStyle);
-       }
-
-       static DWORD GetWndExStyle(DWORD dwExStyle)
-       {
-               return dwExStyle | t_dwExStyle | TWinTraits::GetWndExStyle(dwExStyle);
-       }
+    static DWORD GetWndStyle(DWORD dwStyle)
+    {
+        return dwStyle | t_dwStyle | TWinTraits::GetWndStyle(dwStyle);
+    }
+
+    static DWORD GetWndExStyle(DWORD dwExStyle)
+    {
+        return dwExStyle | t_dwExStyle | TWinTraits::GetWndExStyle(dwExStyle);
+    }
 };
 
 class _U_MENUorID
 {
 public:
-       HMENU                                                                   m_hMenu;
+    HMENU m_hMenu;
 public:
-       _U_MENUorID(HMENU hMenu)
-       {
-               m_hMenu = hMenu;
-       }
-
-       _U_MENUorID(UINT nID)
-       {
-               m_hMenu = (HMENU)(UINT_PTR)nID;
-       }
+    _U_MENUorID(HMENU hMenu)
+    {
+        m_hMenu = hMenu;
+    }
+
+    _U_MENUorID(UINT nID)
+    {
+        m_hMenu = (HMENU)(UINT_PTR)nID;
+    }
 };
 
 class _U_RECT
 {
 public:
-       LPRECT                                                                  m_lpRect;
+    LPRECT m_lpRect;
 public:
-       _U_RECT(LPRECT lpRect)
-       {
-               m_lpRect = lpRect;
-       }
-
-       _U_RECT(RECT &rc)
-       {
-               m_lpRect = &rc;
-       }
+    _U_RECT(LPRECT lpRect)
+    {
+        m_lpRect = lpRect;
+    }
+
+    _U_RECT(RECT &rc)
+    {
+        m_lpRect = &rc;
+    }
 };
 
 struct _ATL_MSG : public MSG
 {
 public:
-       BOOL                                                                    bHandled;
+    BOOL bHandled;
 public:
-       _ATL_MSG(HWND hWnd, UINT uMsg, WPARAM wParamIn, LPARAM lParamIn, BOOL bHandledIn = TRUE)
-       {
-               hwnd = hWnd;
-               message = uMsg;
-               wParam = wParamIn;
-               lParam = lParamIn;
-               time = 0;
-               pt.x = 0;
-               pt.y = 0;
-               bHandled = bHandledIn;
-       }
+    _ATL_MSG(HWND hWnd, UINT uMsg, WPARAM wParamIn, LPARAM lParamIn, BOOL bHandledIn = TRUE)
+    {
+        hwnd = hWnd;
+        message = uMsg;
+        wParam = wParamIn;
+        lParam = lParamIn;
+        time = 0;
+        pt.x = 0;
+        pt.y = 0;
+        bHandled = bHandledIn;
+    }
 };
 
 #if defined(_M_IX86)
@@ -143,18 +143,18 @@ public:
 #pragma pack(push,1)
 struct thunkCode
 {
-       DWORD                                                                   m_mov;
-       DWORD                                                                   m_this;
-       BYTE                                                                    m_jmp;
-       DWORD                                                                   m_relproc;
+    DWORD m_mov;
+    DWORD m_this;
+    BYTE m_jmp;
+    DWORD m_relproc;
 };
 #pragma pack(pop)
 
 class CWndProcThunk
 {
 public:
-       thunkCode                                                               *m_pthunk;
-       _AtlCreateWndData                                               cd;
+    thunkCode *m_pthunk;
+    _AtlCreateWndData cd;
 public:
 
     CWndProcThunk()
@@ -167,51 +167,51 @@ public:
         VirtualFree(m_pthunk, 0, MEM_RELEASE);
     }
 
-       BOOL Init(WNDPROC proc, void *pThis)
-       {
-               m_pthunk->m_mov = 0x042444C7;
-               m_pthunk->m_this = PtrToUlong(pThis);
-               m_pthunk->m_jmp = 0xe9;
-               m_pthunk->m_relproc = DWORD(reinterpret_cast<char *>(proc) - (reinterpret_cast<char *>(m_pthunk) + sizeof(thunkCode)));
-               return TRUE;
-       }
+    BOOL Init(WNDPROC proc, void *pThis)
+    {
+        m_pthunk->m_mov = 0x042444C7;
+        m_pthunk->m_this = PtrToUlong(pThis);
+        m_pthunk->m_jmp = 0xe9;
+        m_pthunk->m_relproc = DWORD(reinterpret_cast<char *>(proc) - (reinterpret_cast<char *>(m_pthunk) + sizeof(thunkCode)));
+        return TRUE;
+    }
 
-       WNDPROC GetWNDPROC()
-       {
-               return reinterpret_cast<WNDPROC>(m_pthunk);
-       }
+    WNDPROC GetWNDPROC()
+    {
+        return reinterpret_cast<WNDPROC>(m_pthunk);
+    }
 };
 
 #elif _AMD64_ //WARNING: NOT VERIFIED
 #pragma pack(push,1)
 struct thunkCode
 {
-       DWORD_PTR                                                               m_mov;
-       DWORD_PTR                                                               m_this;
-       BYTE                                                                    m_jmp;
-       DWORD_PTR                                                               m_relproc;
+    DWORD_PTR m_mov;
+    DWORD_PTR m_this;
+    BYTE m_jmp;
+    DWORD_PTR m_relproc;
 };
 #pragma pack(pop)
 
 class CWndProcThunk
 {
 public:
-       thunkCode                                                               m_thunk;
-       _AtlCreateWndData                                               cd;
+    thunkCode m_thunk;
+    _AtlCreateWndData cd;
 public:
-       BOOL Init(WNDPROC proc, void *pThis)
-       {
-               m_thunk.m_mov = 0xffff8000042444C7LL;
-               m_thunk.m_this = (DWORD_PTR)pThis;
-               m_thunk.m_jmp = 0xe9;
-               m_thunk.m_relproc = DWORD_PTR(reinterpret_cast<char *>(proc) - (reinterpret_cast<char *>(this) + sizeof(thunkCode)));
-               return TRUE;
-       }
-
-       WNDPROC GetWNDPROC()
-       {
-               return reinterpret_cast<WNDPROC>(&m_thunk);
-       }
+    BOOL Init(WNDPROC proc, void *pThis)
+    {
+        m_thunk.m_mov = 0xffff8000042444C7LL;
+        m_thunk.m_this = (DWORD_PTR)pThis;
+        m_thunk.m_jmp = 0xe9;
+        m_thunk.m_relproc = DWORD_PTR(reinterpret_cast<char *>(proc) - (reinterpret_cast<char *>(this) + sizeof(thunkCode)));
+        return TRUE;
+    }
+
+    WNDPROC GetWNDPROC()
+    {
+        return reinterpret_cast<WNDPROC>(&m_thunk);
+    }
 };
 #else
 #error ARCH not supported
@@ -220,155 +220,155 @@ public:
 class CMessageMap
 {
 public:
-       virtual BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT &lResult, DWORD dwMsgMapID) = 0;
+    virtual BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT &lResult, DWORD dwMsgMapID) = 0;
 };
 
 class CWindow
 {
 public:
-       HWND                                                                    m_hWnd;
-       static RECT                                                             rcDefault;
+    HWND m_hWnd;
+    static RECT rcDefault;
 public:
-       CWindow(HWND hWnd = NULL)
-       {
-               m_hWnd = hWnd;
-       }
-
-       operator HWND() const
-       {
-               return m_hWnd;
-       }
-
-       static LPCTSTR GetWndClassName()
-       {
-               return NULL;
-       }
-
-       HDC BeginPaint(LPPAINTSTRUCT lpPaint)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::BeginPaint(m_hWnd, lpPaint);
-       }
-
-       BOOL DestroyWindow()
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-
-               if (!::DestroyWindow(m_hWnd))
-                       return FALSE;
-
-               m_hWnd = NULL;
-               return TRUE;
-       }
-
-       void EndPaint(LPPAINTSTRUCT lpPaint)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               ::EndPaint(m_hWnd, lpPaint);
-       }
-
-       BOOL GetClientRect(LPRECT lpRect) const
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::GetClientRect(m_hWnd, lpRect);
-       }
-
-       CWindow GetParent() const
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return CWindow(::GetParent(m_hWnd));
-       }
-
-       BOOL Invalidate(BOOL bErase = TRUE)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::InvalidateRect(m_hWnd, NULL, bErase);
-       }
-
-       BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::InvalidateRect(m_hWnd, lpRect, bErase);
-       }
-
-       BOOL IsWindow() const
-       {
-               return ::IsWindow(m_hWnd);
-       }
-
-       BOOL KillTimer(UINT_PTR nIDEvent)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::KillTimer(m_hWnd, nIDEvent);
-       }
-
-       BOOL LockWindowUpdate(BOOL bLock = TRUE)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               if (bLock)
-                       return ::LockWindowUpdate(m_hWnd);
-               return ::LockWindowUpdate(NULL);
-       }
-
-       BOOL ScreenToClient(LPPOINT lpPoint) const
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::ScreenToClient(m_hWnd, lpPoint);
-       }
-
-       LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::SendMessage(m_hWnd, message, wParam, lParam);
-       }
-
-       static LRESULT SendMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
-       {
-               ATLASSERT(::IsWindow(hWnd));
-               return ::SendMessage(hWnd, message, wParam, lParam);
-       }
-
-       HWND SetCapture()
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::SetCapture(m_hWnd);
-       }
-
-       HWND SetFocus()
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::SetFocus(m_hWnd);
-       }
-
-       UINT_PTR SetTimer(UINT_PTR nIDEvent, UINT nElapse, void (CALLBACK *lpfnTimer)(HWND, UINT, UINT_PTR, DWORD) = NULL)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::SetTimer(m_hWnd, nIDEvent, nElapse, reinterpret_cast<TIMERPROC>(lpfnTimer));
-       }
-
-       BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::SetWindowPos(m_hWnd, hWndInsertAfter, x, y, cx, cy, nFlags);
-       }
-
-       BOOL SetWindowText(LPCTSTR lpszString)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::SetWindowText(m_hWnd, lpszString);
-       }
-
-       BOOL ShowWindow(int nCmdShow)
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::ShowWindow(m_hWnd, nCmdShow);
-       }
-
-       BOOL UpdateWindow()
-       {
-               ATLASSERT(::IsWindow(m_hWnd));
-               return ::UpdateWindow(m_hWnd);
-       }
+    CWindow(HWND hWnd = NULL)
+    {
+        m_hWnd = hWnd;
+    }
+
+    operator HWND() const
+    {
+        return m_hWnd;
+    }
+
+    static LPCTSTR GetWndClassName()
+    {
+        return NULL;
+    }
+
+    HDC BeginPaint(LPPAINTSTRUCT lpPaint)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::BeginPaint(m_hWnd, lpPaint);
+    }
+
+    BOOL DestroyWindow()
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+
+        if (!::DestroyWindow(m_hWnd))
+            return FALSE;
+
+        m_hWnd = NULL;
+        return TRUE;
+    }
+
+    void EndPaint(LPPAINTSTRUCT lpPaint)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        ::EndPaint(m_hWnd, lpPaint);
+    }
+
+    BOOL GetClientRect(LPRECT lpRect) const
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::GetClientRect(m_hWnd, lpRect);
+    }
+
+    CWindow GetParent() const
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return CWindow(::GetParent(m_hWnd));
+    }
+
+    BOOL Invalidate(BOOL bErase = TRUE)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::InvalidateRect(m_hWnd, NULL, bErase);
+    }
+
+    BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::InvalidateRect(m_hWnd, lpRect, bErase);
+    }
+
+    BOOL IsWindow() const
+    {
+        return ::IsWindow(m_hWnd);
+    }
+
+    BOOL KillTimer(UINT_PTR nIDEvent)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::KillTimer(m_hWnd, nIDEvent);
+    }
+
+    BOOL LockWindowUpdate(BOOL bLock = TRUE)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        if (bLock)
+            return ::LockWindowUpdate(m_hWnd);
+        return ::LockWindowUpdate(NULL);
+    }
+
+    BOOL ScreenToClient(LPPOINT lpPoint) const
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::ScreenToClient(m_hWnd, lpPoint);
+    }
+
+    LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::SendMessage(m_hWnd, message, wParam, lParam);
+    }
+
+    static LRESULT SendMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        ATLASSERT(::IsWindow(hWnd));
+        return ::SendMessage(hWnd, message, wParam, lParam);
+    }
+
+    HWND SetCapture()
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::SetCapture(m_hWnd);
+    }
+
+    HWND SetFocus()
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::SetFocus(m_hWnd);
+    }
+
+    UINT_PTR SetTimer(UINT_PTR nIDEvent, UINT nElapse, void (CALLBACK *lpfnTimer)(HWND, UINT, UINT_PTR, DWORD) = NULL)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::SetTimer(m_hWnd, nIDEvent, nElapse, reinterpret_cast<TIMERPROC>(lpfnTimer));
+    }
+
+    BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::SetWindowPos(m_hWnd, hWndInsertAfter, x, y, cx, cy, nFlags);
+    }
+
+    BOOL SetWindowText(LPCTSTR lpszString)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::SetWindowText(m_hWnd, lpszString);
+    }
+
+    BOOL ShowWindow(int nCmdShow)
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::ShowWindow(m_hWnd, nCmdShow);
+    }
+
+    BOOL UpdateWindow()
+    {
+        ATLASSERT(::IsWindow(m_hWnd));
+        return ::UpdateWindow(m_hWnd);
+    }
 };
 
 __declspec(selectany) RECT CWindow::rcDefault = { CW_USEDEFAULT, CW_USEDEFAULT, 0, 0 };
@@ -377,422 +377,422 @@ template <class TBase = CWindow, class TWinTraits = CControlWinTraits>
 class CWindowImplBaseT : public TBase, public CMessageMap
 {
 public:
-       enum { WINSTATE_DESTROYED = 0x00000001 };
-       DWORD                                                                   m_dwState;
-       const _ATL_MSG                                                  *m_pCurrentMsg;
-       CWndProcThunk                                                   m_thunk;
-       WNDPROC                                                                 m_pfnSuperWindowProc;
+    enum { WINSTATE_DESTROYED = 0x00000001 };
+    DWORD m_dwState;
+    const _ATL_MSG *m_pCurrentMsg;
+    CWndProcThunk m_thunk;
+    WNDPROC m_pfnSuperWindowProc;
 public:
-       CWindowImplBaseT()
-       {
-               m_dwState = 0;
-               m_pCurrentMsg = NULL;
-               m_pfnSuperWindowProc = ::DefWindowProc;
-       }
-
-       virtual void OnFinalMessage(HWND /* hWnd */)
-       {
-       }
-
-       BOOL SubclassWindow(HWND hWnd)
-       {
-               CWindowImplBaseT<TBase, TWinTraits>     *pThis;
-               WNDPROC                                                         newWindowProc;
-               WNDPROC                                                         oldWindowProc;
-               BOOL                                                            result;
-
-               ATLASSERT(m_hWnd == NULL);
-               ATLASSERT(::IsWindow(hWnd));
-
-               pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this);
-
-               result = m_thunk.Init(GetWindowProc(), this);
-               if (result == FALSE)
-                       return FALSE;
-               newWindowProc = m_thunk.GetWNDPROC();
-               oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
-               if (oldWindowProc == NULL)
-                       return FALSE;
-               m_pfnSuperWindowProc = oldWindowProc;
-               pThis->m_hWnd = hWnd;
-               return TRUE;
-       }
-
-       virtual WNDPROC GetWindowProc()
-       {
-               return WindowProc;
-       }
-
-       static DWORD GetWndStyle(DWORD dwStyle)
-       {
-               return TWinTraits::GetWndStyle(dwStyle);
-       }
-
-       static DWORD GetWndExStyle(DWORD dwExStyle)
-       {
-               return TWinTraits::GetWndExStyle(dwExStyle);
-       }
-
-       LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
-       {
-               CWindowImplBaseT<TBase, TWinTraits>     *pThis;
-
-               pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(this);
-               return ::CallWindowProc(m_pfnSuperWindowProc, pThis->m_hWnd, uMsg, wParam, lParam);
-       }
-
-       static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-       {
-               CWindowImplBaseT<TBase, TWinTraits>     *pThis;
-               WNDPROC                                                         newWindowProc;
-               WNDPROC                                                         GCCU(pOldProc);
-
-               pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(_AtlWinModule.ExtractCreateWndData());
-               ATLASSERT(pThis != NULL);
-               if (pThis == NULL)
-                       return 0;
-               pThis->m_thunk.Init(pThis->GetWindowProc(), pThis);
-               newWindowProc = pThis->m_thunk.GetWNDPROC();
-               pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
-               Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass
-               pThis->m_hWnd = hWnd;
-               return newWindowProc(hWnd, uMsg, wParam, lParam);
-       }
-
-       static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-       {
-               CWindowImplBaseT<TBase, TWinTraits>     *pThis = reinterpret_cast<CWindowImplBaseT< TBase, TWinTraits> *>(hWnd);
-               _ATL_MSG                                                        msg(pThis->m_hWnd, uMsg, wParam, lParam);
-               LRESULT                                                         lResult;
-               const _ATL_MSG                                          *previousMessage;
-               BOOL                                                            handled;
-               LONG_PTR                                                        saveWindowProc;
-
-               ATLASSERT(pThis != NULL && (pThis->m_dwState & WINSTATE_DESTROYED) == 0 && pThis->m_hWnd != NULL);
-               if (pThis == NULL || (pThis->m_dwState & WINSTATE_DESTROYED) != 0 || pThis->m_hWnd == NULL)
-                       return 0;
-
-               hWnd = pThis->m_hWnd;
-               previousMessage = pThis->m_pCurrentMsg;
-               pThis->m_pCurrentMsg = &msg;
-
-               handled = pThis->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, 0);
-               ATLASSERT(pThis->m_pCurrentMsg == &msg);
-
-               if (handled == FALSE)
-               {
-                       if (uMsg == WM_NCDESTROY)
-                       {
-                               saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
-                               lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
-                               if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC))
-                                       ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc));
-                               pThis->m_dwState |= WINSTATE_DESTROYED;
-                       }
-                       else
-                               lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
-               }
-               ATLASSERT(pThis->m_pCurrentMsg == &msg);
-               pThis->m_pCurrentMsg = previousMessage;
-               if (previousMessage == NULL && (pThis->m_dwState & WINSTATE_DESTROYED) != 0)
-               {
-                       pThis->m_dwState &= ~WINSTATE_DESTROYED;
-                       pThis->m_hWnd = NULL;
-                       pThis->OnFinalMessage(hWnd);
-               }
-               return lResult;
-       }
-
-       HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle,
-                                       _U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam)
-       {
-               HWND                                                            hWnd;
-
-               ATLASSERT(m_hWnd == NULL);
-               ATLASSERT(atom != 0);
-               if (atom == 0)
-                       return NULL;
-               if (m_thunk.Init(NULL, NULL) == FALSE)
-               {
-                       SetLastError(ERROR_OUTOFMEMORY);
-                       return NULL;
-               }
-
-               _AtlWinModule.AddCreateWndData(&m_thunk.cd, this);
-               if (MenuOrID.m_hMenu == NULL && (dwStyle & WS_CHILD) != 0)
-                       MenuOrID.m_hMenu = (HMENU)(UINT_PTR)this;
-               if (rect.m_lpRect == NULL)
-                       rect.m_lpRect = &TBase::rcDefault;
-               hWnd = ::CreateWindowEx(dwExStyle, reinterpret_cast<LPCWSTR>(MAKEINTATOM(atom)), szWindowName, dwStyle, rect.m_lpRect->left,
-                                       rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left, rect.m_lpRect->bottom - rect.m_lpRect->top,
-                                       hWndParent, MenuOrID.m_hMenu, _AtlBaseModule.GetModuleInstance(), lpCreateParam);
-
-               ATLASSERT(m_hWnd == hWnd);
-
-               return hWnd;
-       }
+    CWindowImplBaseT()
+    {
+        m_dwState = 0;
+        m_pCurrentMsg = NULL;
+        m_pfnSuperWindowProc = ::DefWindowProc;
+    }
+
+    virtual void OnFinalMessage(HWND /* hWnd */)
+    {
+    }
+
+    BOOL SubclassWindow(HWND hWnd)
+    {
+        CWindowImplBaseT<TBase, TWinTraits> *pThis;
+        WNDPROC newWindowProc;
+        WNDPROC oldWindowProc;
+        BOOL result;
+
+        ATLASSERT(m_hWnd == NULL);
+        ATLASSERT(::IsWindow(hWnd));
+
+        pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this);
+
+        result = m_thunk.Init(GetWindowProc(), this);
+        if (result == FALSE)
+            return FALSE;
+        newWindowProc = m_thunk.GetWNDPROC();
+        oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
+        if (oldWindowProc == NULL)
+            return FALSE;
+        m_pfnSuperWindowProc = oldWindowProc;
+        pThis->m_hWnd = hWnd;
+        return TRUE;
+    }
+
+    virtual WNDPROC GetWindowProc()
+    {
+        return WindowProc;
+    }
+
+    static DWORD GetWndStyle(DWORD dwStyle)
+    {
+        return TWinTraits::GetWndStyle(dwStyle);
+    }
+
+    static DWORD GetWndExStyle(DWORD dwExStyle)
+    {
+        return TWinTraits::GetWndExStyle(dwExStyle);
+    }
+
+    LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        CWindowImplBaseT<TBase, TWinTraits>    *pThis;
+
+        pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(this);
+        return ::CallWindowProc(m_pfnSuperWindowProc, pThis->m_hWnd, uMsg, wParam, lParam);
+    }
+
+    static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        CWindowImplBaseT<TBase, TWinTraits> *pThis;
+        WNDPROC newWindowProc;
+        WNDPROC GCCU(pOldProc);
+
+        pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits> *>(_AtlWinModule.ExtractCreateWndData());
+        ATLASSERT(pThis != NULL);
+        if (pThis == NULL)
+            return 0;
+        pThis->m_thunk.Init(pThis->GetWindowProc(), pThis);
+        newWindowProc = pThis->m_thunk.GetWNDPROC();
+        pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
+        Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass
+        pThis->m_hWnd = hWnd;
+        return newWindowProc(hWnd, uMsg, wParam, lParam);
+    }
+
+    static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        CWindowImplBaseT<TBase, TWinTraits> *pThis = reinterpret_cast<CWindowImplBaseT< TBase, TWinTraits> *>(hWnd);
+        _ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam);
+        LRESULT lResult;
+        const _ATL_MSG *previousMessage;
+        BOOL handled;
+        LONG_PTR saveWindowProc;
+
+        ATLASSERT(pThis != NULL && (pThis->m_dwState & WINSTATE_DESTROYED) == 0 && pThis->m_hWnd != NULL);
+        if (pThis == NULL || (pThis->m_dwState & WINSTATE_DESTROYED) != 0 || pThis->m_hWnd == NULL)
+            return 0;
+
+        hWnd = pThis->m_hWnd;
+        previousMessage = pThis->m_pCurrentMsg;
+        pThis->m_pCurrentMsg = &msg;
+
+        handled = pThis->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, 0);
+        ATLASSERT(pThis->m_pCurrentMsg == &msg);
+
+        if (handled == FALSE)
+        {
+            if (uMsg == WM_NCDESTROY)
+            {
+                saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
+                lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
+                if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC))
+                    ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc));
+                pThis->m_dwState |= WINSTATE_DESTROYED;
+            }
+            else
+                lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
+        }
+        ATLASSERT(pThis->m_pCurrentMsg == &msg);
+        pThis->m_pCurrentMsg = previousMessage;
+        if (previousMessage == NULL && (pThis->m_dwState & WINSTATE_DESTROYED) != 0)
+        {
+            pThis->m_dwState &= ~WINSTATE_DESTROYED;
+            pThis->m_hWnd = NULL;
+            pThis->OnFinalMessage(hWnd);
+        }
+        return lResult;
+    }
+
+    HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle,
+                    _U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam)
+    {
+        HWND                                hWnd;
+
+        ATLASSERT(m_hWnd == NULL);
+        ATLASSERT(atom != 0);
+        if (atom == 0)
+            return NULL;
+        if (m_thunk.Init(NULL, NULL) == FALSE)
+        {
+            SetLastError(ERROR_OUTOFMEMORY);
+            return NULL;
+        }
+
+        _AtlWinModule.AddCreateWndData(&m_thunk.cd, this);
+        if (MenuOrID.m_hMenu == NULL && (dwStyle & WS_CHILD) != 0)
+            MenuOrID.m_hMenu = (HMENU)(UINT_PTR)this;
+        if (rect.m_lpRect == NULL)
+            rect.m_lpRect = &TBase::rcDefault;
+        hWnd = ::CreateWindowEx(dwExStyle, reinterpret_cast<LPCWSTR>(MAKEINTATOM(atom)), szWindowName, dwStyle, rect.m_lpRect->left,
+                    rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left, rect.m_lpRect->bottom - rect.m_lpRect->top,
+                    hWndParent, MenuOrID.m_hMenu, _AtlBaseModule.GetModuleInstance(), lpCreateParam);
+
+        ATLASSERT(m_hWnd == hWnd);
+
+        return hWnd;
+    }
 };
 
 template <class T, class TBase = CWindow, class TWinTraits = CControlWinTraits>
 class CWindowImpl : public CWindowImplBaseT<TBase, TWinTraits>
 {
 public:
-       static LPCTSTR GetWndCaption()
-       {
-               return NULL;
-       }
-
-       HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0,
-                                       DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-       {
-               CWindowImplBaseT<TBase, TWinTraits>     *pThis;
-               ATOM                                                            atom;
-
-               ATLASSERT(m_hWnd == NULL);
-               pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this);
-
-               if (T::GetWndClassInfo().m_lpszOrigName == NULL)
-                       T::GetWndClassInfo().m_lpszOrigName = pThis->GetWndClassName();
-               atom = T::GetWndClassInfo().Register(&pThis->m_pfnSuperWindowProc);
-
-               if (szWindowName == NULL)
-                       szWindowName = T::GetWndCaption();
-               dwStyle = T::GetWndStyle(dwStyle);
-               dwExStyle = T::GetWndExStyle(dwExStyle);
-
-               return CWindowImplBaseT<TBase, TWinTraits>::Create(hWndParent, rect, szWindowName, dwStyle,
-                                               dwExStyle, MenuOrID, atom, lpCreateParam);
-       }
+    static LPCTSTR GetWndCaption()
+    {
+        return NULL;
+    }
+
+    HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0,
+                    DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
+    {
+        CWindowImplBaseT<TBase, TWinTraits> *pThis;
+        ATOM atom;
+
+        ATLASSERT(m_hWnd == NULL);
+        pThis = reinterpret_cast<CWindowImplBaseT<TBase, TWinTraits>*>(this);
+
+        if (T::GetWndClassInfo().m_lpszOrigName == NULL)
+            T::GetWndClassInfo().m_lpszOrigName = pThis->GetWndClassName();
+        atom = T::GetWndClassInfo().Register(&pThis->m_pfnSuperWindowProc);
+
+        if (szWindowName == NULL)
+            szWindowName = T::GetWndCaption();
+        dwStyle = T::GetWndStyle(dwStyle);
+        dwExStyle = T::GetWndExStyle(dwExStyle);
+
+        return CWindowImplBaseT<TBase, TWinTraits>::Create(hWndParent, rect, szWindowName, dwStyle,
+                        dwExStyle, MenuOrID, atom, lpCreateParam);
+    }
 };
 
 template <class TBase = CWindow, class TWinTraits = CControlWinTraits>
 class CContainedWindowT : public TBase
 {
 public:
-       CWndProcThunk                                                   m_thunk;
-       LPCTSTR                                                                 m_lpszClassName;
-       WNDPROC                                                                 m_pfnSuperWindowProc;
-       CMessageMap                                                             *m_pObject;
-       DWORD                                                                   m_dwMsgMapID;
-       const _ATL_MSG                                                  *m_pCurrentMsg;
+    CWndProcThunk m_thunk;
+    LPCTSTR m_lpszClassName;
+    WNDPROC m_pfnSuperWindowProc;
+    CMessageMap *m_pObject;
+    DWORD m_dwMsgMapID;
+    const _ATL_MSG *m_pCurrentMsg;
 public:
-       CContainedWindowT(CMessageMap *pObject, DWORD dwMsgMapID = 0)
-       {
-               m_lpszClassName = TBase::GetWndClassName();
-               m_pfnSuperWindowProc = ::DefWindowProc;
-               m_pObject = pObject;
-               m_dwMsgMapID = dwMsgMapID;
-               m_pCurrentMsg = NULL;
-       }
-
-       CContainedWindowT(LPTSTR lpszClassName, CMessageMap *pObject, DWORD dwMsgMapID = 0)
-       {
-               m_lpszClassName = lpszClassName;
-               m_pfnSuperWindowProc = ::DefWindowProc;
-               m_pObject = pObject;
-               m_dwMsgMapID = dwMsgMapID;
-               m_pCurrentMsg = NULL;
-       }
-
-       LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
-       {
-               return ::CallWindowProc(m_pfnSuperWindowProc, this->m_hWnd, uMsg, wParam, lParam);
-       }
-
-       BOOL SubclassWindow(HWND hWnd)
-       {
-               CContainedWindowT<TBase>                        *pThis;
-               WNDPROC                                                         newWindowProc;
-               WNDPROC                                                         oldWindowProc;
-               BOOL                                                            result;
-
-               ATLASSERT(m_hWnd == NULL);
-               ATLASSERT(::IsWindow(hWnd));
-
-               pThis = reinterpret_cast<CContainedWindowT<TBase> *>(this);
-
-               result = m_thunk.Init(WindowProc, pThis);
-               if (result == FALSE)
-                       return FALSE;
-               newWindowProc = m_thunk.GetWNDPROC();
-               oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
-               if (oldWindowProc == NULL)
-                       return FALSE;
-               m_pfnSuperWindowProc = oldWindowProc;
-               pThis->m_hWnd = hWnd;
-               return TRUE;
-       }
-
-       static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-       {
-               CContainedWindowT<TBase>                        *pThis;
-               WNDPROC                                                         newWindowProc;
-               WNDPROC                                                         GCCU(pOldProc);
-
-               pThis = reinterpret_cast<CContainedWindowT<TBase> *>(_AtlWinModule.ExtractCreateWndData());
-               ATLASSERT(pThis != NULL);
-               if (pThis == NULL)
-                       return 0;
-               pThis->m_thunk.Init(WindowProc, pThis);
-               newWindowProc = pThis->m_thunk.GetWNDPROC();
-               pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
-               Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass
-               pThis->m_hWnd = hWnd;
-               return newWindowProc(hWnd, uMsg, wParam, lParam);
-       }
-
-       static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-       {
-               CContainedWindowT<TBase>                        *pThis = reinterpret_cast<CContainedWindowT<TBase> *>(hWnd);
-               _ATL_MSG                                                        msg(pThis->m_hWnd, uMsg, wParam, lParam);
-               LRESULT                                                         lResult;
-               const _ATL_MSG                                          *previousMessage;
-               BOOL                                                            handled;
-               LONG_PTR                                                        saveWindowProc;
-
-               ATLASSERT(pThis != NULL && pThis->m_hWnd != NULL && pThis->m_pObject != NULL);
-               if (pThis == NULL || pThis->m_hWnd == NULL || pThis->m_pObject == NULL)
-                       return 0;
-
-               hWnd = pThis->m_hWnd;
-               previousMessage = pThis->m_pCurrentMsg;
-               pThis->m_pCurrentMsg = &msg;
-
-               handled = pThis->m_pObject->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, pThis->m_dwMsgMapID);
-               ATLASSERT(pThis->m_pCurrentMsg == &msg);
-
-               pThis->m_pCurrentMsg = previousMessage;
-               if (handled == FALSE)
-               {
-                       if (uMsg == WM_NCDESTROY)
-                       {
-                               saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
-                               lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
-                               if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC))
-                                       ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc));
-                               pThis->m_hWnd = NULL;
-                       }
-                       else
-                               lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
-               }
-               return lResult;
-       }
+    CContainedWindowT(CMessageMap *pObject, DWORD dwMsgMapID = 0)
+    {
+        m_lpszClassName = TBase::GetWndClassName();
+        m_pfnSuperWindowProc = ::DefWindowProc;
+        m_pObject = pObject;
+        m_dwMsgMapID = dwMsgMapID;
+        m_pCurrentMsg = NULL;
+    }
+
+    CContainedWindowT(LPTSTR lpszClassName, CMessageMap *pObject, DWORD dwMsgMapID = 0)
+    {
+        m_lpszClassName = lpszClassName;
+        m_pfnSuperWindowProc = ::DefWindowProc;
+        m_pObject = pObject;
+        m_dwMsgMapID = dwMsgMapID;
+        m_pCurrentMsg = NULL;
+    }
+
+    LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        return ::CallWindowProc(m_pfnSuperWindowProc, this->m_hWnd, uMsg, wParam, lParam);
+    }
+
+    BOOL SubclassWindow(HWND hWnd)
+    {
+        CContainedWindowT<TBase> *pThis;
+        WNDPROC newWindowProc;
+        WNDPROC oldWindowProc;
+        BOOL result;
+
+        ATLASSERT(m_hWnd == NULL);
+        ATLASSERT(::IsWindow(hWnd));
+
+        pThis = reinterpret_cast<CContainedWindowT<TBase> *>(this);
+
+        result = m_thunk.Init(WindowProc, pThis);
+        if (result == FALSE)
+            return FALSE;
+        newWindowProc = m_thunk.GetWNDPROC();
+        oldWindowProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
+        if (oldWindowProc == NULL)
+            return FALSE;
+        m_pfnSuperWindowProc = oldWindowProc;
+        pThis->m_hWnd = hWnd;
+        return TRUE;
+    }
+
+    static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        CContainedWindowT<TBase> *pThis;
+        WNDPROC newWindowProc;
+        WNDPROC GCCU(pOldProc);
+
+        pThis = reinterpret_cast<CContainedWindowT<TBase> *>(_AtlWinModule.ExtractCreateWndData());
+        ATLASSERT(pThis != NULL);
+        if (pThis == NULL)
+            return 0;
+        pThis->m_thunk.Init(WindowProc, pThis);
+        newWindowProc = pThis->m_thunk.GetWNDPROC();
+        pOldProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(newWindowProc)));
+        Unused(pOldProc); // TODO: should generate trace message if overwriting another subclass
+        pThis->m_hWnd = hWnd;
+        return newWindowProc(hWnd, uMsg, wParam, lParam);
+    }
+
+    static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        CContainedWindowT<TBase> *pThis = reinterpret_cast<CContainedWindowT<TBase> *>(hWnd);
+        _ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam);
+        LRESULT lResult;
+        const _ATL_MSG *previousMessage;
+        BOOL handled;
+        LONG_PTR saveWindowProc;
+
+        ATLASSERT(pThis != NULL && pThis->m_hWnd != NULL && pThis->m_pObject != NULL);
+        if (pThis == NULL || pThis->m_hWnd == NULL || pThis->m_pObject == NULL)
+            return 0;
+
+        hWnd = pThis->m_hWnd;
+        previousMessage = pThis->m_pCurrentMsg;
+        pThis->m_pCurrentMsg = &msg;
+
+        handled = pThis->m_pObject->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, pThis->m_dwMsgMapID);
+        ATLASSERT(pThis->m_pCurrentMsg == &msg);
+
+        pThis->m_pCurrentMsg = previousMessage;
+        if (handled == FALSE)
+        {
+            if (uMsg == WM_NCDESTROY)
+            {
+                saveWindowProc = ::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
+                lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
+                if (pThis->m_pfnSuperWindowProc != ::DefWindowProc && saveWindowProc == ::GetWindowLongPtr(hWnd, GWLP_WNDPROC))
+                    ::SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(pThis->m_pfnSuperWindowProc));
+                pThis->m_hWnd = NULL;
+            }
+            else
+                lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
+        }
+        return lResult;
+    }
 
 };
-typedef CContainedWindowT<CWindow>     CContainedWindow;
-
-#define BEGIN_MSG_MAP(theClass)                                                                                                                                                                                                \
-public:                                                                                                                                                                                                                                                \
-       BOOL ProcessWindowMessage(HWND GCCU(hWnd), UINT GCCU(uMsg), WPARAM GCCU(wParam), LPARAM GCCU(lParam), LRESULT &GCCU(lResult), DWORD dwMsgMapID = 0)     \
-       {                                                                                                                                                                                                                                               \
-               BOOL GCCU(bHandled) = TRUE;                                                                                                                                                                                     \
-               Unused(hWnd);                                                                                                                                                                                                           \
-               Unused(uMsg);                                                                                                                                                                                                           \
-               Unused(wParam);                                                                                                                                                                                                         \
-               Unused(lParam);                                                                                                                                                                                                         \
-               Unused(lResult);                                                                                                                                                                                                        \
-               Unused(bHandled);                                                                                                                                                                                                       \
-               switch(dwMsgMapID)                                                                                                                                                                                                      \
-               {                                                                                                                                                                                                                                       \
-               case 0:
-
-#define ALT_MSG_MAP(map)                                                                                                                                               \
-            break;                                                                                                                                                             \
+typedef CContainedWindowT<CWindow> CContainedWindow;
+
+#define BEGIN_MSG_MAP(theClass)                                                                                                \
+public:                                                                                                                        \
+    BOOL ProcessWindowMessage(HWND GCCU(hWnd), UINT GCCU(uMsg), WPARAM GCCU(wParam), LPARAM GCCU(lParam), LRESULT &GCCU(lResult), DWORD dwMsgMapID = 0)    \
+    {                                                                                                                        \
+        BOOL GCCU(bHandled) = TRUE;                                                                                            \
+        Unused(hWnd);                                                                                                        \
+        Unused(uMsg);                                                                                                        \
+        Unused(wParam);                                                                                                        \
+        Unused(lParam);                                                                                                        \
+        Unused(lResult);                                                                                                    \
+        Unused(bHandled);                                                                                                    \
+        switch(dwMsgMapID)                                                                                                    \
+        {                                                                                                                    \
+        case 0:
+
+#define ALT_MSG_MAP(map)                                                                        \
+            break;                                                                                \
         case map:
 
-#define END_MSG_MAP()                                                                                                                                                  \
-                       break;                                                                                                                                                          \
-               default:                                                                                                                                                                \
-                       ATLASSERT(FALSE);                                                                                                                                       \
-                       break;                                                                                                                                                          \
-               }                                                                                                                                                                               \
-               return FALSE;                                                                                                                                                   \
-       }
-
-#define MESSAGE_HANDLER(msg, func)                                                                                                                             \
-       if (uMsg == msg)                                                                                                                                                        \
-       {                                                                                                                                                                                       \
-               bHandled = TRUE;                                                                                                                                                \
-               lResult = func(uMsg, wParam, lParam, bHandled);                                                                                 \
-               if (bHandled)                                                                                                                                                   \
-                       return TRUE;                                                                                                                                            \
-       }
-
-#define MESSAGE_RANGE_HANDLER(msgFirst, msgLast, func)                                                                                 \
-       if (uMsg >= msgFirst && uMsg <= msgLast)                                                                                                        \
-       {                                                                                                                                                                                       \
-               bHandled = TRUE;                                                                                                                                                \
-               lResult = func(uMsg, wParam, lParam, bHandled);                                                                                 \
-               if (bHandled)                                                                                                                                                   \
-                       return TRUE;                                                                                                                                            \
-       }
-
-#define COMMAND_ID_HANDLER(id, func)                                                                                                                   \
-       if (uMsg == WM_COMMAND && id == LOWORD(wParam))                                                                                         \
-       {                                                                                                                                                                                       \
-               bHandled = TRUE;                                                                                                                                                \
-               lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled);                                 \
-               if (bHandled)                                                                                                                                                   \
-                       return TRUE;                                                                                                                                            \
-       }
-
-#define COMMAND_RANGE_HANDLER(idFirst, idLast, func)                                                                                   \
-       if (uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst  && LOWORD(wParam) <= idLast)                       \
-       {                                                                                                                                                                                       \
-               bHandled = TRUE;                                                                                                                                                \
-               lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled);                                 \
-               if (bHandled)                                                                                                                                                   \
-                       return TRUE;                                                                                                                                            \
-       }
-
-#define NOTIFY_CODE_HANDLER(cd, func)                                                                                                                  \
-       if(uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code)                                                                          \
-       {                                                                                                                                                                                       \
-               bHandled = TRUE;                                                                                                                                                \
-               lResult = func((int)wParam, (LPNMHDR)lParam, bHandled);                                                                 \
-               if (bHandled)                                                                                                                                                   \
-                       return TRUE;                                                                                                                                            \
-       }
-
-#define NOTIFY_HANDLER(id, cd, func)                                                                                                                   \
-       if(uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom && cd == ((LPNMHDR)lParam)->code)       \
-       {                                                                                                                                                                                       \
-               bHandled = TRUE;                                                                                                                                                \
-               lResult = func((int)wParam, (LPNMHDR)lParam, bHandled);                                                                 \
-               if (bHandled)                                                                                                                                                   \
-                       return TRUE;                                                                                                                                            \
-       }
-
-#define DECLARE_WND_CLASS_EX(WndClassName, style, bkgnd)                                                                               \
-static ATL::CWndClassInfo& GetWndClassInfo()                                                                                                   \
-{                                                                                                                                                                                              \
-       static ATL::CWndClassInfo wc =                                                                                                                          \
-       {                                                                                                                                                                                       \
-               { sizeof(WNDCLASSEX), style, StartWindowProc,                                                                                   \
-                 0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName, NULL },                              \
-               NULL, NULL, IDC_ARROW, TRUE, 0, _T("")                                                                                                  \
-       };                                                                                                                                                                                      \
-       return wc;                                                                                                                                                                      \
+#define END_MSG_MAP()                                                                            \
+            break;                                                                                \
+        default:                                                                                \
+            ATLASSERT(FALSE);                                                                    \
+            break;                                                                                \
+        }                                                                                        \
+        return FALSE;                                                                            \
+    }
+
+#define MESSAGE_HANDLER(msg, func)                                                                \
+    if (uMsg == msg)                                                                            \
+    {                                                                                            \
+        bHandled = TRUE;                                                                        \
+        lResult = func(uMsg, wParam, lParam, bHandled);                                            \
+        if (bHandled)                                                                            \
+            return TRUE;                                                                        \
+    }
+
+#define MESSAGE_RANGE_HANDLER(msgFirst, msgLast, func)                                            \
+    if (uMsg >= msgFirst && uMsg <= msgLast)                                                    \
+    {                                                                                            \
+        bHandled = TRUE;                                                                        \
+        lResult = func(uMsg, wParam, lParam, bHandled);                                            \
+        if (bHandled)                                                                            \
+            return TRUE;                                                                        \
+    }
+
+#define COMMAND_ID_HANDLER(id, func)                                                            \
+    if (uMsg == WM_COMMAND && id == LOWORD(wParam))                                                \
+    {                                                                                            \
+        bHandled = TRUE;                                                                        \
+        lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled);                    \
+        if (bHandled)                                                                            \
+            return TRUE;                                                                        \
+    }
+
+#define COMMAND_RANGE_HANDLER(idFirst, idLast, func)                                            \
+    if (uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst  && LOWORD(wParam) <= idLast)            \
+    {                                                                                            \
+        bHandled = TRUE;                                                                        \
+        lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled);                    \
+        if (bHandled)                                                                            \
+            return TRUE;                                                                        \
+    }
+
+#define NOTIFY_CODE_HANDLER(cd, func)                                                            \
+    if(uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code)                                        \
+    {                                                                                            \
+        bHandled = TRUE;                                                                        \
+        lResult = func((int)wParam, (LPNMHDR)lParam, bHandled);                                    \
+        if (bHandled)                                                                            \
+            return TRUE;                                                                        \
+    }
+
+#define NOTIFY_HANDLER(id, cd, func)                                                            \
+    if(uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom && cd == ((LPNMHDR)lParam)->code)    \
+    {                                                                                            \
+        bHandled = TRUE;                                                                        \
+        lResult = func((int)wParam, (LPNMHDR)lParam, bHandled);                                    \
+        if (bHandled)                                                                            \
+            return TRUE;                                                                        \
+    }
+
+#define DECLARE_WND_CLASS_EX(WndClassName, style, bkgnd)                                        \
+static ATL::CWndClassInfo& GetWndClassInfo()                                                    \
+{                                                                                                \
+    static ATL::CWndClassInfo wc =                                                                \
+    {                                                                                            \
+        { sizeof(WNDCLASSEX), style, StartWindowProc,                                            \
+          0, 0, NULL, NULL, NULL, (HBRUSH)(bkgnd + 1), NULL, WndClassName, NULL },                \
+        NULL, NULL, IDC_ARROW, TRUE, 0, _T("")                                                    \
+    };                                                                                            \
+    return wc;                                                                                    \
 }
 
 struct _ATL_WNDCLASSINFOW
 {
-       WNDCLASSEXW                                                             m_wc;
-       LPCWSTR                                                                 m_lpszOrigName;
-       WNDPROC                                                                 pWndProc;
-       LPCWSTR                                                                 m_lpszCursorID;
-       BOOL                                                                    m_bSystemCursor;
-       ATOM                                                                    m_atom;
-       WCHAR                                                                   m_szAutoName[5 + sizeof(void *)];
-
-       ATOM Register(WNDPROC *p)
-       {
-               if (m_wc.hInstance == NULL)
-                       m_wc.hInstance = _AtlBaseModule.GetModuleInstance();
-               if (m_atom == 0)
-                       m_atom = RegisterClassEx(&m_wc);
-               return m_atom;
-       }
+    WNDCLASSEXW m_wc;
+    LPCWSTR m_lpszOrigName;
+    WNDPROC pWndProc;
+    LPCWSTR m_lpszCursorID;
+    BOOL m_bSystemCursor;
+    ATOM m_atom;
+    WCHAR m_szAutoName[5 + sizeof(void *)];
+
+    ATOM Register(WNDPROC *p)
+    {
+        if (m_wc.hInstance == NULL)
+            m_wc.hInstance = _AtlBaseModule.GetModuleInstance();
+        if (m_atom == 0)
+            m_atom = RegisterClassEx(&m_wc);
+        return m_atom;
+    }
 };
 
 }; // namespace ATL
index 44bbe0d..7af2643 100644 (file)
@@ -24,8 +24,8 @@
 class IRegistrarBase : public IUnknown
 {
 public:
-       virtual HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item) = 0;
-       virtual HRESULT STDMETHODCALLTYPE ClearReplacements() = 0;
+    virtual HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item) = 0;
+    virtual HRESULT STDMETHODCALLTYPE ClearReplacements() = 0;
 };
 
 namespace ATL
@@ -34,731 +34,731 @@ namespace ATL
 class CRegObject : public IRegistrarBase
 {
 public:
-       typedef struct rep_list_str
-       {
-               LPOLESTR                                                        key;
-               LPOLESTR                                                        item;
-               int                                                                     key_len;
-               struct rep_list_str                                     *next;
-       } rep_list;
-
-       typedef struct
-       {
-               LPOLESTR                                                        str;
-               DWORD                                                           alloc;
-               DWORD                                                           len;
-       } strbuf;
-
-       rep_list                                                                *m_rep;
+    typedef struct rep_list_str
+    {
+        LPOLESTR key;
+        LPOLESTR item;
+        int key_len;
+        struct rep_list_str *next;
+    } rep_list;
+
+    typedef struct
+    {
+        LPOLESTR str;
+        DWORD alloc;
+        DWORD len;
+    } strbuf;
+
+    rep_list *m_rep;
 
 public:
-       CRegObject()
-       {
-               m_rep = NULL;
-       }
-
-       ~CRegObject()
-       {
-               HRESULT                                                         hResult;
-
-               hResult = ClearReplacements();
-               ATLASSERT(SUCCEEDED(hResult));
-               (void)hResult;
-       }
-
-       HRESULT STDMETHODCALLTYPE QueryInterface(const IID & /* riid */, void ** /* ppvObject */ )
-       {
-               ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function"));
-               return E_NOTIMPL;
-       }
-
-       ULONG STDMETHODCALLTYPE AddRef()
-       {
-               ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function"));
-               return 1;
-       }
-
-       ULONG STDMETHODCALLTYPE Release()
-       {
-               ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function"));
-               return 0;
-       }
-
-       HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item)
-       {
-               int                                                                     len;
-               rep_list                                                        *new_rep;
-
-               new_rep = reinterpret_cast<rep_list *>(HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list)));
-               if (new_rep == NULL)
-                       return E_OUTOFMEMORY;
-
-               new_rep->key_len  = lstrlenW(key);
-               new_rep->key = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR)));
-               if (new_rep->key == NULL)
-               {
-                       HeapFree(GetProcessHeap(), 0, new_rep);
-                       return E_OUTOFMEMORY;
-               }
-               memcpy(new_rep->key, key, (new_rep->key_len + 1) * sizeof(OLECHAR));
-
-               len = lstrlenW(item) + 1;
-               new_rep->item = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, len * sizeof(OLECHAR)));
-               if (new_rep->item == NULL)
-               {
-                       HeapFree(GetProcessHeap(), 0, new_rep->key);
-                       HeapFree(GetProcessHeap(), 0, new_rep);
-                       return E_OUTOFMEMORY;
-               }
-               memcpy(new_rep->item, item, len * sizeof(OLECHAR));
-
-               new_rep->next = m_rep;
-               m_rep = new_rep;
-
-               return S_OK;
-       }
-
-       HRESULT STDMETHODCALLTYPE ClearReplacements()
-       {
-               rep_list                                                        *iter;
-               rep_list                                                        *iter2;
-
-               iter = m_rep;
-               while (iter)
-               {
-                       iter2 = iter->next;
-                       HeapFree(GetProcessHeap(), 0, iter->key);
-                       HeapFree(GetProcessHeap(), 0, iter->item);
-                       HeapFree(GetProcessHeap(), 0, iter);
-                       iter = iter2;
-               }
-
-               m_rep = NULL;
-               return S_OK;
-       }
-
-       HRESULT STDMETHODCALLTYPE ResourceRegisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
-       {
-               return RegisterWithResource(resFileName, szID, szType, TRUE);
-       }
-
-       HRESULT STDMETHODCALLTYPE ResourceUnregisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
-       {
-               return RegisterWithResource(resFileName, szID, szType, FALSE);
-       }
-
-       HRESULT STDMETHODCALLTYPE FileRegister(LPCOLESTR fileName)
-       {
-               return RegisterWithFile(fileName, TRUE);
-       }
-
-       HRESULT STDMETHODCALLTYPE FileUnregister(LPCOLESTR fileName)
-       {
-               return RegisterWithFile(fileName, FALSE);
-       }
-
-       HRESULT STDMETHODCALLTYPE StringRegister(LPCOLESTR data)
-       {
-               return RegisterWithString(data, TRUE);
-       }
-
-       HRESULT STDMETHODCALLTYPE StringUnregister(LPCOLESTR data)
-       {
-               return RegisterWithString(data, FALSE);
-       }
-
-       HRESULT STDMETHODCALLTYPE ResourceRegister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
-       {
-               return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType);
-       }
-
-       HRESULT STDMETHODCALLTYPE ResourceUnregister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
-       {
-               return ResourceUnregisterSz(resFileName, MAKEINTRESOURCEW(nID), szType);
-       }
+    CRegObject()
+    {
+        m_rep = NULL;
+    }
+
+    ~CRegObject()
+    {
+        HRESULT hResult;
+
+        hResult = ClearReplacements();
+        ATLASSERT(SUCCEEDED(hResult));
+        (void)hResult;
+    }
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(const IID & /* riid */, void ** /* ppvObject */ )
+    {
+        ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function"));
+        return E_NOTIMPL;
+    }
+
+    ULONG STDMETHODCALLTYPE AddRef()
+    {
+        ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function"));
+        return 1;
+    }
+
+    ULONG STDMETHODCALLTYPE Release()
+    {
+        ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function"));
+        return 0;
+    }
+
+    HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item)
+    {
+        int len;
+        rep_list *new_rep;
+
+        new_rep = reinterpret_cast<rep_list *>(HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list)));
+        if (new_rep == NULL)
+            return E_OUTOFMEMORY;
+
+        new_rep->key_len  = lstrlenW(key);
+        new_rep->key = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR)));
+        if (new_rep->key == NULL)
+        {
+            HeapFree(GetProcessHeap(), 0, new_rep);
+            return E_OUTOFMEMORY;
+        }
+        memcpy(new_rep->key, key, (new_rep->key_len + 1) * sizeof(OLECHAR));
+
+        len = lstrlenW(item) + 1;
+        new_rep->item = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, len * sizeof(OLECHAR)));
+        if (new_rep->item == NULL)
+        {
+            HeapFree(GetProcessHeap(), 0, new_rep->key);
+            HeapFree(GetProcessHeap(), 0, new_rep);
+            return E_OUTOFMEMORY;
+        }
+        memcpy(new_rep->item, item, len * sizeof(OLECHAR));
+
+        new_rep->next = m_rep;
+        m_rep = new_rep;
+
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE ClearReplacements()
+    {
+        rep_list *iter;
+        rep_list *iter2;
+
+        iter = m_rep;
+        while (iter)
+        {
+            iter2 = iter->next;
+            HeapFree(GetProcessHeap(), 0, iter->key);
+            HeapFree(GetProcessHeap(), 0, iter->item);
+            HeapFree(GetProcessHeap(), 0, iter);
+            iter = iter2;
+        }
+
+        m_rep = NULL;
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE ResourceRegisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
+    {
+        return RegisterWithResource(resFileName, szID, szType, TRUE);
+    }
+
+    HRESULT STDMETHODCALLTYPE ResourceUnregisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
+    {
+        return RegisterWithResource(resFileName, szID, szType, FALSE);
+    }
+
+    HRESULT STDMETHODCALLTYPE FileRegister(LPCOLESTR fileName)
+    {
+        return RegisterWithFile(fileName, TRUE);
+    }
+
+    HRESULT STDMETHODCALLTYPE FileUnregister(LPCOLESTR fileName)
+    {
+        return RegisterWithFile(fileName, FALSE);
+    }
+
+    HRESULT STDMETHODCALLTYPE StringRegister(LPCOLESTR data)
+    {
+        return RegisterWithString(data, TRUE);
+    }
+
+    HRESULT STDMETHODCALLTYPE StringUnregister(LPCOLESTR data)
+    {
+        return RegisterWithString(data, FALSE);
+    }
+
+    HRESULT STDMETHODCALLTYPE ResourceRegister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
+    {
+        return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType);
+    }
+
+    HRESULT STDMETHODCALLTYPE ResourceUnregister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
+    {
+        return ResourceUnregisterSz(resFileName, MAKEINTRESOURCEW(nID), szType);
+    }
 
 protected:
-       HRESULT STDMETHODCALLTYPE RegisterWithResource(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL doRegister)
-       {
-               return resource_register(resFileName, szID, szType, doRegister);
-       }
+    HRESULT STDMETHODCALLTYPE RegisterWithResource(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL doRegister)
+    {
+        return resource_register(resFileName, szID, szType, doRegister);
+    }
 
-       HRESULT STDMETHODCALLTYPE RegisterWithFile(LPCOLESTR fileName, BOOL doRegister)
-       {
-               return file_register(fileName, doRegister);
-       }
+    HRESULT STDMETHODCALLTYPE RegisterWithFile(LPCOLESTR fileName, BOOL doRegister)
+    {
+        return file_register(fileName, doRegister);
+    }
 
-       HRESULT STDMETHODCALLTYPE RegisterWithString(LPCOLESTR data, BOOL doRegister)
-       {
-               return string_register(data, doRegister);
-       }
+    HRESULT STDMETHODCALLTYPE RegisterWithString(LPCOLESTR data, BOOL doRegister)
+    {
+        return string_register(data, doRegister);
+    }
 
 private:
-       inline LONG RegDeleteTreeX(HKEY parentKey, LPCTSTR subKeyName)
-       {
-               wchar_t                                                         szBuffer[256];
-               DWORD                                                           dwSize;
-               FILETIME                                                        time;
-               HKEY                                                            childKey;
-               LONG                                                            lRes;
-
-               ATLASSERT(parentKey != NULL);
-               lRes = RegOpenKeyEx(parentKey, subKeyName, 0, KEY_READ | KEY_WRITE, &childKey);
-               if (lRes != ERROR_SUCCESS)
-                       return lRes;
-
-               dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]);
-               while (RegEnumKeyExW(parentKey, 0, szBuffer, &dwSize, NULL, NULL, NULL, &time) == ERROR_SUCCESS)
-               {
-                       lRes = RegDeleteTreeX(childKey, szBuffer);
-                       if (lRes != ERROR_SUCCESS)
-                               return lRes;
-                       dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]);
-               }
-               RegCloseKey(childKey);
-               return RegDeleteKey(parentKey, subKeyName);
-       }
-
-       HRESULT strbuf_init(strbuf *buf)
-       {
-               buf->str = reinterpret_cast<LPOLESTR>(HeapAlloc(GetProcessHeap(), 0, 128 * sizeof(WCHAR)));
-               if (buf->str == NULL)
-                       return E_OUTOFMEMORY;
-               buf->alloc = 128;
-               buf->len = 0;
-               return S_OK;
-       }
-
-       HRESULT strbuf_write(LPCOLESTR str, strbuf *buf, int len)
-       {
-               LPOLESTR                                                        newBuffer;
-
-               if (len == -1)
-                       len = lstrlenW(str);
-               if (buf->len + len + 1 >= buf->alloc)
-               {
-                       buf->alloc = (buf->len + len) * 2;
-                       newBuffer = reinterpret_cast<LPOLESTR>(HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc * sizeof(WCHAR)));
-                       if (newBuffer == NULL)
-                               return E_OUTOFMEMORY;
-                       buf->str = newBuffer;
-               }
-               memcpy(buf->str + buf->len, str, len * sizeof(OLECHAR));
-               buf->len += len;
-               buf->str[buf->len] = '\0';
-               return S_OK;
-       }
-
-
-       HRESULT file_register(LPCOLESTR fileName, BOOL do_register)
-       {
-               HANDLE                                                          file;
-               DWORD                                                           filelen;
-               DWORD                                                           len;
-               LPWSTR                                                          regstrw;
-               LPSTR                                                           regstra;
-               LRESULT                                                         lres;
-               HRESULT                                                         hResult;
-
-               file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
-               if (file != INVALID_HANDLE_VALUE)
-               {
-                       filelen = GetFileSize(file, NULL);
-                       regstra = reinterpret_cast<LPSTR>(HeapAlloc(GetProcessHeap(), 0, filelen));
-                       if (regstra == NULL)
-                               return E_OUTOFMEMORY;
-                       lres = ReadFile(file, regstra, filelen, NULL, NULL);
-                       if (lres == ERROR_SUCCESS)
-                       {
-                               len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0) + 1;
-                               regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR)));
-                               if (regstrw == NULL)
-                               {
-                                       HeapFree(GetProcessHeap(), 0, regstra);
-                                       return E_OUTOFMEMORY;
-                               }
-                               MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len);
-                               regstrw[len - 1] = '\0';
-
-                               hResult = string_register(regstrw, do_register);
-
-                               HeapFree(GetProcessHeap(), 0, regstrw);
-                       }
-                       else
-                       {
-                               hResult = HRESULT_FROM_WIN32(lres);
-                       }
-                       HeapFree(GetProcessHeap(), 0, regstra);
-                       CloseHandle(file);
-               }
-               else
-               {
-                       hResult = HRESULT_FROM_WIN32(GetLastError());
-               }
-
-               return hResult;
-       }
-
-       HRESULT resource_register(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
-       {
-               HINSTANCE                                                       hins;
-               HRSRC                                                           src;
-               HGLOBAL                                                         regstra;
-               LPWSTR                                                          regstrw;
-               DWORD                                                           len;
-               DWORD                                                           reslen;
-               HRESULT                                                         hResult;
-
-               hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
-               if (hins)
-               {
-                       src = FindResourceW(hins, szID, szType);
-                       if (src)
-                       {
-                               regstra = LoadResource(hins, src);
-                               reslen = SizeofResource(hins, src);
-                               if (regstra)
-                               {
-                                       len = MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, NULL, 0) + 1;
-                                       regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR)));
-                                       if (regstrw == NULL)
-                                               return E_OUTOFMEMORY;
-         &