2 * Implementation of Active Template Library (atl.dll)
4 * Copyright 2004 Aric Stewart for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
31 #include "wine/debug.h"
39 #include "wine/unicode.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(atl
);
43 DECLSPEC_HIDDEN HINSTANCE hInst
;
45 BOOL WINAPI
DllMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
47 TRACE("(0x%p, %d, %p)\n",hinstDLL
,fdwReason
,lpvReserved
);
49 if (fdwReason
== DLL_PROCESS_ATTACH
) {
50 DisableThreadLibraryCalls(hinstDLL
);
56 #define ATLVer1Size FIELD_OFFSET(_ATL_MODULEW, dwAtlBuildVer)
58 HRESULT WINAPI
AtlModuleInit(_ATL_MODULEW
* pM
, _ATL_OBJMAP_ENTRYW
* p
, HINSTANCE h
)
63 FIXME("SEMI-STUB (%p %p %p)\n",pM
,p
,h
);
69 case sizeof(_ATL_MODULEW
):
71 case sizeof(_ATL_MODULEW
) + sizeof(void *):
75 WARN("Unknown structure version (size %i)\n",size
);
79 memset(pM
,0,pM
->cbSize
);
82 pM
->m_hInstResource
= h
;
83 pM
->m_hInstTypeLib
= h
;
85 pM
->m_hHeap
= GetProcessHeap();
87 InitializeCriticalSection(&pM
->u
.m_csTypeInfoHolder
);
88 InitializeCriticalSection(&pM
->m_csWindowCreate
);
89 InitializeCriticalSection(&pM
->m_csObjMap
);
93 if (pM
->m_pObjMap
!= NULL
&& size
> ATLVer1Size
)
95 while (pM
->m_pObjMap
[i
].pclsid
!= NULL
)
97 TRACE("Initializing object %i %p\n",i
,p
[i
].pfnObjectMain
);
98 if (p
[i
].pfnObjectMain
)
99 p
[i
].pfnObjectMain(TRUE
);
107 static _ATL_OBJMAP_ENTRYW_V1
*get_objmap_entry( _ATL_MODULEW
*mod
, unsigned int index
)
109 _ATL_OBJMAP_ENTRYW_V1
*ret
;
111 if (mod
->cbSize
== ATLVer1Size
)
112 ret
= (_ATL_OBJMAP_ENTRYW_V1
*)mod
->m_pObjMap
+ index
;
114 ret
= (_ATL_OBJMAP_ENTRYW_V1
*)(mod
->m_pObjMap
+ index
);
116 if (!ret
->pclsid
) ret
= NULL
;
120 HRESULT WINAPI
AtlModuleLoadTypeLib(_ATL_MODULEW
*pM
, LPCOLESTR lpszIndex
,
121 BSTR
*pbstrPath
, ITypeLib
**ppTypeLib
)
124 OLECHAR path
[MAX_PATH
+8]; /* leave some space for index */
126 TRACE("(%p, %s, %p, %p)\n", pM
, debugstr_w(lpszIndex
), pbstrPath
, ppTypeLib
);
131 GetModuleFileNameW(pM
->m_hInstTypeLib
, path
, MAX_PATH
);
133 lstrcatW(path
, lpszIndex
);
135 hRes
= LoadTypeLib(path
, ppTypeLib
);
139 *pbstrPath
= SysAllocString(path
);
144 HRESULT WINAPI
AtlModuleTerm(_ATL_MODULEW
* pM
)
146 _ATL_TERMFUNC_ELEM
*iter
= pM
->m_pTermFuncs
, *tmp
;
151 iter
->pFunc(iter
->dw
);
154 HeapFree(GetProcessHeap(), 0, tmp
);
157 HeapFree(GetProcessHeap(), 0, pM
);
162 HRESULT WINAPI
AtlModuleAddTermFunc(_ATL_MODULEW
*pM
, _ATL_TERMFUNC
*pFunc
, DWORD_PTR dw
)
164 _ATL_TERMFUNC_ELEM
*termfunc_elem
;
166 TRACE("(%p %p %ld)\n", pM
, pFunc
, dw
);
168 termfunc_elem
= HeapAlloc(GetProcessHeap(), 0, sizeof(_ATL_TERMFUNC_ELEM
));
169 termfunc_elem
->pFunc
= pFunc
;
170 termfunc_elem
->dw
= dw
;
171 termfunc_elem
->pNext
= pM
->m_pTermFuncs
;
173 pM
->m_pTermFuncs
= termfunc_elem
;
178 HRESULT WINAPI
AtlModuleRegisterClassObjects(_ATL_MODULEW
*pM
, DWORD dwClsContext
,
181 _ATL_OBJMAP_ENTRYW_V1
*obj
;
184 TRACE("(%p %i %i)\n",pM
, dwClsContext
, dwFlags
);
189 while ((obj
= get_objmap_entry( pM
, i
++ )))
194 TRACE("Registering object %i\n",i
);
195 if (obj
->pfnGetClassObject
)
197 rc
= obj
->pfnGetClassObject(obj
->pfnCreateInstance
, &IID_IUnknown
,
201 rc
= CoRegisterClassObject(obj
->pclsid
, pUnknown
, dwClsContext
,
202 dwFlags
, &obj
->dwRegister
);
205 WARN("Failed to register object %i: 0x%08x\n", i
, rc
);
208 IUnknown_Release(pUnknown
);
216 HRESULT WINAPI
AtlModuleUnregisterServerEx(_ATL_MODULEW
* pM
, BOOL bUnRegTypeLib
, const CLSID
* pCLSID
)
218 FIXME("(%p, %i, %p) stub\n", pM
, bUnRegTypeLib
, pCLSID
);
223 IUnknown
* WINAPI
AtlComPtrAssign(IUnknown
** pp
, IUnknown
*p
)
225 TRACE("(%p %p)\n", pp
, p
);
227 if (p
) IUnknown_AddRef(p
);
228 if (*pp
) IUnknown_Release(*pp
);
233 IUnknown
* WINAPI
AtlComQIPtrAssign(IUnknown
** pp
, IUnknown
*p
, REFIID riid
)
235 IUnknown
*new_p
= NULL
;
237 TRACE("(%p %p %s)\n", pp
, p
, debugstr_guid(riid
));
239 if (p
) IUnknown_QueryInterface(p
, riid
, (void **)&new_p
);
240 if (*pp
) IUnknown_Release(*pp
);
246 HRESULT WINAPI
AtlInternalQueryInterface(void* this, const _ATL_INTMAP_ENTRY
* pEntries
, REFIID iid
, void** ppvObject
)
249 HRESULT rc
= E_NOINTERFACE
;
250 TRACE("(%p, %p, %s, %p)\n",this, pEntries
, debugstr_guid(iid
), ppvObject
);
252 if (IsEqualGUID(iid
,&IID_IUnknown
))
254 TRACE("Returning IUnknown\n");
255 *ppvObject
= ((LPSTR
)this+pEntries
[0].dw
);
256 IUnknown_AddRef((IUnknown
*)*ppvObject
);
260 while (pEntries
[i
].pFunc
!= 0)
262 TRACE("Trying entry %i (%s %i %p)\n",i
,debugstr_guid(pEntries
[i
].piid
),
263 pEntries
[i
].dw
, pEntries
[i
].pFunc
);
265 if (!pEntries
[i
].piid
|| IsEqualGUID(iid
,pEntries
[i
].piid
))
268 if (pEntries
[i
].pFunc
== (_ATL_CREATORARGFUNC
*)1)
271 *ppvObject
= ((LPSTR
)this+pEntries
[i
].dw
);
272 IUnknown_AddRef((IUnknown
*)*ppvObject
);
278 rc
= pEntries
[i
].pFunc(this, iid
, ppvObject
, pEntries
[i
].dw
);
279 if(rc
==S_OK
|| pEntries
[i
].piid
)
285 TRACE("Done returning (0x%x)\n",rc
);
289 /***********************************************************************
290 * AtlModuleRegisterServer [ATL.@]
293 HRESULT WINAPI
AtlModuleRegisterServer(_ATL_MODULEW
* pM
, BOOL bRegTypeLib
, const CLSID
* clsid
)
295 const _ATL_OBJMAP_ENTRYW_V1
*obj
;
299 TRACE("%p %d %s\n", pM
, bRegTypeLib
, debugstr_guid(clsid
));
304 for (i
= 0; (obj
= get_objmap_entry( pM
, i
)) != NULL
; i
++) /* register CLSIDs */
306 if (!clsid
|| IsEqualCLSID(obj
->pclsid
, clsid
))
308 TRACE("Registering clsid %s\n", debugstr_guid(obj
->pclsid
));
309 hRes
= obj
->pfnUpdateRegistry(TRUE
); /* register */
317 hRes
= AtlModuleRegisterTypeLib(pM
, NULL
);
325 /***********************************************************************
328 HRESULT WINAPI
AtlAdvise(IUnknown
*pUnkCP
, IUnknown
*pUnk
, const IID
*iid
, LPDWORD pdw
)
330 FIXME("%p %p %p %p\n", pUnkCP
, pUnk
, iid
, pdw
);
334 /***********************************************************************
335 * AtlUnadvise [ATL.@]
337 HRESULT WINAPI
AtlUnadvise(IUnknown
*pUnkCP
, const IID
*iid
, DWORD dw
)
339 FIXME("%p %p %d\n", pUnkCP
, iid
, dw
);
343 /***********************************************************************
344 * AtlFreeMarshalStream [ATL.@]
346 HRESULT WINAPI
AtlFreeMarshalStream(IStream
*stm
)
352 /***********************************************************************
353 * AtlMarshalPtrInProc [ATL.@]
355 HRESULT WINAPI
AtlMarshalPtrInProc(IUnknown
*pUnk
, const IID
*iid
, IStream
**pstm
)
357 FIXME("%p %p %p\n", pUnk
, iid
, pstm
);
361 /***********************************************************************
362 * AtlUnmarshalPtr [ATL.@]
364 HRESULT WINAPI
AtlUnmarshalPtr(IStream
*stm
, const IID
*iid
, IUnknown
**ppUnk
)
366 FIXME("%p %p %p\n", stm
, iid
, ppUnk
);
370 /***********************************************************************
371 * AtlModuleGetClassObject [ATL.@]
373 HRESULT WINAPI
AtlModuleGetClassObject(_ATL_MODULEW
*pm
, REFCLSID rclsid
,
374 REFIID riid
, LPVOID
*ppv
)
376 _ATL_OBJMAP_ENTRYW_V1
*obj
;
378 HRESULT hres
= CLASS_E_CLASSNOTAVAILABLE
;
380 TRACE("%p %s %s %p\n", pm
, debugstr_guid(rclsid
), debugstr_guid(riid
), ppv
);
385 for (i
= 0; (obj
= get_objmap_entry( pm
, i
)) != NULL
; i
++)
387 if (IsEqualCLSID(obj
->pclsid
, rclsid
))
389 TRACE("found object %i\n", i
);
390 if (obj
->pfnGetClassObject
)
393 hres
= obj
->pfnGetClassObject(obj
->pfnCreateInstance
,
397 hres
= IUnknown_QueryInterface(obj
->pCF
, riid
, ppv
);
403 WARN("no class object found for %s\n", debugstr_guid(rclsid
));
408 /***********************************************************************
409 * AtlModuleGetClassObject [ATL.@]
411 HRESULT WINAPI
AtlModuleRegisterTypeLib(_ATL_MODULEW
*pm
, LPCOLESTR lpszIndex
)
417 TRACE("%p %s\n", pm
, debugstr_w(lpszIndex
));
422 hRes
= AtlModuleLoadTypeLib(pm
, lpszIndex
, &path
, &typelib
);
426 hRes
= RegisterTypeLib(typelib
, path
, NULL
); /* FIXME: pass help directory */
427 ITypeLib_Release(typelib
);
434 /***********************************************************************
435 * AtlModuleRevokeClassObjects [ATL.@]
437 HRESULT WINAPI
AtlModuleRevokeClassObjects(_ATL_MODULEW
*pm
)
443 /***********************************************************************
444 * AtlModuleUnregisterServer [ATL.@]
446 HRESULT WINAPI
AtlModuleUnregisterServer(_ATL_MODULEW
*pm
, const CLSID
*clsid
)
448 FIXME("%p %s\n", pm
, debugstr_guid(clsid
));
452 /***********************************************************************
453 * AtlModuleRegisterWndClassInfoA [ATL.@]
455 * See AtlModuleRegisterWndClassInfoW.
457 ATOM WINAPI
AtlModuleRegisterWndClassInfoA(_ATL_MODULEA
*pm
, _ATL_WNDCLASSINFOA
*wci
, WNDPROC
*pProc
)
461 FIXME("%p %p %p semi-stub\n", pm
, wci
, pProc
);
468 TRACE("wci->m_wc.lpszClassName = %s\n", wci
->m_wc
.lpszClassName
);
470 if (wci
->m_lpszOrigName
)
471 FIXME( "subclassing %s not implemented\n", debugstr_a(wci
->m_lpszOrigName
));
473 if (!wci
->m_wc
.lpszClassName
)
475 snprintf(wci
->m_szAutoName
, sizeof(wci
->m_szAutoName
), "ATL%08lx", (UINT_PTR
)wci
);
476 TRACE("auto-generated class name %s\n", wci
->m_szAutoName
);
477 wci
->m_wc
.lpszClassName
= wci
->m_szAutoName
;
480 atom
= GetClassInfoExA(pm
->m_hInst
, wci
->m_wc
.lpszClassName
, &wc
);
483 wci
->m_wc
.hInstance
= pm
->m_hInst
;
484 wci
->m_wc
.hCursor
= LoadCursorA( wci
->m_bSystemCursor
? NULL
: pm
->m_hInst
,
485 wci
->m_lpszCursorID
);
486 atom
= RegisterClassExA(&wci
->m_wc
);
488 wci
->pWndProc
= wci
->m_wc
.lpfnWndProc
;
492 if (wci
->m_lpszOrigName
) *pProc
= wci
->pWndProc
;
494 TRACE("returning 0x%04x\n", atom
);
498 /***********************************************************************
499 * AtlModuleRegisterWndClassInfoW [ATL.@]
502 * pm [IO] Information about the module registering the window.
503 * wci [IO] Information about the window being registered.
504 * pProc [O] Window procedure of the registered class.
507 * Atom representing the registered class.
510 * Can be called multiple times without error, unlike RegisterClassEx().
512 * If the class name is NULL, then a class with a name of "ATLxxxxxxxx" is
513 * registered, where the 'x's represent a unique value.
516 ATOM WINAPI
AtlModuleRegisterWndClassInfoW(_ATL_MODULEW
*pm
, _ATL_WNDCLASSINFOW
*wci
, WNDPROC
*pProc
)
520 FIXME("%p %p %p semi-stub\n", pm
, wci
, pProc
);
527 TRACE("wci->m_wc.lpszClassName = %s\n", debugstr_w(wci
->m_wc
.lpszClassName
));
529 if (wci
->m_lpszOrigName
)
530 FIXME( "subclassing %s not implemented\n", debugstr_w(wci
->m_lpszOrigName
));
532 if (!wci
->m_wc
.lpszClassName
)
534 static const WCHAR szFormat
[] = {'A','T','L','%','0','8','l','x',0};
535 snprintfW(wci
->m_szAutoName
, sizeof(wci
->m_szAutoName
)/sizeof(WCHAR
), szFormat
, (UINT_PTR
)wci
);
536 TRACE("auto-generated class name %s\n", debugstr_w(wci
->m_szAutoName
));
537 wci
->m_wc
.lpszClassName
= wci
->m_szAutoName
;
540 atom
= GetClassInfoExW(pm
->m_hInst
, wci
->m_wc
.lpszClassName
, &wc
);
543 wci
->m_wc
.hInstance
= pm
->m_hInst
;
544 wci
->m_wc
.hCursor
= LoadCursorW( wci
->m_bSystemCursor
? NULL
: pm
->m_hInst
,
545 wci
->m_lpszCursorID
);
546 atom
= RegisterClassExW(&wci
->m_wc
);
548 wci
->pWndProc
= wci
->m_wc
.lpfnWndProc
;
552 if (wci
->m_lpszOrigName
) *pProc
= wci
->pWndProc
;
554 TRACE("returning 0x%04x\n", atom
);
558 void WINAPI
AtlHiMetricToPixel(const SIZEL
* lpHiMetric
, SIZEL
* lpPix
)
560 HDC dc
= GetDC(NULL
);
561 lpPix
->cx
= lpHiMetric
->cx
* GetDeviceCaps( dc
, LOGPIXELSX
) / 100;
562 lpPix
->cy
= lpHiMetric
->cy
* GetDeviceCaps( dc
, LOGPIXELSY
) / 100;
563 ReleaseDC( NULL
, dc
);
566 void WINAPI
AtlPixelToHiMetric(const SIZEL
* lpPix
, SIZEL
* lpHiMetric
)
568 HDC dc
= GetDC(NULL
);
569 lpHiMetric
->cx
= 100 * lpPix
->cx
/ GetDeviceCaps( dc
, LOGPIXELSX
);
570 lpHiMetric
->cy
= 100 * lpPix
->cy
/ GetDeviceCaps( dc
, LOGPIXELSY
);
571 ReleaseDC( NULL
, dc
);
574 /***********************************************************************
575 * AtlCreateTargetDC [ATL.@]
577 HDC WINAPI
AtlCreateTargetDC( HDC hdc
, DVTARGETDEVICE
*dv
)
579 static const WCHAR displayW
[] = {'d','i','s','p','l','a','y',0};
580 const WCHAR
*driver
= NULL
, *device
= NULL
, *port
= NULL
;
581 DEVMODEW
*devmode
= NULL
;
583 TRACE( "(%p, %p)\n", hdc
, dv
);
587 if (dv
->tdDriverNameOffset
) driver
= (WCHAR
*)((char *)dv
+ dv
->tdDriverNameOffset
);
588 if (dv
->tdDeviceNameOffset
) device
= (WCHAR
*)((char *)dv
+ dv
->tdDeviceNameOffset
);
589 if (dv
->tdPortNameOffset
) port
= (WCHAR
*)((char *)dv
+ dv
->tdPortNameOffset
);
590 if (dv
->tdExtDevmodeOffset
) devmode
= (DEVMODEW
*)((char *)dv
+ dv
->tdExtDevmodeOffset
);
597 return CreateDCW( driver
, device
, port
, devmode
);
600 /***********************************************************************
601 * AtlModuleAddCreateWndData [ATL.@]
603 void WINAPI
AtlModuleAddCreateWndData(_ATL_MODULEW
*pM
, _AtlCreateWndData
*pData
, void* pvObject
)
605 TRACE("(%p, %p, %p)\n", pM
, pData
, pvObject
);
607 pData
->m_pThis
= pvObject
;
608 pData
->m_dwThreadID
= GetCurrentThreadId();
609 pData
->m_pNext
= pM
->m_pCreateWndList
;
610 pM
->m_pCreateWndList
= pData
;
613 /***********************************************************************
614 * AtlModuleExtractCreateWndData [ATL.@]
616 * NOTE: I failed to find any good description of this function.
617 * Tests show that this function extracts one of _AtlCreateWndData
618 * records from the current thread from a list
621 void* WINAPI
AtlModuleExtractCreateWndData(_ATL_MODULEW
*pM
)
623 _AtlCreateWndData
**ppData
;
627 for(ppData
= &pM
->m_pCreateWndList
; *ppData
!=NULL
; ppData
= &(*ppData
)->m_pNext
)
629 if ((*ppData
)->m_dwThreadID
== GetCurrentThreadId())
631 _AtlCreateWndData
*pData
= *ppData
;
632 *ppData
= pData
->m_pNext
;
633 return pData
->m_pThis
;
639 /* FIXME: should be in a header file */
640 typedef struct ATL_PROPMAP_ENTRY
644 const CLSID
* pclsidPropPage
;
645 const IID
* piidDispatch
;
651 /***********************************************************************
652 * AtlIPersistStreamInit_Load [ATL.@]
654 HRESULT WINAPI
AtlIPersistStreamInit_Load( LPSTREAM pStm
, ATL_PROPMAP_ENTRY
*pMap
,
655 void *pThis
, IUnknown
*pUnk
)
657 FIXME("(%p, %p, %p, %p)\n", pStm
, pMap
, pThis
, pUnk
);
662 HRESULT WINAPI
AtlIPersistStreamInit_Save(LPSTREAM pStm
, BOOL fClearDirty
,
663 ATL_PROPMAP_ENTRY
*pMap
, void *pThis
,
666 FIXME("(%p, %d, %p, %p, %p)\n", pStm
, fClearDirty
, pMap
, pThis
, pUnk
);