dlls/atl/atl.c

   1 /*
   2  * Copyright 2012 Stefan Leichter
   3  * Copyright 2012 Jacek Caban for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21
  22 #include "atlbase.h"
  23 #include "atlcom.h"
  24
  25 #include "wine/debug.h"
  26 #include "wine/heap.h"
  27 #include "wine/unicode.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(atl);
  30
  31 #define ATLVer1Size FIELD_OFFSET(_ATL_MODULEW, dwAtlBuildVer)
  32
  33 HINSTANCE atl_instance;
  34
  35 typedef unsigned char cpp_bool;
  36
  37 static ICatRegister *catreg;
  38
  39 /***********************************************************************
  40  *           AtlAdvise         [atl100.@]
  41  */
  42 HRESULT WINAPI AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, DWORD *pdw)
  43 {
  44     IConnectionPointContainer *container;
  45     IConnectionPoint *cp;
  46     HRESULT hres;
  47
  48     TRACE("%p %p %p %p\n", pUnkCP, pUnk, iid, pdw);
  49
  50     if(!pUnkCP)
  51         return E_INVALIDARG;
  52
  53     hres = IUnknown_QueryInterface(pUnkCP, &IID_IConnectionPointContainer, (void**)&container);
  54     if(FAILED(hres))
  55         return hres;
  56
  57     hres = IConnectionPointContainer_FindConnectionPoint(container, iid, &cp);
  58     IConnectionPointContainer_Release(container);
  59     if(FAILED(hres))
  60         return hres;
  61
  62     hres = IConnectionPoint_Advise(cp, pUnk, pdw);
  63     IConnectionPoint_Release(cp);
  64     return hres;
  65 }
  66
  67 /***********************************************************************
  68  *           AtlUnadvise         [atl100.@]
  69  */
  70 HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw)
  71 {
  72     IConnectionPointContainer *container;
  73     IConnectionPoint *cp;
  74     HRESULT hres;
  75
  76     TRACE("%p %p %d\n", pUnkCP, iid, dw);
  77
  78     if(!pUnkCP)
  79         return E_INVALIDARG;
  80
  81     hres = IUnknown_QueryInterface(pUnkCP, &IID_IConnectionPointContainer, (void**)&container);
  82     if(FAILED(hres))
  83         return hres;
  84
  85     hres = IConnectionPointContainer_FindConnectionPoint(container, iid, &cp);
  86     IConnectionPointContainer_Release(container);
  87     if(FAILED(hres))
  88         return hres;
  89
  90     hres = IConnectionPoint_Unadvise(cp, dw);
  91     IConnectionPoint_Release(cp);
  92     return hres;
  93 }
  94
  95 /***********************************************************************
  96  *           AtlFreeMarshalStream         [atl100.@]
  97  */
  98 HRESULT WINAPI AtlFreeMarshalStream(IStream *stm)
  99 {
 100     FIXME("%p\n", stm);
 101     return S_OK;
 102 }
 103
 104 /***********************************************************************
 105  *           AtlMarshalPtrInProc         [atl100.@]
 106  */
 107 HRESULT WINAPI AtlMarshalPtrInProc(IUnknown *pUnk, const IID *iid, IStream **pstm)
 108 {
 109     FIXME("%p %p %p\n", pUnk, iid, pstm);
 110     return E_FAIL;
 111 }
 112
 113 /***********************************************************************
 114  *           AtlUnmarshalPtr              [atl100.@]
 115  */
 116 HRESULT WINAPI AtlUnmarshalPtr(IStream *stm, const IID *iid, IUnknown **ppUnk)
 117 {
 118     FIXME("%p %p %p\n", stm, iid, ppUnk);
 119     return E_FAIL;
 120 }
 121
 122 /***********************************************************************
 123  *           AtlCreateTargetDC         [atl100.@]
 124  */
 125 HDC WINAPI AtlCreateTargetDC( HDC hdc, DVTARGETDEVICE *dv )
 126 {
 127     static const WCHAR displayW[] = {'d','i','s','p','l','a','y',0};
 128     const WCHAR *driver = NULL, *device = NULL, *port = NULL;
 129     DEVMODEW *devmode = NULL;
 130
 131     TRACE( "(%p, %p)\n", hdc, dv );
 132
 133     if (dv)
 134     {
 135         if (dv->tdDriverNameOffset) driver  = (WCHAR *)((char *)dv + dv->tdDriverNameOffset);
 136         if (dv->tdDeviceNameOffset) device  = (WCHAR *)((char *)dv + dv->tdDeviceNameOffset);
 137         if (dv->tdPortNameOffset)   port    = (WCHAR *)((char *)dv + dv->tdPortNameOffset);
 138         if (dv->tdExtDevmodeOffset) devmode = (DEVMODEW *)((char *)dv + dv->tdExtDevmodeOffset);
 139     }
 140     else
 141     {
 142         if (hdc) return hdc;
 143         driver = displayW;
 144     }
 145     return CreateDCW( driver, device, port, devmode );
 146 }
 147
 148 /***********************************************************************
 149  *           AtlHiMetricToPixel              [atl100.@]
 150  */
 151 void WINAPI AtlHiMetricToPixel(const SIZEL* lpHiMetric, SIZEL* lpPix)
 152 {
 153     HDC dc = GetDC(NULL);
 154     lpPix->cx = lpHiMetric->cx * GetDeviceCaps( dc, LOGPIXELSX ) / 100;
 155     lpPix->cy = lpHiMetric->cy * GetDeviceCaps( dc, LOGPIXELSY ) / 100;
 156     ReleaseDC( NULL, dc );
 157 }
 158
 159 /***********************************************************************
 160  *           AtlPixelToHiMetric              [atl100.@]
 161  */
 162 void WINAPI AtlPixelToHiMetric(const SIZEL* lpPix, SIZEL* lpHiMetric)
 163 {
 164     HDC dc = GetDC(NULL);
 165     lpHiMetric->cx = 100 * lpPix->cx / GetDeviceCaps( dc, LOGPIXELSX );
 166     lpHiMetric->cy = 100 * lpPix->cy / GetDeviceCaps( dc, LOGPIXELSY );
 167     ReleaseDC( NULL, dc );
 168 }
 169
 170 /***********************************************************************
 171  *           AtlComPtrAssign              [atl100.@]
 172  */
 173 IUnknown* WINAPI AtlComPtrAssign(IUnknown** pp, IUnknown *p)
 174 {
 175     TRACE("(%p %p)\n", pp, p);
 176
 177     if (p) IUnknown_AddRef(p);
 178     if (*pp) IUnknown_Release(*pp);
 179     *pp = p;
 180     return p;
 181 }
 182
 183 /***********************************************************************
 184  *           AtlComQIPtrAssign              [atl100.@]
 185  */
 186 IUnknown* WINAPI AtlComQIPtrAssign(IUnknown** pp, IUnknown *p, REFIID riid)
 187 {
 188     IUnknown *new_p = NULL;
 189
 190     TRACE("(%p %p %s)\n", pp, p, debugstr_guid(riid));
 191
 192     if (p) IUnknown_QueryInterface(p, riid, (void **)&new_p);
 193     if (*pp) IUnknown_Release(*pp);
 194     *pp = new_p;
 195     return new_p;
 196 }
 197
 198 /***********************************************************************
 199  *           AtlInternalQueryInterface     [atl100.@]
 200  */
 201 HRESULT WINAPI AtlInternalQueryInterface(void* this, const _ATL_INTMAP_ENTRY* pEntries,  REFIID iid, void** ppvObject)
 202 {
 203     int i = 0;
 204     HRESULT rc = E_NOINTERFACE;
 205     TRACE("(%p, %p, %s, %p)\n",this, pEntries, debugstr_guid(iid), ppvObject);
 206
 207     if (IsEqualGUID(iid,&IID_IUnknown))
 208     {
 209         TRACE("Returning IUnknown\n");
 210         *ppvObject = ((LPSTR)this+pEntries[0].dw);
 211         IUnknown_AddRef((IUnknown*)*ppvObject);
 212         return S_OK;
 213     }
 214
 215     while (pEntries[i].pFunc != 0)
 216     {
 217         TRACE("Trying entry %i (%s %i %p)\n",i,debugstr_guid(pEntries[i].piid),
 218               pEntries[i].dw, pEntries[i].pFunc);
 219
 220         if (!pEntries[i].piid || IsEqualGUID(iid,pEntries[i].piid))
 221         {
 222             TRACE("MATCH\n");
 223             if (pEntries[i].pFunc == (_ATL_CREATORARGFUNC*)1)
 224             {
 225                 TRACE("Offset\n");
 226                 *ppvObject = ((LPSTR)this+pEntries[i].dw);
 227                 IUnknown_AddRef((IUnknown*)*ppvObject);
 228                 return S_OK;
 229             }
 230             else
 231             {
 232                 TRACE("Function\n");
 233                 rc = pEntries[i].pFunc(this, iid, ppvObject, pEntries[i].dw);
 234                 if(rc==S_OK || pEntries[i].piid)
 235                     return rc;
 236             }
 237         }
 238         i++;
 239     }
 240     TRACE("Done returning (0x%x)\n",rc);
 241     return rc;
 242 }
 243
 244 /***********************************************************************
 245  *           AtlIPersistStreamInit_Load      [atl100.@]
 246  */
 247 HRESULT WINAPI AtlIPersistStreamInit_Load( LPSTREAM pStm, ATL_PROPMAP_ENTRY *pMap,
 248                                            void *pThis, IUnknown *pUnk)
 249 {
 250     FIXME("(%p, %p, %p, %p)\n", pStm, pMap, pThis, pUnk);
 251
 252     return S_OK;
 253 }
 254
 255 /***********************************************************************
 256  *           AtlIPersistStreamInit_Save      [atl100.@]
 257  */
 258 HRESULT WINAPI AtlIPersistStreamInit_Save(LPSTREAM pStm, BOOL fClearDirty,
 259                                           ATL_PROPMAP_ENTRY *pMap, void *pThis,
 260                                           IUnknown *pUnk)
 261 {
 262     FIXME("(%p, %d, %p, %p, %p)\n", pStm, fClearDirty, pMap, pThis, pUnk);
 263
 264     return S_OK;
 265 }
 266
 267 /***********************************************************************
 268  *           AtlIPersistPropertyBag_Load      [atl100.@]
 269  */
 270 HRESULT WINAPI AtlIPersistPropertyBag_Load(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog,
 271                                            ATL_PROPMAP_ENTRY *pMap, void *pThis,
 272                                            IUnknown *pUnk)
 273 {
 274     FIXME("(%p, %p, %p, %p, %p)\n", pPropBag, pErrorLog, pMap, pThis, pUnk);
 275
 276     return S_OK;
 277 }
 278
 279 /***********************************************************************
 280  *           AtlIPersistPropertyBag_Save     [atl100.@]
 281  */
 282 HRESULT WINAPI AtlIPersistPropertyBag_Save(LPPROPERTYBAG pPropBag, BOOL fClearDirty,
 283                                            BOOL fSaveAll, ATL_PROPMAP_ENTRY *pMap,
 284                                            void *pThis, IUnknown *pUnk)
 285 {
 286     FIXME("(%p, %d, %d, %p, %p, %p)\n", pPropBag, fClearDirty, fSaveAll, pMap, pThis, pUnk);
 287
 288     return S_OK;
 289 }
 290
 291 /***********************************************************************
 292  *           AtlModuleAddTermFunc            [atl100.@]
 293  */
 294 HRESULT WINAPI AtlModuleAddTermFunc(_ATL_MODULE *pM, _ATL_TERMFUNC *pFunc, DWORD_PTR dw)
 295 {
 296     _ATL_TERMFUNC_ELEM *termfunc_elem;
 297
 298     TRACE("version %04x (%p %p %ld)\n", _ATL_VER, pM, pFunc, dw);
 299
 300     if (_ATL_VER > _ATL_VER_30 || pM->cbSize > ATLVer1Size) {
 301         termfunc_elem = HeapAlloc(GetProcessHeap(), 0, sizeof(_ATL_TERMFUNC_ELEM));
 302         termfunc_elem->pFunc = pFunc;
 303         termfunc_elem->dw = dw;
 304         termfunc_elem->pNext = pM->m_pTermFuncs;
 305
 306         pM->m_pTermFuncs = termfunc_elem;
 307     }
 308
 309     return S_OK;
 310 }
 311
 312 #if _ATL_VER > _ATL_VER_30
 313
 314 /***********************************************************************
 315  *           AtlCallTermFunc              [atl100.@]
 316  */
 317 void WINAPI AtlCallTermFunc(_ATL_MODULE *pM)
 318 {
 319     _ATL_TERMFUNC_ELEM *iter = pM->m_pTermFuncs, *tmp;
 320
 321     TRACE("(%p)\n", pM);
 322
 323     while(iter) {
 324         iter->pFunc(iter->dw);
 325         tmp = iter;
 326         iter = iter->pNext;
 327         HeapFree(GetProcessHeap(), 0, tmp);
 328     }
 329
 330     pM->m_pTermFuncs = NULL;
 331 }
 332
 333 #endif
 334
 335 /***********************************************************************
 336  *           AtlLoadTypeLib             [atl100.56]
 337  */
 338 HRESULT WINAPI AtlLoadTypeLib(HINSTANCE inst, LPCOLESTR lpszIndex,
 339         BSTR *pbstrPath, ITypeLib **ppTypeLib)
 340 {
 341     size_t path_len, index_len;
 342     ITypeLib *typelib = NULL;
 343     WCHAR *path;
 344     HRESULT hres;
 345
 346     static const WCHAR tlb_extW[] = {'.','t','l','b',0};
 347
 348     TRACE("(%p %s %p %p)\n", inst, debugstr_w(lpszIndex), pbstrPath, ppTypeLib);
 349
 350     index_len = lpszIndex ? strlenW(lpszIndex) : 0;
 351     path = heap_alloc((MAX_PATH+index_len)*sizeof(WCHAR) + sizeof(tlb_extW));
 352     if(!path)
 353         return E_OUTOFMEMORY;
 354
 355     path_len = GetModuleFileNameW(inst, path, MAX_PATH);
 356     if(!path_len) {
 357         heap_free(path);
 358         return HRESULT_FROM_WIN32(GetLastError());
 359     }
 360
 361     if(index_len)
 362         memcpy(path+path_len, lpszIndex, (index_len+1)*sizeof(WCHAR));
 363
 364     hres = LoadTypeLib(path, &typelib);
 365     if(FAILED(hres)) {
 366         WCHAR *ptr;
 367
 368         for(ptr = path+path_len-1; ptr > path && *ptr != '\\' && *ptr != '.'; ptr--);
 369         if(*ptr != '.')
 370             ptr = path+path_len;
 371         memcpy(ptr, tlb_extW, sizeof(tlb_extW));
 372         hres = LoadTypeLib(path, &typelib);
 373     }
 374
 375     if(SUCCEEDED(hres)) {
 376         *pbstrPath = SysAllocString(path);
 377         if(!*pbstrPath) {
 378             ITypeLib_Release(typelib);
 379             hres = E_OUTOFMEMORY;
 380         }
 381     }
 382
 383     heap_free(path);
 384     if(FAILED(hres))
 385         return hres;
 386
 387     *ppTypeLib = typelib;
 388     return S_OK;
 389 }
 390
 391 #if _ATL_VER <= _ATL_VER_80
 392
 393 /***********************************************************************
 394  *           AtlRegisterTypeLib         [atl80.19]
 395  */
 396 HRESULT WINAPI AtlRegisterTypeLib(HINSTANCE inst, const WCHAR *index)
 397 {
 398     ITypeLib *typelib;
 399     BSTR path;
 400     HRESULT hres;
 401
 402     TRACE("(%p %s)\n", inst, debugstr_w(index));
 403
 404     hres = AtlLoadTypeLib(inst, index, &path, &typelib);
 405     if(FAILED(hres))
 406         return hres;
 407
 408     hres = RegisterTypeLib(typelib, path, NULL); /* FIXME: pass help directory */
 409     ITypeLib_Release(typelib);
 410     SysFreeString(path);
 411     return hres;
 412 }
 413
 414 #endif
 415
 416 #if _ATL_VER > _ATL_VER_30
 417
 418 /***********************************************************************
 419  *           AtlWinModuleInit                          [atl100.65]
 420  */
 421 HRESULT WINAPI AtlWinModuleInit(_ATL_WIN_MODULE *winmod)
 422 {
 423     TRACE("(%p)\n", winmod);
 424
 425     if(winmod->cbSize != sizeof(*winmod))
 426         return E_INVALIDARG;
 427
 428     InitializeCriticalSection(&winmod->m_csWindowCreate);
 429     winmod->m_pCreateWndList = NULL;
 430     return S_OK;
 431 }
 432
 433 /***********************************************************************
 434  *           AtlWinModuleAddCreateWndData              [atl100.43]
 435  */
 436 void WINAPI AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE *pM, _AtlCreateWndData *pData, void *pvObject)
 437 {
 438     TRACE("(%p, %p, %p)\n", pM, pData, pvObject);
 439
 440     pData->m_pThis = pvObject;
 441     pData->m_dwThreadID = GetCurrentThreadId();
 442
 443     EnterCriticalSection(&pM->m_csWindowCreate);
 444     pData->m_pNext = pM->m_pCreateWndList;
 445     pM->m_pCreateWndList = pData;
 446     LeaveCriticalSection(&pM->m_csWindowCreate);
 447 }
 448
 449 /***********************************************************************
 450  *           AtlWinModuleExtractCreateWndData          [atl100.44]
 451  */
 452 void* WINAPI AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE *winmod)
 453 {
 454     _AtlCreateWndData *iter, *prev = NULL;
 455     DWORD thread_id;
 456
 457     TRACE("(%p)\n", winmod);
 458
 459     thread_id = GetCurrentThreadId();
 460
 461     EnterCriticalSection(&winmod->m_csWindowCreate);
 462
 463     for(iter = winmod->m_pCreateWndList; iter && iter->m_dwThreadID != thread_id; iter = iter->m_pNext)
 464         prev = iter;
 465     if(iter) {
 466         if(prev)
 467             prev->m_pNext = iter->m_pNext;
 468         else
 469             winmod->m_pCreateWndList = iter->m_pNext;
 470     }
 471
 472     LeaveCriticalSection(&winmod->m_csWindowCreate);
 473
 474     return iter ? iter->m_pThis : NULL;
 475 }
 476
 477 /***********************************************************************
 478  *           AtlComModuleGetClassObject                [atl100.15]
 479  */
 480 #if _ATL_VER < _ATL_VER_110
 481 HRESULT WINAPI AtlComModuleGetClassObject(_ATL_COM_MODULE *pm, REFCLSID rclsid, REFIID riid, void **ppv)
 482 {
 483     _ATL_OBJMAP_ENTRY **iter;
 484     HRESULT hres;
 485
 486     TRACE("(%p %s %s %p)\n", pm, debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 487
 488     if(!pm)
 489         return E_INVALIDARG;
 490
 491     for(iter = pm->m_ppAutoObjMapFirst; iter < pm->m_ppAutoObjMapLast; iter++) {
 492         if(IsEqualCLSID((*iter)->pclsid, rclsid) && (*iter)->pfnGetClassObject) {
 493             if(!(*iter)->pCF)
 494                 hres = (*iter)->pfnGetClassObject((*iter)->pfnCreateInstance, &IID_IUnknown, (void**)&(*iter)->pCF);
 495             if((*iter)->pCF)
 496                 hres = IUnknown_QueryInterface((*iter)->pCF, riid, ppv);
 497             TRACE("returning %p (%08x)\n", *ppv, hres);
 498             return hres;
 499         }
 500     }
 501
 502     WARN("Class %s not found\n", debugstr_guid(rclsid));
 503     return CLASS_E_CLASSNOTAVAILABLE;
 504 }
 505 #else
 506 HRESULT WINAPI AtlComModuleGetClassObject(_ATL_COM_MODULE *pm, REFCLSID rclsid, REFIID riid, void **ppv)
 507 {
 508     _ATL_OBJMAP_ENTRY_EX **iter;
 509     HRESULT hres;
 510
 511     TRACE("(%p %s %s %p)\n", pm, debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 512
 513     if(!pm)
 514         return E_INVALIDARG;
 515
 516     for(iter = pm->m_ppAutoObjMapFirst; iter < pm->m_ppAutoObjMapLast; iter++) {
 517         if(IsEqualCLSID((*iter)->pclsid, rclsid) && (*iter)->pfnGetClassObject) {
 518             if(!(*iter)->pCache->pCF)
 519                 hres = (*iter)->pfnGetClassObject((*iter)->pfnCreateInstance, &IID_IUnknown, (void**)&(*iter)->pCache->pCF);
 520             if((*iter)->pCache->pCF)
 521                 hres = IUnknown_QueryInterface((*iter)->pCache->pCF, riid, ppv);
 522             TRACE("returning %p (%08x)\n", *ppv, hres);
 523             return hres;
 524         }
 525     }
 526
 527     WARN("Class %s not found\n", debugstr_guid(rclsid));
 528     return CLASS_E_CLASSNOTAVAILABLE;
 529 }
 530 #endif
 531
 532 /***********************************************************************
 533  *           AtlComModuleRegisterClassObjects   [atl100.17]
 534  */
 535 #if _ATL_VER < _ATL_VER_110
 536 HRESULT WINAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE *module, DWORD context, DWORD flags)
 537 {
 538     _ATL_OBJMAP_ENTRY **iter;
 539     IUnknown *unk;
 540     HRESULT hres;
 541
 542     TRACE("(%p %x %x)\n", module, context, flags);
 543
 544     if(!module)
 545         return E_INVALIDARG;
 546
 547     for(iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++) {
 548         if(!(*iter)->pfnGetClassObject)
 549             continue;
 550
 551         hres = (*iter)->pfnGetClassObject((*iter)->pfnCreateInstance, &IID_IUnknown, (void**)&unk);
 552         if(FAILED(hres))
 553             return hres;
 554
 555         hres = CoRegisterClassObject((*iter)->pclsid, unk, context, flags, &(*iter)->dwRegister);
 556         IUnknown_Release(unk);
 557         if(FAILED(hres))
 558             return hres;
 559     }
 560
 561    return S_OK;
 562 }
 563 #else
 564 HRESULT WINAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE *module, DWORD context, DWORD flags)
 565 {
 566     _ATL_OBJMAP_ENTRY_EX **iter;
 567     IUnknown *unk;
 568     HRESULT hres;
 569
 570     TRACE("(%p %x %x)\n", module, context, flags);
 571
 572     if(!module)
 573         return E_INVALIDARG;
 574
 575     for(iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++) {
 576         if(!(*iter)->pfnGetClassObject)
 577             continue;
 578
 579         hres = (*iter)->pfnGetClassObject((*iter)->pfnCreateInstance, &IID_IUnknown, (void**)&unk);
 580         if(FAILED(hres))
 581             return hres;
 582
 583         hres = CoRegisterClassObject((*iter)->pclsid, unk, context, flags, &(*iter)->pCache->dwRegister);
 584         IUnknown_Release(unk);
 585         if(FAILED(hres))
 586             return hres;
 587     }
 588
 589    return S_OK;
 590 }
 591 #endif
 592
 593 /***********************************************************************
 594  *           AtlComModuleRevokeClassObjects   [atl100.20]
 595  */
 596 #if _ATL_VER < _ATL_VER_110
 597 HRESULT WINAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE *module)
 598 {
 599     _ATL_OBJMAP_ENTRY **iter;
 600     HRESULT hres;
 601
 602     TRACE("(%p)\n", module);
 603
 604     if(!module)
 605         return E_INVALIDARG;
 606
 607     for(iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++) {
 608         hres = CoRevokeClassObject((*iter)->dwRegister);
 609         if(FAILED(hres))
 610             return hres;
 611     }
 612
 613     return S_OK;
 614 }
 615 #else
 616 HRESULT WINAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE *module)
 617 {
 618     _ATL_OBJMAP_ENTRY_EX **iter;
 619     HRESULT hres;
 620
 621     TRACE("(%p)\n", module);
 622
 623     if(!module)
 624         return E_INVALIDARG;
 625
 626     for(iter = module->m_ppAutoObjMapFirst; iter < module->m_ppAutoObjMapLast; iter++) {
 627         hres = CoRevokeClassObject((*iter)->pCache->dwRegister);
 628         if(FAILED(hres))
 629             return hres;
 630     }
 631
 632     return S_OK;
 633 }
 634 #endif
 635
 636 /***********************************************************************
 637  *           AtlComModuleUnregisterServer       [atl100.22]
 638  */
 639 #if _ATL_VER < _ATL_VER_110
 640 HRESULT WINAPI AtlComModuleUnregisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid)
 641 {
 642     const struct _ATL_CATMAP_ENTRY *catmap;
 643     _ATL_OBJMAP_ENTRY **iter;
 644     HRESULT hres;
 645
 646     TRACE("(%p %x %s)\n", mod, bRegTypeLib, debugstr_guid(clsid));
 647
 648     for(iter = mod->m_ppAutoObjMapFirst; iter < mod->m_ppAutoObjMapLast; iter++) {
 649         if(!*iter || (clsid && !IsEqualCLSID((*iter)->pclsid, clsid)))
 650             continue;
 651
 652         TRACE("Unregistering clsid %s\n", debugstr_guid((*iter)->pclsid));
 653
 654         catmap = (*iter)->pfnGetCategoryMap();
 655         if(catmap) {
 656             hres = AtlRegisterClassCategoriesHelper((*iter)->pclsid, catmap, FALSE);
 657             if(FAILED(hres))
 658                 return hres;
 659         }
 660
 661         hres = (*iter)->pfnUpdateRegistry(FALSE);
 662         if(FAILED(hres))
 663             return hres;
 664     }
 665
 666     if(bRegTypeLib) {
 667         ITypeLib *typelib;
 668         TLIBATTR *attr;
 669         BSTR path;
 670
 671         hres = AtlLoadTypeLib(mod->m_hInstTypeLib, NULL, &path, &typelib);
 672         if(FAILED(hres))
 673             return hres;
 674
 675         SysFreeString(path);
 676         hres = ITypeLib_GetLibAttr(typelib, &attr);
 677         if(SUCCEEDED(hres)) {
 678             hres = UnRegisterTypeLib(&attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, attr->lcid, attr->syskind);
 679             ITypeLib_ReleaseTLibAttr(typelib, attr);
 680         }
 681         ITypeLib_Release(typelib);
 682         if(FAILED(hres))
 683             return hres;
 684     }
 685
 686     return S_OK;
 687 }
 688 #else
 689 HRESULT WINAPI AtlComModuleUnregisterServer(_ATL_COM_MODULE *mod, BOOL bRegTypeLib, const CLSID *clsid)
 690 {
 691     const struct _ATL_CATMAP_ENTRY *catmap;
 692     _ATL_OBJMAP_ENTRY_EX **iter;
 693     HRESULT hres;
 694
 695     TRACE("(%p %x %s)\n", mod, bRegTypeLib, debugstr_guid(clsid));
 696
 697     for(iter = mod->m_ppAutoObjMapFirst; iter < mod->m_ppAutoObjMapLast; iter++) {
 698         if(!*iter || (clsid && !IsEqualCLSID((*iter)->pclsid, clsid)))
 699             continue;
 700
 701         TRACE("Unregistering clsid %s\n", debugstr_guid((*iter)->pclsid));
 702
 703         catmap = (*iter)->pfnGetCategoryMap();
 704         if(catmap) {
 705             hres = AtlRegisterClassCategoriesHelper((*iter)->pclsid, catmap, FALSE);
 706             if(FAILED(hres))
 707                 return hres;
 708         }
 709
 710         hres = (*iter)->pfnUpdateRegistry(FALSE);
 711         if(FAILED(hres))
 712             return hres;
 713     }
 714
 715     if(bRegTypeLib) {
 716         ITypeLib *typelib;
 717         TLIBATTR *attr;
 718         BSTR path;
 719
 720         hres = AtlLoadTypeLib(mod->m_hInstTypeLib, NULL, &path, &typelib);
 721         if(FAILED(hres))
 722             return hres;
 723
 724         SysFreeString(path);
 725         hres = ITypeLib_GetLibAttr(typelib, &attr);
 726         if(SUCCEEDED(hres)) {
 727             hres = UnRegisterTypeLib(&attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, attr->lcid, attr->syskind);
 728             ITypeLib_ReleaseTLibAttr(typelib, attr);
 729         }
 730         ITypeLib_Release(typelib);
 731         if(FAILED(hres))
 732             return hres;
 733     }
 734
 735     return S_OK;
 736 }
 737 #endif
 738
 739 #endif
 740
 741 /***********************************************************************
 742  *           AtlRegisterClassCategoriesHelper          [atl100.49]
 743  */
 744 HRESULT WINAPI AtlRegisterClassCategoriesHelper(REFCLSID clsid, const struct _ATL_CATMAP_ENTRY *catmap, BOOL reg)
 745 {
 746     const struct _ATL_CATMAP_ENTRY *iter;
 747     HRESULT hres;
 748
 749     TRACE("(%s %p %x)\n", debugstr_guid(clsid), catmap, reg);
 750
 751     if(!catmap)
 752         return S_OK;
 753
 754     if(!catreg) {
 755         ICatRegister *new_catreg;
 756
 757         hres = CoCreateInstance(&CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER,
 758                 &IID_ICatRegister, (void**)&new_catreg);
 759         if(FAILED(hres))
 760             return hres;
 761
 762         if(InterlockedCompareExchangePointer((void**)&catreg, new_catreg, NULL))
 763             ICatRegister_Release(new_catreg);
 764     }
 765
 766     for(iter = catmap; iter->iType != _ATL_CATMAP_ENTRY_END; iter++) {
 767         CATID catid = *iter->pcatid; /* For stupid lack of const in ICatRegister declaration. */
 768
 769         if(iter->iType == _ATL_CATMAP_ENTRY_IMPLEMENTED) {
 770             if(reg)
 771                 hres = ICatRegister_RegisterClassImplCategories(catreg, clsid, 1, &catid);
 772             else
 773                 hres = ICatRegister_UnRegisterClassImplCategories(catreg, clsid, 1, &catid);
 774         }else {
 775             if(reg)
 776                 hres = ICatRegister_RegisterClassReqCategories(catreg, clsid, 1, &catid);
 777             else
 778                 hres = ICatRegister_UnRegisterClassReqCategories(catreg, clsid, 1, &catid);
 779         }
 780         if(FAILED(hres))
 781             return hres;
 782     }
 783
 784     if(!reg) {
 785         WCHAR reg_path[256] = {'C','L','S','I','D','\\'}, *ptr = reg_path+6;
 786
 787         static const WCHAR implemented_catW[] =
 788             {'I','m','p','l','e','m','e','n','t','e','d',' ','C','a','t','e','g','o','r','i','e','s',0};
 789         static const WCHAR required_catW[] =
 790             {'R','e','q','u','i','r','e','d',' ','C','a','t','e','g','o','r','i','e','s',0};
 791
 792         ptr += StringFromGUID2(clsid, ptr, 64)-1;
 793         *ptr++ = '\\';
 794
 795         memcpy(ptr, implemented_catW, sizeof(implemented_catW));
 796         RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
 797
 798         memcpy(ptr, required_catW, sizeof(required_catW));
 799         RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
 800     }
 801
 802     return S_OK;
 803 }
 804
 805 /***********************************************************************
 806  *           AtlWaitWithMessageLoop     [atl100.24]
 807  */
 808 BOOL WINAPI AtlWaitWithMessageLoop(HANDLE handle)
 809 {
 810     MSG msg;
 811     DWORD res;
 812
 813     TRACE("(%p)\n", handle);
 814
 815     while(1) {
 816         res = MsgWaitForMultipleObjects(1, &handle, FALSE, INFINITE, QS_ALLINPUT);
 817         switch(res) {
 818         case WAIT_OBJECT_0:
 819             return TRUE;
 820         case WAIT_OBJECT_0+1:
 821             if(GetMessageW(&msg, NULL, 0, 0) < 0)
 822                 return FALSE;
 823
 824             TranslateMessage(&msg);
 825             DispatchMessageW(&msg);
 826             break;
 827         default:
 828             return FALSE;
 829         }
 830     }
 831 }
 832
 833 static HRESULT get_default_source(ITypeLib *typelib, const CLSID *clsid, IID *iid)
 834 {
 835     ITypeInfo *typeinfo, *src_typeinfo = NULL;
 836     TYPEATTR *attr;
 837     int type_flags;
 838     unsigned i;
 839     HRESULT hres;
 840
 841     hres = ITypeLib_GetTypeInfoOfGuid(typelib, clsid, &typeinfo);
 842     if(FAILED(hres))
 843         return hres;
 844
 845     hres = ITypeInfo_GetTypeAttr(typeinfo, &attr);
 846     if(FAILED(hres)) {
 847         ITypeInfo_Release(typeinfo);
 848         return hres;
 849     }
 850
 851     for(i=0; i < attr->cImplTypes; i++) {
 852         hres = ITypeInfo_GetImplTypeFlags(typeinfo, i, &type_flags);
 853         if(SUCCEEDED(hres) && type_flags == (IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT)) {
 854             HREFTYPE ref;
 855
 856             hres = ITypeInfo_GetRefTypeOfImplType(typeinfo, i, &ref);
 857             if(SUCCEEDED(hres))
 858                 hres = ITypeInfo_GetRefTypeInfo(typeinfo, ref, &src_typeinfo);
 859             break;
 860         }
 861     }
 862
 863     ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
 864     ITypeInfo_Release(typeinfo);
 865     if(FAILED(hres))
 866         return hres;
 867
 868     if(!src_typeinfo) {
 869         *iid = IID_NULL;
 870         return S_OK;
 871     }
 872
 873     hres = ITypeInfo_GetTypeAttr(src_typeinfo, &attr);
 874     if(SUCCEEDED(hres)) {
 875         *iid = attr->guid;
 876         ITypeInfo_ReleaseTypeAttr(src_typeinfo, attr);
 877     }
 878     ITypeInfo_Release(src_typeinfo);
 879     return hres;
 880 }
 881
 882 /***********************************************************************
 883  *           AtlGetObjectSourceInterface    [atl100.54]
 884  */
 885 HRESULT WINAPI AtlGetObjectSourceInterface(IUnknown *unk, GUID *libid, IID *iid, unsigned short *major, unsigned short *minor)
 886 {
 887     IProvideClassInfo2 *classinfo;
 888     ITypeInfo *typeinfo;
 889     ITypeLib *typelib;
 890     IPersist *persist;
 891     IDispatch *disp;
 892     HRESULT hres;
 893
 894     TRACE("(%p %p %p %p %p)\n", unk, libid, iid, major, minor);
 895
 896     hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
 897     if(FAILED(hres))
 898         return hres;
 899
 900     hres = IDispatch_GetTypeInfo(disp, 0, 0, &typeinfo);
 901     IDispatch_Release(disp);
 902     if(FAILED(hres))
 903         return hres;
 904
 905     hres = ITypeInfo_GetContainingTypeLib(typeinfo, &typelib, 0);
 906     ITypeInfo_Release(typeinfo);
 907     if(SUCCEEDED(hres)) {
 908         TLIBATTR *attr;
 909
 910         hres = ITypeLib_GetLibAttr(typelib, &attr);
 911         if(SUCCEEDED(hres)) {
 912             *libid = attr->guid;
 913             *major = attr->wMajorVerNum;
 914             *minor = attr->wMinorVerNum;
 915             ITypeLib_ReleaseTLibAttr(typelib, attr);
 916         }else {
 917             ITypeLib_Release(typelib);
 918         }
 919     }
 920     if(FAILED(hres))
 921         return hres;
 922
 923     hres = IUnknown_QueryInterface(unk, &IID_IProvideClassInfo2, (void**)&classinfo);
 924     if(SUCCEEDED(hres)) {
 925         hres = IProvideClassInfo2_GetGUID(classinfo, GUIDKIND_DEFAULT_SOURCE_DISP_IID, iid);
 926         IProvideClassInfo2_Release(classinfo);
 927         ITypeLib_Release(typelib);
 928         return hres;
 929     }
 930
 931     hres = IUnknown_QueryInterface(unk, &IID_IPersist, (void**)&persist);
 932     if(SUCCEEDED(hres)) {
 933         CLSID clsid;
 934
 935         hres = IPersist_GetClassID(persist, &clsid);
 936         if(SUCCEEDED(hres))
 937             hres = get_default_source(typelib, &clsid, iid);
 938         IPersist_Release(persist);
 939     }
 940
 941     return hres;
 942 }
 943
 944 #if _ATL_VER >= _ATL_VER90
 945
 946 /***********************************************************************
 947  *           AtlSetPerUserRegistration [atl100.67]
 948  */
 949 HRESULT WINAPI AtlSetPerUserRegistration(cpp_bool bEnable)
 950 {
 951     FIXME("stub: bEnable: %d\n", bEnable);
 952     return E_NOTIMPL;
 953 }
 954
 955 /***********************************************************************
 956  *           AtlGetPerUserRegistration  [atl100.68]
 957  */
 958 HRESULT WINAPI AtlGetPerUserRegistration(cpp_bool *pbEnabled)
 959 {
 960     FIXME("stub: returning false\n");
 961     *pbEnabled = 0;
 962     return S_OK;
 963 }
 964
 965 #endif
 966
 967 /***********************************************************************
 968  *           AtlGetVersion              [atl100.@]
 969  */
 970 DWORD WINAPI AtlGetVersion(void *pReserved)
 971 {
 972     TRACE("version %04x (%p)\n", _ATL_VER, pReserved);
 973     return _ATL_VER;
 974 }
 975
 976 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 977 {
 978     TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
 979
 980     switch(fdwReason) {
 981     case DLL_PROCESS_ATTACH:
 982         atl_instance = hinstDLL;
 983         DisableThreadLibraryCalls(hinstDLL);
 984         break;
 985     case DLL_PROCESS_DETACH:
 986         if (lpvReserved) break;
 987         if(catreg)
 988             ICatRegister_Release(catreg);
 989     }
 990
 991     return TRUE;
 992 }