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