1 /*
2 * Implementation of Active Template Library (atl.dll)
3 *
4 * Copyright 2004 Aric Stewart for CodeWeavers
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winerror.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "wine/debug.h"
32 #include "objbase.h"
33 #include "objidl.h"
34 #include "ole2.h"
35 #include "atlbase.h"
36 #include "atliface.h"
37 #include "atlwin.h"
38
39 #include "wine/unicode.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(atl);
42
43 HINSTANCE hInst;
44
45 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
46 {
47 TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
48
49 if (fdwReason == DLL_PROCESS_ATTACH) {
50 DisableThreadLibraryCalls(hinstDLL);
51 hInst = hinstDLL;
52 }
53 return TRUE;
54 }
55
56 #define ATLVer1Size 100
57
58 HRESULT WINAPI AtlModuleInit(_ATL_MODULEW* pM, _ATL_OBJMAP_ENTRYW* p, HINSTANCE h)
59 {
60 INT i;
61 UINT size;
62
63 FIXME("SEMI-STUB (%p %p %p)\n",pM,p,h);
64
65 size = pM->cbSize;
66 if (size != sizeof(_ATL_MODULEW) && size != ATLVer1Size)
67 {
68 FIXME("Unknown structure version (size %i)\n",size);
69 return E_INVALIDARG;
70 }
71
72 memset(pM,0,pM->cbSize);
73 pM->cbSize = size;
74 pM->m_hInst = h;
75 pM->m_hInstResource = h;
76 pM->m_hInstTypeLib = h;
77 pM->m_pObjMap = p;
78 pM->m_hHeap = GetProcessHeap();
79
80 InitializeCriticalSection(&pM->u.m_csTypeInfoHolder);
81 InitializeCriticalSection(&pM->m_csWindowCreate);
82 InitializeCriticalSection(&pM->m_csObjMap);
83
84 /* call mains */
85 i = 0;
86 if (pM->m_pObjMap != NULL && size > ATLVer1Size)
87 {
88 while (pM->m_pObjMap[i].pclsid != NULL)
89 {
90 TRACE("Initializing object %i %p\n",i,p[i].pfnObjectMain);
91 if (p[i].pfnObjectMain)
92 p[i].pfnObjectMain(TRUE);
93 i++;
94 }
95 }
96
97 return S_OK;
98 }
99
100 HRESULT WINAPI AtlModuleLoadTypeLib(_ATL_MODULEW *pM, LPCOLESTR lpszIndex,
101 BSTR *pbstrPath, ITypeLib **ppTypeLib)
102 {
103 HRESULT hRes;
104 OLECHAR path[MAX_PATH+8]; /* leave some space for index */
105
106 TRACE("(%p, %s, %p, %p)\n", pM, debugstr_w(lpszIndex), pbstrPath, ppTypeLib);
107
108 if (!pM)
109 return E_INVALIDARG;
110
111 GetModuleFileNameW(pM->m_hInstTypeLib, path, MAX_PATH);
112 if (lpszIndex)
113 lstrcatW(path, lpszIndex);
114
115 hRes = LoadTypeLib(path, ppTypeLib);
116 if (FAILED(hRes))
117 return hRes;
118
119 *pbstrPath = SysAllocString(path);
120
121 return S_OK;
122 }
123
124 HRESULT WINAPI AtlModuleTerm(_ATL_MODULEW* pM)
125 {
126 _ATL_TERMFUNC_ELEM *iter = pM->m_pTermFuncs, *tmp;
127
128 TRACE("(%p)\n", pM);
129
130 while(iter) {
131 iter->pFunc(iter->dw);
132 tmp = iter;
133 iter = iter->pNext;
134 HeapFree(GetProcessHeap(), 0, tmp);
135 }
136
137 HeapFree(GetProcessHeap(), 0, pM);
138
139 return S_OK;
140 }
141
142 HRESULT WINAPI AtlModuleAddTermFunc(_ATL_MODULEW *pM, _ATL_TERMFUNC *pFunc, DWORD_PTR dw)
143 {
144 _ATL_TERMFUNC_ELEM *termfunc_elem;
145
146 TRACE("(%p %p %ld)\n", pM, pFunc, dw);
147
148 termfunc_elem = HeapAlloc(GetProcessHeap(), 0, sizeof(_ATL_TERMFUNC_ELEM));
149 termfunc_elem->pFunc = pFunc;
150 termfunc_elem->dw = dw;
151 termfunc_elem->pNext = pM->m_pTermFuncs;
152
153 pM->m_pTermFuncs = termfunc_elem;
154
155 return S_OK;
156 }
157
158 HRESULT WINAPI AtlModuleRegisterClassObjects(_ATL_MODULEW *pM, DWORD dwClsContext,
159 DWORD dwFlags)
160 {
161 HRESULT hRes = S_OK;
162 int i=0;
163
164 TRACE("(%p %i %i)\n",pM, dwClsContext, dwFlags);
165
166 if (pM == NULL)
167 return E_INVALIDARG;
168
169 while(pM->m_pObjMap[i].pclsid != NULL)
170 {
171 IUnknown* pUnknown;
172 _ATL_OBJMAP_ENTRYW *obj = &(pM->m_pObjMap[i]);
173 HRESULT rc;
174
175 TRACE("Registering object %i\n",i);
176 if (obj->pfnGetClassObject)
177 {
178 rc = obj->pfnGetClassObject(obj->pfnCreateInstance, &IID_IUnknown,
179 (LPVOID*)&pUnknown);
180 if (SUCCEEDED (rc) )
181 {
182 CoRegisterClassObject(obj->pclsid, pUnknown, dwClsContext,
183 dwFlags, &obj->dwRegister);
184 if (pUnknown)
185 IUnknown_Release(pUnknown);
186 }
187 }
188 i++;
189 }
190
191 return hRes;
192 }
193
194 HRESULT WINAPI AtlModuleUnregisterServerEx(_ATL_MODULEW* pM, BOOL bUnRegTypeLib, const CLSID* pCLSID)
195 {
196 FIXME("(%p, %i, %p) stub\n", pM, bUnRegTypeLib, pCLSID);
197 return S_OK;
198 }
199
200
201 IUnknown* WINAPI AtlComPtrAssign(IUnknown** pp, IUnknown *p)
202 {
203 TRACE("(%p %p)\n", pp, p);
204
205 if (p) IUnknown_AddRef(p);
206 if (*pp) IUnknown_Release(*pp);
207 *pp = p;
208 return p;
209 }
210
211 IUnknown* WINAPI AtlComQIPtrAssign(IUnknown** pp, IUnknown *p, REFIID riid)
212 {
213 IUnknown *new_p = NULL;
214
215 TRACE("(%p %p %s)\n", pp, p, debugstr_guid(riid));
216
217 if (p) IUnknown_QueryInterface(p, riid, (void **)&new_p);
218 if (*pp) IUnknown_Release(*pp);
219 *pp = new_p;
220 return new_p;
221 }
222
223
224 HRESULT WINAPI AtlInternalQueryInterface(void* this, const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject)
225 {
226 int i = 0;
227 HRESULT rc = E_NOINTERFACE;
228 TRACE("(%p, %p, %s, %p)\n",this, pEntries, debugstr_guid(iid), ppvObject);
229
230 if (IsEqualGUID(iid,&IID_IUnknown))
231 {
232 TRACE("Returning IUnknown\n");
233 *ppvObject = ((LPSTR)this+pEntries[0].dw);
234 IUnknown_AddRef((IUnknown*)*ppvObject);
235 return S_OK;
236 }
237
238 while (pEntries[i].pFunc != 0)
239 {
240 TRACE("Trying entry %i (%s %i %p)\n",i,debugstr_guid(pEntries[i].piid),
241 pEntries[i].dw, pEntries[i].pFunc);
242
243 if (pEntries[i].piid && IsEqualGUID(iid,pEntries[i].piid))
244 {
245 TRACE("MATCH\n");
246 if (pEntries[i].pFunc == (_ATL_CREATORARGFUNC*)1)
247 {
248 TRACE("Offset\n");
249 *ppvObject = ((LPSTR)this+pEntries[i].dw);
250 IUnknown_AddRef((IUnknown*)*ppvObject);
251 rc = S_OK;
252 }
253 else
254 {
255 TRACE("Function\n");
256 rc = pEntries[i].pFunc(this, iid, ppvObject,0);
257 }
258 break;
259 }
260 i++;
261 }
262 TRACE("Done returning (0x%x)\n",rc);
263 return rc;
264 }
265
266 /***********************************************************************
267 * AtlModuleRegisterServer [ATL.@]
268 *
269 */
270 HRESULT WINAPI AtlModuleRegisterServer(_ATL_MODULEW* pM, BOOL bRegTypeLib, const CLSID* clsid)
271 {
272 int i;
273 HRESULT hRes;
274
275 TRACE("%p %d %s\n", pM, bRegTypeLib, debugstr_guid(clsid));
276
277 if (pM == NULL)
278 return E_INVALIDARG;
279
280 for (i = 0; pM->m_pObjMap[i].pclsid != NULL; i++) /* register CLSIDs */
281 {
282 if (!clsid || IsEqualCLSID(pM->m_pObjMap[i].pclsid, clsid))
283 {
284 const _ATL_OBJMAP_ENTRYW *obj = &pM->m_pObjMap[i];
285
286 TRACE("Registering clsid %s\n", debugstr_guid(obj->pclsid));
287 hRes = obj->pfnUpdateRegistry(TRUE); /* register */
288 if (FAILED(hRes))
289 return hRes;
290 }
291 }
292
293 if (bRegTypeLib)
294 {
295 hRes = AtlModuleRegisterTypeLib(pM, NULL);
296 if (FAILED(hRes))
297 return hRes;
298 }
299
300 return S_OK;
301 }
302
303 /***********************************************************************
304 * AtlAdvise [ATL.@]
305 */
306 HRESULT WINAPI AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, LPDWORD pdw)
307 {
308 FIXME("%p %p %p %p\n", pUnkCP, pUnk, iid, pdw);
309 return E_FAIL;
310 }
311
312 /***********************************************************************
313 * AtlUnadvise [ATL.@]
314 */
315 HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw)
316 {
317 FIXME("%p %p %d\n", pUnkCP, iid, dw);
318 return S_OK;
319 }
320
321 /***********************************************************************
322 * AtlFreeMarshalStream [ATL.@]
323 */
324 HRESULT WINAPI AtlFreeMarshalStream(IStream *stm)
325 {
326 FIXME("%p\n", stm);
327 return S_OK;
328 }
329
330 /***********************************************************************
331 * AtlMarshalPtrInProc [ATL.@]
332 */
333 HRESULT WINAPI AtlMarshalPtrInProc(IUnknown *pUnk, const IID *iid, IStream **pstm)
334 {
335 FIXME("%p %p %p\n", pUnk, iid, pstm);
336 return E_FAIL;
337 }
338
339 /***********************************************************************
340 * AtlUnmarshalPtr [ATL.@]
341 */
342 HRESULT WINAPI AtlUnmarshalPtr(IStream *stm, const IID *iid, IUnknown **ppUnk)
343 {
344 FIXME("%p %p %p\n", stm, iid, ppUnk);
345 return E_FAIL;
346 }
347
348 /***********************************************************************
349 * AtlModuleGetClassObject [ATL.@]
350 */
351 HRESULT WINAPI AtlModuleGetClassObject(_ATL_MODULEW *pm, REFCLSID rclsid,
352 REFIID riid, LPVOID *ppv)
353 {
354 int i;
355 HRESULT hres = CLASS_E_CLASSNOTAVAILABLE;
356
357 TRACE("%p %s %s %p\n", pm, debugstr_guid(rclsid), debugstr_guid(riid), ppv);
358
359 if (pm == NULL)
360 return E_INVALIDARG;
361
362 for (i = 0; pm->m_pObjMap[i].pclsid != NULL; i++)
363 {
364 if (IsEqualCLSID(pm->m_pObjMap[i].pclsid, rclsid))
365 {
366 _ATL_OBJMAP_ENTRYW *obj = &pm->m_pObjMap[i];
367
368 TRACE("found object %i\n", i);
369 if (obj->pfnGetClassObject)
370 {
371 if (!obj->pCF)
372 hres = obj->pfnGetClassObject(obj->pfnCreateInstance,
373 &IID_IUnknown,
374 (void **)&obj->pCF);
375 if (obj->pCF)
376 hres = IUnknown_QueryInterface(obj->pCF, riid, ppv);
377 break;
378 }
379 }
380 }
381
382 WARN("no class object found for %s\n", debugstr_guid(rclsid));
383
384 return hres;
385 }
386
387 /***********************************************************************
388 * AtlModuleGetClassObject [ATL.@]
389 */
390 HRESULT WINAPI AtlModuleRegisterTypeLib(_ATL_MODULEW *pm, LPCOLESTR lpszIndex)
391 {
392 HRESULT hRes;
393 BSTR path;
394 ITypeLib *typelib;
395
396 TRACE("%p %s\n", pm, debugstr_w(lpszIndex));
397
398 if (!pm)
399 return E_INVALIDARG;
400
401 hRes = AtlModuleLoadTypeLib(pm, lpszIndex, &path, &typelib);
402
403 if (SUCCEEDED(hRes))
404 {
405 hRes = RegisterTypeLib(typelib, path, NULL); /* FIXME: pass help directory */
406 ITypeLib_Release(typelib);
407 SysFreeString(path);
408 }
409
410 return hRes;
411 }
412
413 /***********************************************************************
414 * AtlModuleRevokeClassObjects [ATL.@]
415 */
416 HRESULT WINAPI AtlModuleRevokeClassObjects(_ATL_MODULEW *pm)
417 {
418 FIXME("%p\n", pm);
419 return E_FAIL;
420 }
421
422 /***********************************************************************
423 * AtlModuleUnregisterServer [ATL.@]
424 */
425 HRESULT WINAPI AtlModuleUnregisterServer(_ATL_MODULEW *pm, const CLSID *clsid)
426 {
427 FIXME("%p %s\n", pm, debugstr_guid(clsid));
428 return E_FAIL;
429 }
430
431 /***********************************************************************
432 * AtlModuleRegisterWndClassInfoW [ATL.@]
433 *
434 * PARAMS
435 * pm [IO] Information about the module registering the window.
436 * wci [IO] Information about the window being registered.
437 * pProc [O] Window procedure of the registered class.
438 *
439 * RETURNS
440 * Atom representing the registered class.
441 *
442 * NOTES
443 * Can be called multiple times without error, unlike RegisterClassEx().
444 *
445 * If the class name is NULL, then a class with a name of "ATLxxxxxxxx" is
446 * registered, where the 'x's represent a unique value.
447 *
448 */
449 ATOM WINAPI AtlModuleRegisterWndClassInfoW(_ATL_MODULEW *pm, _ATL_WNDCLASSINFOW *wci, WNDPROC *pProc)
450 {
451 ATOM atom;
452
453 FIXME("%p %p %p semi-stub\n", pm, wci, pProc);
454
455 atom = wci->m_atom;
456 if (!atom)
457 {
458 WNDCLASSEXW wc;
459
460 TRACE("wci->m_wc.lpszClassName = %s\n", debugstr_w(wci->m_wc.lpszClassName));
461
462 if (!wci->m_wc.lpszClassName)
463 {
464 static const WCHAR szFormat[] = {'A','T','L','%','','8','x',0};
465 sprintfW(wci->m_szAutoName, szFormat, (UINT)(UINT_PTR)wci);
466 TRACE("auto-generated class name %s\n", debugstr_w(wci->m_szAutoName));
467 wci->m_wc.lpszClassName = wci->m_szAutoName;
468 }
469
470 atom = GetClassInfoExW(pm->m_hInst, wci->m_wc.lpszClassName, &wc);
471 if (!atom)
472 atom = RegisterClassExW(&wci->m_wc);
473
474 wci->pWndProc = wci->m_wc.lpfnWndProc;
475 wci->m_atom = atom;
476 }
477 *pProc = wci->pWndProc;
478
479 TRACE("returning 0x%04x\n", atom);
480 return atom;
481 }
482
483 void WINAPI AtlHiMetricToPixel(const SIZEL* lpHiMetric, SIZEL* lpPix)
484 {
485 HDC dc = GetDC(NULL);
486 lpPix->cx = lpHiMetric->cx * GetDeviceCaps( dc, LOGPIXELSX ) / 100;
487 lpPix->cy = lpHiMetric->cy * GetDeviceCaps( dc, LOGPIXELSY ) / 100;
488 ReleaseDC( NULL, dc );
489 }
490
491 void WINAPI AtlPixelToHiMetric(const SIZEL* lpPix, SIZEL* lpHiMetric)
492 {
493 HDC dc = GetDC(NULL);
494 lpHiMetric->cx = 100 * lpPix->cx / GetDeviceCaps( dc, LOGPIXELSX );
495 lpHiMetric->cy = 100 * lpPix->cy / GetDeviceCaps( dc, LOGPIXELSY );
496 ReleaseDC( NULL, dc );
497 }
498
499 /***********************************************************************
500 * AtlModuleAddCreateWndData [ATL.@]
501 */
502 void WINAPI AtlModuleAddCreateWndData(_ATL_MODULEW *pM, _AtlCreateWndData *pData, void* pvObject)
503 {
504 TRACE("(%p, %p, %p)\n", pM, pData, pvObject);
505
506 pData->m_pThis = pvObject;
507 pData->m_dwThreadID = GetCurrentThreadId();
508 pData->m_pNext = pM->m_pCreateWndList;
509 pM->m_pCreateWndList = pData;
510 }
511
512 /***********************************************************************
513 * AtlModuleExtractCreateWndData [ATL.@]
514 *
515 * NOTE: I failed to find any good description of this function.
516 * Tests show that this function extracts one of _AtlCreateWndData
517 * records from the current thread from a list
518 *
519 */
520 void* WINAPI AtlModuleExtractCreateWndData(_ATL_MODULEW *pM)
521 {
522 _AtlCreateWndData **ppData;
523
524 TRACE("(%p)\n", pM);
525
526 for(ppData = &pM->m_pCreateWndList; *ppData!=NULL; ppData = &(*ppData)->m_pNext)
527 {
528 if ((*ppData)->m_dwThreadID == GetCurrentThreadId())
529 {
530 _AtlCreateWndData *pData = *ppData;
531 *ppData = pData->m_pNext;
532 return pData->m_pThis;
533 }
534 }
535 return NULL;
536 }
537
538 /* FIXME: should be in a header file */
539 typedef struct ATL_PROPMAP_ENTRY
540 {
541 LPCOLESTR szDesc;
542 DISPID dispid;
543 const CLSID* pclsidPropPage;
544 const IID* piidDispatch;
545 DWORD dwOffsetData;
546 DWORD dwSizeData;
547 VARTYPE vt;
548 } ATL_PROPMAP_ENTRY;
549
550 /***********************************************************************
551 * AtlIPersistStreamInit_Load [ATL.@]
552 */
553 HRESULT WINAPI AtlIPersistStreamInit_Load( LPSTREAM pStm, ATL_PROPMAP_ENTRY *pMap,
554 void *pThis, IUnknown *pUnk)
555 {
556 FIXME("(%p, %p, %p, %p)\n", pStm, pMap, pThis, pUnk);
557
558 return S_OK;
559 }
560
561 HRESULT WINAPI AtlIPersistStreamInit_Save(LPSTREAM pStm, BOOL fClearDirty,
562 ATL_PROPMAP_ENTRY *pMap, void *pThis,
563 IUnknown *pUnk)
564 {
565 FIXME("(%p, %d, %p, %p, %p)\n", pStm, fClearDirty, pMap, pThis, pUnk);
566
567 return S_OK;
568 }
569
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.