atl.c File Reference

#include "wine/atlbase.h"
#include "wine/atlcom.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/unicode.h"

Include dependency graph for atl.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	ATLVer1Size   FIELD_OFFSET(_ATL_MODULEW, dwAtlBuildVer)

Typedefs
typedef unsigned char	cpp_bool

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (atl)
HRESULT WINAPI	AtlAdvise (IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, DWORD *pdw)
HRESULT WINAPI	AtlUnadvise (IUnknown *pUnkCP, const IID *iid, DWORD dw)
HRESULT WINAPI	AtlFreeMarshalStream (IStream *stm)
HRESULT WINAPI	AtlMarshalPtrInProc (IUnknown *pUnk, const IID *iid, IStream **pstm)
HRESULT WINAPI	AtlUnmarshalPtr (IStream *stm, const IID *iid, IUnknown **ppUnk)
HDC WINAPI	AtlCreateTargetDC (HDC hdc, DVTARGETDEVICE *dv)
void WINAPI	AtlHiMetricToPixel (const SIZEL *lpHiMetric, SIZEL *lpPix)
void WINAPI	AtlPixelToHiMetric (const SIZEL *lpPix, SIZEL *lpHiMetric)
IUnknown *WINAPI	AtlComPtrAssign (IUnknown **pp, IUnknown *p)
IUnknown *WINAPI	AtlComQIPtrAssign (IUnknown **pp, IUnknown *p, REFIID riid)
HRESULT WINAPI	AtlInternalQueryInterface (void *this, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
HRESULT WINAPI	AtlIPersistStreamInit_Load (LPSTREAM pStm, ATL_PROPMAP_ENTRY *pMap, void *pThis, IUnknown *pUnk)
HRESULT WINAPI	AtlIPersistStreamInit_Save (LPSTREAM pStm, BOOL fClearDirty, ATL_PROPMAP_ENTRY *pMap, void *pThis, IUnknown *pUnk)
HRESULT WINAPI	AtlIPersistPropertyBag_Load (LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog, ATL_PROPMAP_ENTRY *pMap, void *pThis, IUnknown *pUnk)
HRESULT WINAPI	AtlIPersistPropertyBag_Save (LPPROPERTYBAG pPropBag, BOOL fClearDirty, BOOL fSaveAll, ATL_PROPMAP_ENTRY *pMap, void *pThis, IUnknown *pUnk)
HRESULT WINAPI	AtlModuleAddTermFunc (_ATL_MODULE *pM, _ATL_TERMFUNC *pFunc, DWORD_PTR dw)
HRESULT WINAPI	AtlLoadTypeLib (HINSTANCE inst, LPCOLESTR lpszIndex, BSTR *pbstrPath, ITypeLib **ppTypeLib)
HRESULT WINAPI	AtlRegisterTypeLib (HINSTANCE inst, const WCHAR *index)
HRESULT WINAPI	AtlRegisterClassCategoriesHelper (REFCLSID clsid, const struct _ATL_CATMAP_ENTRY *catmap, BOOL reg)
BOOL WINAPI	AtlWaitWithMessageLoop (HANDLE handle)
static HRESULT	get_default_source (ITypeLib *typelib, const CLSID *clsid, IID *iid)
HRESULT WINAPI	AtlGetObjectSourceInterface (IUnknown *unk, GUID *libid, IID *iid, unsigned short *major, unsigned short *minor)
HRESULT WINAPI	AtlSetPerUserRegistration (cpp_bool bEnable)
HRESULT WINAPI	AtlGetPerUserRegistration (cpp_bool *pbEnabled)
DWORD WINAPI	AtlGetVersion (void *pReserved)
BOOL WINAPI	DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)

Variables
HINSTANCE	atl_instance
static ICatRegister *	catreg

Macro Definition Documentation

ATLVer1Size

#define ATLVer1Size   FIELD_OFFSET(_ATL_MODULEW, dwAtlBuildVer)

Definition at line 35 of file atl.c.

COBJMACROS

#define COBJMACROS

Definition at line 20 of file atl.c.

Typedef Documentation

cpp_bool

typedef unsigned char cpp_bool

Definition at line 39 of file atl.c.

Function Documentation

AtlAdvise()

HRESULT WINAPI AtlAdvise	(	IUnknown *	pUnkCP,
		IUnknown *	pUnk,
		const IID *	iid,
		DWORD *	pdw
	)

Definition at line 46 of file atl.c.

{
    IConnectionPointContainer *container;
    IConnectionPoint *cp;
    HRESULT hres;

    TRACE("%p %p %p %p\n", pUnkCP, pUnk, iid, pdw);

    if(!pUnkCP)
        return E_INVALIDARG;

    hres = IUnknown_QueryInterface(pUnkCP, &IID_IConnectionPointContainer, (void**)&container);
    if(FAILED(hres))
        return hres;

    hres = IConnectionPointContainer_FindConnectionPoint(container, iid, &cp);
    IConnectionPointContainer_Release(container);
    if(FAILED(hres))
        return hres;

    hres = IConnectionPoint_Advise(cp, pUnk, pdw);
    IConnectionPoint_Release(cp);
    return hres;
}

Referenced by CAddressEditBox::Init(), CExplorerBand::InitializeExplorerBand(), CBrandBand::SetSite(), CInternetToolbar::SetSite(), and test_cp().

AtlComPtrAssign()

IUnknown* WINAPI AtlComPtrAssign	(	IUnknown **	pp,
		IUnknown *	p
	)

Definition at line 177 of file atl.c.

{
    TRACE("(%p %p)\n", pp, p);

    if (p) IUnknown_AddRef(p);
    if (*pp) IUnknown_Release(*pp);
    *pp = p;
    return p;
}

AtlComQIPtrAssign()

IUnknown* WINAPI AtlComQIPtrAssign	(	IUnknown **	pp,
		IUnknown *	p,
		REFIID	riid
	)

Definition at line 190 of file atl.c.

{
    IUnknown *new_p = NULL;

    TRACE("(%p %p %s)\n", pp, p, debugstr_guid(riid));

    if (p) IUnknown_QueryInterface(p, riid, (void **)&new_p);
    if (*pp) IUnknown_Release(*pp);
    *pp = new_p;
    return new_p;
}

AtlCreateTargetDC()

HDC WINAPI AtlCreateTargetDC	(	HDC	hdc,
		DVTARGETDEVICE *	dv
	)

Definition at line 129 of file atl.c.

{
    static const WCHAR displayW[] = {'d','i','s','p','l','a','y',0};
    const WCHAR *driver = NULL, *device = NULL, *port = NULL;
    DEVMODEW *devmode = NULL;

    TRACE( "(%p, %p)\n", hdc, dv );

    if (dv)
    {
        if (dv->tdDriverNameOffset) driver  = (WCHAR *)((char *)dv + dv->tdDriverNameOffset);
        if (dv->tdDeviceNameOffset) device  = (WCHAR *)((char *)dv + dv->tdDeviceNameOffset);
        if (dv->tdPortNameOffset)   port    = (WCHAR *)((char *)dv + dv->tdPortNameOffset);
        if (dv->tdExtDevmodeOffset) devmode = (DEVMODEW *)((char *)dv + dv->tdExtDevmodeOffset);
    }
    else
    {
        if (hdc) return hdc;
        driver = displayW;
    }
    return CreateDCW( driver, device, port, devmode );
}

AtlFreeMarshalStream()

HRESULT WINAPI AtlFreeMarshalStream

(

IStream *

stm

)

Definition at line 102 of file atl.c.

{
    FIXME("%p\n", stm);
    return S_OK;
}

AtlGetObjectSourceInterface()

HRESULT WINAPI AtlGetObjectSourceInterface	(	IUnknown *	unk,
		GUID *	libid,
		IID *	iid,
		unsigned short *	major,
		unsigned short *	minor
	)

Definition at line 889 of file atl.c.

{
    IProvideClassInfo2 *classinfo;
    ITypeInfo *typeinfo;
    ITypeLib *typelib;
    IPersist *persist;
    IDispatch *disp;
    HRESULT hres;

    TRACE("(%p %p %p %p %p)\n", unk, libid, iid, major, minor);

    hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
    if(FAILED(hres))
        return hres;

    hres = IDispatch_GetTypeInfo(disp, 0, 0, &typeinfo);
    IDispatch_Release(disp);
    if(FAILED(hres))
        return hres;

    hres = ITypeInfo_GetContainingTypeLib(typeinfo, &typelib, 0);
    ITypeInfo_Release(typeinfo);
    if(SUCCEEDED(hres)) {
        TLIBATTR *attr;

        hres = ITypeLib_GetLibAttr(typelib, &attr);
        if(SUCCEEDED(hres)) {
            *libid = attr->guid;
            *major = attr->wMajorVerNum;
            *minor = attr->wMinorVerNum;
            ITypeLib_ReleaseTLibAttr(typelib, attr);
        }else {
            ITypeLib_Release(typelib);
        }
    }
    if(FAILED(hres))
        return hres;

    hres = IUnknown_QueryInterface(unk, &IID_IProvideClassInfo2, (void**)&classinfo);
    if(SUCCEEDED(hres)) {
        hres = IProvideClassInfo2_GetGUID(classinfo, GUIDKIND_DEFAULT_SOURCE_DISP_IID, iid);
        IProvideClassInfo2_Release(classinfo);
        ITypeLib_Release(typelib);
        return hres;
    }

    hres = IUnknown_QueryInterface(unk, &IID_IPersist, (void**)&persist);
    if(SUCCEEDED(hres)) {
        CLSID clsid;

        hres = IPersist_GetClassID(persist, &clsid);
        if(SUCCEEDED(hres))
            hres = get_default_source(typelib, &clsid, iid);
        IPersist_Release(persist);
    }

    return hres;
}

Referenced by test_source_iface().

AtlGetPerUserRegistration()

HRESULT WINAPI AtlGetPerUserRegistration

(

cpp_bool *

pbEnabled

)

Definition at line 962 of file atl.c.

{
    FIXME("stub: returning false\n");
    *pbEnabled = 0;
    return S_OK;
}

Referenced by test_regcat().

AtlGetVersion()

DWORD WINAPI AtlGetVersion

(

void *

pReserved

)

Definition at line 974 of file atl.c.

{
    TRACE("version %04x (%p)\n", _ATL_VER, pReserved);
    return _ATL_VER;
}

AtlHiMetricToPixel()

void WINAPI AtlHiMetricToPixel	(	const SIZEL *	lpHiMetric,
		SIZEL *	lpPix
	)

Definition at line 155 of file atl.c.

{
    HDC dc = GetDC(NULL);
    lpPix->cx = lpHiMetric->cx * GetDeviceCaps( dc, LOGPIXELSX ) / 100;
    lpPix->cy = lpHiMetric->cy * GetDeviceCaps( dc, LOGPIXELSY ) / 100;
    ReleaseDC( NULL, dc );
}

AtlInternalQueryInterface()

HRESULT WINAPI AtlInternalQueryInterface	(	void *	this,
		const _ATL_INTMAP_ENTRY *	pEntries,
		REFIID	iid,
		void **	ppvObject
	)

Definition at line 205 of file atl.c.

{
    int i = 0;
    HRESULT rc = E_NOINTERFACE;
    TRACE("(%p, %p, %s, %p)\n",this, pEntries, debugstr_guid(iid), ppvObject);

    if (IsEqualGUID(iid,&IID_IUnknown))
    {
        TRACE("Returning IUnknown\n");
        *ppvObject = ((LPSTR)this+pEntries[0].dw);
        IUnknown_AddRef((IUnknown*)*ppvObject);
        return S_OK;
    }

    while (pEntries[i].pFunc != 0)
    {
        TRACE("Trying entry %i (%s %i %p)\n",i,debugstr_guid(pEntries[i].piid),
              pEntries[i].dw, pEntries[i].pFunc);

        if (!pEntries[i].piid || IsEqualGUID(iid,pEntries[i].piid))
        {
            TRACE("MATCH\n");
            if (pEntries[i].pFunc == (_ATL_CREATORARGFUNC*)1)
            {
                TRACE("Offset\n");
                *ppvObject = ((LPSTR)this+pEntries[i].dw);
                IUnknown_AddRef((IUnknown*)*ppvObject);
                return S_OK;
            }
            else
            {
                TRACE("Function\n");
                rc = pEntries[i].pFunc(this, iid, ppvObject, pEntries[i].dw);
                if(rc==S_OK || pEntries[i].piid)
                    return rc;
            }
        }
        i++;
    }
    TRACE("Done returning (0x%x)\n",rc);
    return rc;
}

AtlIPersistPropertyBag_Load()

HRESULT WINAPI AtlIPersistPropertyBag_Load	(	LPPROPERTYBAG	pPropBag,
		LPERRORLOG	pErrorLog,
		ATL_PROPMAP_ENTRY *	pMap,
		void *	pThis,
		IUnknown *	pUnk
	)

Definition at line 274 of file atl.c.

{
    FIXME("(%p, %p, %p, %p, %p)\n", pPropBag, pErrorLog, pMap, pThis, pUnk);

    return S_OK;
}

AtlIPersistPropertyBag_Save()

HRESULT WINAPI AtlIPersistPropertyBag_Save	(	LPPROPERTYBAG	pPropBag,
		BOOL	fClearDirty,
		BOOL	fSaveAll,
		ATL_PROPMAP_ENTRY *	pMap,
		void *	pThis,
		IUnknown *	pUnk
	)

Definition at line 286 of file atl.c.

{
    FIXME("(%p, %d, %d, %p, %p, %p)\n", pPropBag, fClearDirty, fSaveAll, pMap, pThis, pUnk);

    return S_OK;
}

AtlIPersistStreamInit_Load()

HRESULT WINAPI AtlIPersistStreamInit_Load	(	LPSTREAM	pStm,
		ATL_PROPMAP_ENTRY *	pMap,
		void *	pThis,
		IUnknown *	pUnk
	)

Definition at line 251 of file atl.c.

{
    FIXME("(%p, %p, %p, %p)\n", pStm, pMap, pThis, pUnk);

    return S_OK;
}

AtlIPersistStreamInit_Save()

HRESULT WINAPI AtlIPersistStreamInit_Save	(	LPSTREAM	pStm,
		BOOL	fClearDirty,
		ATL_PROPMAP_ENTRY *	pMap,
		void *	pThis,
		IUnknown *	pUnk
	)

Definition at line 262 of file atl.c.

{
    FIXME("(%p, %d, %p, %p, %p)\n", pStm, fClearDirty, pMap, pThis, pUnk);

    return S_OK;
}

AtlLoadTypeLib()

HRESULT WINAPI AtlLoadTypeLib	(	HINSTANCE	inst,
		LPCOLESTR	lpszIndex,
		BSTR *	pbstrPath,
		ITypeLib **	ppTypeLib
	)

Definition at line 342 of file atl.c.

{
    size_t path_len, index_len;
    ITypeLib *typelib = NULL;
    WCHAR *path;
    HRESULT hres;

    static const WCHAR tlb_extW[] = {'.','t','l','b',0};

    TRACE("(%p %s %p %p)\n", inst, debugstr_w(lpszIndex), pbstrPath, ppTypeLib);

    index_len = lpszIndex ? strlenW(lpszIndex) : 0;
    path = heap_alloc((MAX_PATH+index_len)*sizeof(WCHAR) + sizeof(tlb_extW));
    if(!path)
        return E_OUTOFMEMORY;

    path_len = GetModuleFileNameW(inst, path, MAX_PATH);
    if(!path_len) {
        heap_free(path);
        return HRESULT_FROM_WIN32(GetLastError());
    }

    if(index_len)
        memcpy(path+path_len, lpszIndex, (index_len+1)*sizeof(WCHAR));

    hres = LoadTypeLib(path, &typelib);
    if(FAILED(hres)) {
        WCHAR *ptr;

        for(ptr = path+path_len-1; ptr > path && *ptr != '\\' && *ptr != '.'; ptr--);
        if(*ptr != '.')
            ptr = path+path_len;
        memcpy(ptr, tlb_extW, sizeof(tlb_extW));
        hres = LoadTypeLib(path, &typelib);
    }

    if(SUCCEEDED(hres)) {
        *pbstrPath = SysAllocString(path);
        if(!*pbstrPath) {
            ITypeLib_Release(typelib);
            hres = E_OUTOFMEMORY;
        }
    }

    heap_free(path);
    if(FAILED(hres))
        return hres;

    *ppTypeLib = typelib;
    return S_OK;
}

Referenced by AtlModuleLoadTypeLib(), AtlRegisterTypeLib(), and test_typelib().

AtlMarshalPtrInProc()

HRESULT WINAPI AtlMarshalPtrInProc	(	IUnknown *	pUnk,
		const IID *	iid,
		IStream **	pstm
	)

Definition at line 111 of file atl.c.

{
    FIXME("%p %p %p\n", pUnk, iid, pstm);
    return E_FAIL;
}

AtlModuleAddTermFunc()

HRESULT WINAPI AtlModuleAddTermFunc	(	_ATL_MODULE *	pM,
		_ATL_TERMFUNC *	pFunc,
		DWORD_PTR	dw
	)

Definition at line 298 of file atl.c.

{
    _ATL_TERMFUNC_ELEM *termfunc_elem;

    TRACE("version %04x (%p %p %ld)\n", _ATL_VER, pM, pFunc, dw);

    if (_ATL_VER > _ATL_VER_30 || pM->cbSize > ATLVer1Size) {
        termfunc_elem = HeapAlloc(GetProcessHeap(), 0, sizeof(_ATL_TERMFUNC_ELEM));
        termfunc_elem->pFunc = pFunc;
        termfunc_elem->dw = dw;
        termfunc_elem->pNext = pM->m_pTermFuncs;

        pM->m_pTermFuncs = termfunc_elem;
    }

    return S_OK;
}

Referenced by test_term().

AtlPixelToHiMetric()

void WINAPI AtlPixelToHiMetric	(	const SIZEL *	lpPix,
		SIZEL *	lpHiMetric
	)

Definition at line 166 of file atl.c.

{
    HDC dc = GetDC(NULL);
    lpHiMetric->cx = 100 * lpPix->cx / GetDeviceCaps( dc, LOGPIXELSX );
    lpHiMetric->cy = 100 * lpPix->cy / GetDeviceCaps( dc, LOGPIXELSY );
    ReleaseDC( NULL, dc );
}

Referenced by IOCS_OnSize().

AtlRegisterClassCategoriesHelper()

HRESULT WINAPI AtlRegisterClassCategoriesHelper	(	REFCLSID	clsid,
		const struct _ATL_CATMAP_ENTRY *	catmap,
		BOOL	reg
	)

Definition at line 748 of file atl.c.

{
    const struct _ATL_CATMAP_ENTRY *iter;
    HRESULT hres;

    TRACE("(%s %p %x)\n", debugstr_guid(clsid), catmap, reg);

    if(!catmap)
        return S_OK;

    if(!catreg) {
        ICatRegister *new_catreg;

        hres = CoCreateInstance(&CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER,
                &IID_ICatRegister, (void**)&new_catreg);
        if(FAILED(hres))
            return hres;

        if(InterlockedCompareExchangePointer((void**)&catreg, new_catreg, NULL))
            ICatRegister_Release(new_catreg);
    }

    for(iter = catmap; iter->iType != _ATL_CATMAP_ENTRY_END; iter++) {
        CATID catid = *iter->pcatid; /* For stupid lack of const in ICatRegister declaration. */

        if(iter->iType == _ATL_CATMAP_ENTRY_IMPLEMENTED) {
            if(reg)
                hres = ICatRegister_RegisterClassImplCategories(catreg, clsid, 1, &catid);
            else
                hres = ICatRegister_UnRegisterClassImplCategories(catreg, clsid, 1, &catid);
        }else {
            if(reg)
                hres = ICatRegister_RegisterClassReqCategories(catreg, clsid, 1, &catid);
            else
                hres = ICatRegister_UnRegisterClassReqCategories(catreg, clsid, 1, &catid);
        }
        if(FAILED(hres))
            return hres;
    }

    if(!reg) {
        WCHAR reg_path[256] = {'C','L','S','I','D','\\'}, *ptr = reg_path+6;

        static const WCHAR implemented_catW[] =
            {'I','m','p','l','e','m','e','n','t','e','d',' ','C','a','t','e','g','o','r','i','e','s',0};
        static const WCHAR required_catW[] =
            {'R','e','q','u','i','r','e','d',' ','C','a','t','e','g','o','r','i','e','s',0};

        ptr += StringFromGUID2(clsid, ptr, 64)-1;
        *ptr++ = '\\';

        memcpy(ptr, implemented_catW, sizeof(implemented_catW));
        RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);

        memcpy(ptr, required_catW, sizeof(required_catW));
        RegDeleteKeyW(HKEY_CLASSES_ROOT, reg_path);
    }

    return S_OK;
}

Referenced by AtlComModuleRegisterServer(), AtlModuleRegisterServer(), and test_regcat().

AtlRegisterTypeLib()

HRESULT WINAPI AtlRegisterTypeLib	(	HINSTANCE	inst,
		const WCHAR *	index
	)

Definition at line 400 of file atl.c.

{
    ITypeLib *typelib;
    BSTR path;
    HRESULT hres;

    TRACE("(%p %s)\n", inst, debugstr_w(index));

    hres = AtlLoadTypeLib(inst, index, &path, &typelib);
    if(FAILED(hres))
        return hres;

    hres = RegisterTypeLib(typelib, path, NULL); /* FIXME: pass help directory */
    ITypeLib_Release(typelib);
    SysFreeString(path);
    return hres;
}

Referenced by AtlComModuleRegisterServer(), AtlModuleRegisterServer(), and AtlModuleRegisterTypeLib().

AtlSetPerUserRegistration()

HRESULT WINAPI AtlSetPerUserRegistration

(

cpp_bool

bEnable

)

Definition at line 953 of file atl.c.

{
    FIXME("stub: bEnable: %d\n", bEnable);
    return E_NOTIMPL;
}

AtlUnadvise()

HRESULT WINAPI AtlUnadvise	(	IUnknown *	pUnkCP,
		const IID *	iid,
		DWORD	dw
	)

Definition at line 74 of file atl.c.

{
    IConnectionPointContainer *container;
    IConnectionPoint *cp;
    HRESULT hres;

    TRACE("%p %p %d\n", pUnkCP, iid, dw);

    if(!pUnkCP)
        return E_INVALIDARG;

    hres = IUnknown_QueryInterface(pUnkCP, &IID_IConnectionPointContainer, (void**)&container);
    if(FAILED(hres))
        return hres;

    hres = IConnectionPointContainer_FindConnectionPoint(container, iid, &cp);
    IConnectionPointContainer_Release(container);
    if(FAILED(hres))
        return hres;

    hres = IConnectionPoint_Unadvise(cp, dw);
    IConnectionPoint_Release(cp);
    return hres;
}

Referenced by CExplorerBand::DestroyExplorerBand(), CAddressEditBox::SetOwner(), CBrandBand::SetSite(), CInternetToolbar::SetSite(), and test_cp().

AtlUnmarshalPtr()

HRESULT WINAPI AtlUnmarshalPtr	(	IStream *	stm,
		const IID *	iid,
		IUnknown **	ppUnk
	)

Definition at line 120 of file atl.c.

{
    FIXME("%p %p %p\n", stm, iid, ppUnk);
    return E_FAIL;
}

AtlWaitWithMessageLoop()

BOOL WINAPI AtlWaitWithMessageLoop

(

HANDLE

handle

)

Definition at line 812 of file atl.c.

{
    MSG msg;
    DWORD res;

    TRACE("(%p)\n", handle);

    while(1) {
        res = MsgWaitForMultipleObjects(1, &handle, FALSE, INFINITE, QS_ALLINPUT);
        switch(res) {
        case WAIT_OBJECT_0:
            return TRUE;
        case WAIT_OBJECT_0+1:
            if(GetMessageW(&msg, NULL, 0, 0) < 0)
                return FALSE;

            TranslateMessage(&msg);
            DispatchMessageW(&msg);
            break;
        default:
            return FALSE;
        }
    }
}

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	lpvReserved
	)

Definition at line 980 of file atl.c.

{
    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);

    switch(fdwReason) {
    case DLL_PROCESS_ATTACH:
        atl_instance = hinstDLL;
        DisableThreadLibraryCalls(hinstDLL);
        break;
    case DLL_PROCESS_DETACH:
        if (lpvReserved) break;
        if(catreg)
            ICatRegister_Release(catreg);
    }

    return TRUE;
}

get_default_source()

static HRESULT get_default_source ( ITypeLib *  typelib, const CLSID *  clsid, IID *  iid  )

static

Definition at line 837 of file atl.c.

{
    ITypeInfo *typeinfo, *src_typeinfo = NULL;
    TYPEATTR *attr;
    int type_flags;
    unsigned i;
    HRESULT hres;

    hres = ITypeLib_GetTypeInfoOfGuid(typelib, clsid, &typeinfo);
    if(FAILED(hres))
        return hres;

    hres = ITypeInfo_GetTypeAttr(typeinfo, &attr);
    if(FAILED(hres)) {
        ITypeInfo_Release(typeinfo);
        return hres;
    }

    for(i=0; i < attr->cImplTypes; i++) {
        hres = ITypeInfo_GetImplTypeFlags(typeinfo, i, &type_flags);
        if(SUCCEEDED(hres) && type_flags == (IMPLTYPEFLAG_FSOURCE|IMPLTYPEFLAG_FDEFAULT)) {
            HREFTYPE ref;

            hres = ITypeInfo_GetRefTypeOfImplType(typeinfo, i, &ref);
            if(SUCCEEDED(hres))
                hres = ITypeInfo_GetRefTypeInfo(typeinfo, ref, &src_typeinfo);
            break;
        }
    }

    ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
    ITypeInfo_Release(typeinfo);
    if(FAILED(hres))
        return hres;

    if(!src_typeinfo) {
        *iid = IID_NULL;
        return S_OK;
    }

    hres = ITypeInfo_GetTypeAttr(src_typeinfo, &attr);
    if(SUCCEEDED(hres)) {
        *iid = attr->guid;
        ITypeInfo_ReleaseTypeAttr(src_typeinfo, attr);
    }
    ITypeInfo_Release(src_typeinfo);
    return hres;
}

Referenced by AtlGetObjectSourceInterface().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

atl

)

Variable Documentation

atl_instance

HINSTANCE atl_instance

Definition at line 37 of file atl.c.

Referenced by DllMain(), DllRegisterServer(), and DllUnregisterServer().

catreg

ICatRegister* catreg

static

Definition at line 41 of file atl.c.

Referenced by AtlRegisterClassCategoriesHelper(), ATL::AtlRegisterClassCategoriesHelper(), and DllMain().