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