kernel32: Update Korean resource.
[wine] / dlls / atl / atl_main.c
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 FIELD_OFFSET(_ATL_MODULEW, dwAtlBuildVer)
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     switch (size)
67     {
68     case ATLVer1Size:
69     case sizeof(_ATL_MODULEW):
70 #ifdef _WIN64
71     case sizeof(_ATL_MODULEW) + sizeof(void *):
72 #endif
73         break;
74     default:
75         WARN("Unknown structure version (size %i)\n",size);
76         return E_INVALIDARG;
77     }
78
79     memset(pM,0,pM->cbSize);
80     pM->cbSize = size;
81     pM->m_hInst = h;
82     pM->m_hInstResource = h;
83     pM->m_hInstTypeLib = h;
84     pM->m_pObjMap = p;
85     pM->m_hHeap = GetProcessHeap();
86
87     InitializeCriticalSection(&pM->u.m_csTypeInfoHolder);
88     InitializeCriticalSection(&pM->m_csWindowCreate);
89     InitializeCriticalSection(&pM->m_csObjMap);
90
91     /* call mains */
92     i = 0;
93     if (pM->m_pObjMap != NULL  && size > ATLVer1Size)
94     {
95         while (pM->m_pObjMap[i].pclsid != NULL)
96         {
97             TRACE("Initializing object %i %p\n",i,p[i].pfnObjectMain);
98             if (p[i].pfnObjectMain)
99                 p[i].pfnObjectMain(TRUE);
100             i++;
101         }
102     }
103
104     return S_OK;
105 }
106
107 static _ATL_OBJMAP_ENTRYW_V1 *get_objmap_entry( _ATL_MODULEW *mod, unsigned int index )
108 {
109     _ATL_OBJMAP_ENTRYW_V1 *ret;
110
111     if (mod->cbSize == ATLVer1Size)
112         ret = (_ATL_OBJMAP_ENTRYW_V1 *)mod->m_pObjMap + index;
113     else
114         ret = (_ATL_OBJMAP_ENTRYW_V1 *)(mod->m_pObjMap + index);
115
116     if (!ret->pclsid) ret = NULL;
117     return ret;
118 }
119
120 HRESULT WINAPI AtlModuleLoadTypeLib(_ATL_MODULEW *pM, LPCOLESTR lpszIndex,
121                                     BSTR *pbstrPath, ITypeLib **ppTypeLib)
122 {
123     HRESULT hRes;
124     OLECHAR path[MAX_PATH+8]; /* leave some space for index */
125
126     TRACE("(%p, %s, %p, %p)\n", pM, debugstr_w(lpszIndex), pbstrPath, ppTypeLib);
127
128     if (!pM)
129         return E_INVALIDARG;
130
131     GetModuleFileNameW(pM->m_hInstTypeLib, path, MAX_PATH);
132     if (lpszIndex)
133         lstrcatW(path, lpszIndex);
134
135     hRes = LoadTypeLib(path, ppTypeLib);
136     if (FAILED(hRes))
137         return hRes;
138
139     *pbstrPath = SysAllocString(path);
140
141     return S_OK;
142 }
143
144 HRESULT WINAPI AtlModuleTerm(_ATL_MODULEW* pM)
145 {
146     _ATL_TERMFUNC_ELEM *iter = pM->m_pTermFuncs, *tmp;
147
148     TRACE("(%p)\n", pM);
149
150     while(iter) {
151         iter->pFunc(iter->dw);
152         tmp = iter;
153         iter = iter->pNext;
154         HeapFree(GetProcessHeap(), 0, tmp);
155     }
156
157     HeapFree(GetProcessHeap(), 0, pM);
158
159     return S_OK;
160 }
161
162 HRESULT WINAPI AtlModuleAddTermFunc(_ATL_MODULEW *pM, _ATL_TERMFUNC *pFunc, DWORD_PTR dw)
163 {
164     _ATL_TERMFUNC_ELEM *termfunc_elem;
165
166     TRACE("(%p %p %ld)\n", pM, pFunc, dw);
167
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;
172
173     pM->m_pTermFuncs = termfunc_elem;
174
175     return S_OK;
176 }
177
178 HRESULT WINAPI AtlModuleRegisterClassObjects(_ATL_MODULEW *pM, DWORD dwClsContext,
179                                              DWORD dwFlags)
180 {
181     _ATL_OBJMAP_ENTRYW_V1 *obj;
182     HRESULT hRes = S_OK;
183     int i=0;
184
185     TRACE("(%p %i %i)\n",pM, dwClsContext, dwFlags);
186
187     if (pM == NULL)
188         return E_INVALIDARG;
189
190     while ((obj = get_objmap_entry( pM, i++ )))
191     {
192         IUnknown* pUnknown;
193         HRESULT rc;
194
195         TRACE("Registering object %i\n",i);
196         if (obj->pfnGetClassObject)
197         {
198             rc = obj->pfnGetClassObject(obj->pfnCreateInstance, &IID_IUnknown,
199                                    (LPVOID*)&pUnknown);
200             if (SUCCEEDED (rc) )
201             {
202                 CoRegisterClassObject(obj->pclsid, pUnknown, dwClsContext,
203                                       dwFlags, &obj->dwRegister);
204                 if (pUnknown)
205                     IUnknown_Release(pUnknown);
206             }
207         }
208     }
209
210    return hRes;
211 }
212
213 HRESULT WINAPI AtlModuleUnregisterServerEx(_ATL_MODULEW* pM, BOOL bUnRegTypeLib, const CLSID* pCLSID)
214 {
215     FIXME("(%p, %i, %p) stub\n", pM, bUnRegTypeLib, pCLSID);
216     return S_OK;
217 }
218
219
220 IUnknown* WINAPI AtlComPtrAssign(IUnknown** pp, IUnknown *p)
221 {
222     TRACE("(%p %p)\n", pp, p);
223
224     if (p) IUnknown_AddRef(p);
225     if (*pp) IUnknown_Release(*pp);
226     *pp = p;
227     return p;
228 }
229
230 IUnknown* WINAPI AtlComQIPtrAssign(IUnknown** pp, IUnknown *p, REFIID riid)
231 {
232     IUnknown *new_p = NULL;
233
234     TRACE("(%p %p %s)\n", pp, p, debugstr_guid(riid));
235
236     if (p) IUnknown_QueryInterface(p, riid, (void **)&new_p);
237     if (*pp) IUnknown_Release(*pp);
238     *pp = new_p;
239     return new_p;
240 }
241
242
243 HRESULT WINAPI AtlInternalQueryInterface(void* this, const _ATL_INTMAP_ENTRY* pEntries,  REFIID iid, void** ppvObject)
244 {
245     int i = 0;
246     HRESULT rc = E_NOINTERFACE;
247     TRACE("(%p, %p, %s, %p)\n",this, pEntries, debugstr_guid(iid), ppvObject);
248
249     if (IsEqualGUID(iid,&IID_IUnknown))
250     {
251         TRACE("Returning IUnknown\n");
252         *ppvObject = ((LPSTR)this+pEntries[0].dw);
253         IUnknown_AddRef((IUnknown*)*ppvObject);
254         return S_OK;
255     }
256
257     while (pEntries[i].pFunc != 0)
258     {
259         TRACE("Trying entry %i (%s %i %p)\n",i,debugstr_guid(pEntries[i].piid),
260               pEntries[i].dw, pEntries[i].pFunc);
261
262         if (!pEntries[i].piid || IsEqualGUID(iid,pEntries[i].piid))
263         {
264             TRACE("MATCH\n");
265             if (pEntries[i].pFunc == (_ATL_CREATORARGFUNC*)1)
266             {
267                 TRACE("Offset\n");
268                 *ppvObject = ((LPSTR)this+pEntries[i].dw);
269                 IUnknown_AddRef((IUnknown*)*ppvObject);
270                 return S_OK;
271             }
272             else
273             {
274                 TRACE("Function\n");
275                 rc = pEntries[i].pFunc(this, iid, ppvObject, pEntries[i].dw);
276                 if(rc==S_OK || pEntries[i].piid)
277                     return rc;
278             }
279         }
280         i++;
281     }
282     TRACE("Done returning (0x%x)\n",rc);
283     return rc;
284 }
285
286 /***********************************************************************
287  *           AtlModuleRegisterServer         [ATL.@]
288  *
289  */
290 HRESULT WINAPI AtlModuleRegisterServer(_ATL_MODULEW* pM, BOOL bRegTypeLib, const CLSID* clsid)
291 {
292     const _ATL_OBJMAP_ENTRYW_V1 *obj;
293     int i;
294     HRESULT hRes;
295
296     TRACE("%p %d %s\n", pM, bRegTypeLib, debugstr_guid(clsid));
297
298     if (pM == NULL)
299         return E_INVALIDARG;
300
301     for (i = 0; (obj = get_objmap_entry( pM, i )) != NULL; i++) /* register CLSIDs */
302     {
303         if (!clsid || IsEqualCLSID(obj->pclsid, clsid))
304         {
305             TRACE("Registering clsid %s\n", debugstr_guid(obj->pclsid));
306             hRes = obj->pfnUpdateRegistry(TRUE); /* register */
307             if (FAILED(hRes))
308                 return hRes;
309         }
310     }
311
312     if (bRegTypeLib)
313     {
314         hRes = AtlModuleRegisterTypeLib(pM, NULL);
315         if (FAILED(hRes))
316             return hRes;
317     }
318
319     return S_OK;
320 }
321
322 /***********************************************************************
323  *           AtlAdvise         [ATL.@]
324  */
325 HRESULT WINAPI AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, LPDWORD pdw)
326 {
327     FIXME("%p %p %p %p\n", pUnkCP, pUnk, iid, pdw);
328     return E_FAIL;
329 }
330
331 /***********************************************************************
332  *           AtlUnadvise         [ATL.@]
333  */
334 HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw)
335 {
336     FIXME("%p %p %d\n", pUnkCP, iid, dw);
337     return S_OK;
338 }
339
340 /***********************************************************************
341  *           AtlFreeMarshalStream         [ATL.@]
342  */
343 HRESULT WINAPI AtlFreeMarshalStream(IStream *stm)
344 {
345     FIXME("%p\n", stm);
346     return S_OK;
347 }
348
349 /***********************************************************************
350  *           AtlMarshalPtrInProc         [ATL.@]
351  */
352 HRESULT WINAPI AtlMarshalPtrInProc(IUnknown *pUnk, const IID *iid, IStream **pstm)
353 {
354     FIXME("%p %p %p\n", pUnk, iid, pstm);
355     return E_FAIL;
356 }
357
358 /***********************************************************************
359  *           AtlUnmarshalPtr              [ATL.@]
360  */
361 HRESULT WINAPI AtlUnmarshalPtr(IStream *stm, const IID *iid, IUnknown **ppUnk)
362 {
363     FIXME("%p %p %p\n", stm, iid, ppUnk);
364     return E_FAIL;
365 }
366
367 /***********************************************************************
368  *           AtlModuleGetClassObject              [ATL.@]
369  */
370 HRESULT WINAPI AtlModuleGetClassObject(_ATL_MODULEW *pm, REFCLSID rclsid,
371                                        REFIID riid, LPVOID *ppv)
372 {
373     _ATL_OBJMAP_ENTRYW_V1 *obj;
374     int i;
375     HRESULT hres = CLASS_E_CLASSNOTAVAILABLE;
376
377     TRACE("%p %s %s %p\n", pm, debugstr_guid(rclsid), debugstr_guid(riid), ppv);
378
379     if (pm == NULL)
380         return E_INVALIDARG;
381
382     for (i = 0; (obj = get_objmap_entry( pm, i )) != NULL; i++)
383     {
384         if (IsEqualCLSID(obj->pclsid, rclsid))
385         {
386             TRACE("found object %i\n", i);
387             if (obj->pfnGetClassObject)
388             {
389                 if (!obj->pCF)
390                     hres = obj->pfnGetClassObject(obj->pfnCreateInstance,
391                                                   &IID_IUnknown,
392                                                   (void **)&obj->pCF);
393                 if (obj->pCF)
394                     hres = IUnknown_QueryInterface(obj->pCF, riid, ppv);
395                 break;
396             }
397         }
398     }
399
400     WARN("no class object found for %s\n", debugstr_guid(rclsid));
401
402     return hres;
403 }
404
405 /***********************************************************************
406  *           AtlModuleGetClassObject              [ATL.@]
407  */
408 HRESULT WINAPI AtlModuleRegisterTypeLib(_ATL_MODULEW *pm, LPCOLESTR lpszIndex)
409 {
410     HRESULT hRes;
411     BSTR path;
412     ITypeLib *typelib;
413
414     TRACE("%p %s\n", pm, debugstr_w(lpszIndex));
415
416     if (!pm)
417         return E_INVALIDARG;
418
419     hRes = AtlModuleLoadTypeLib(pm, lpszIndex, &path, &typelib);
420
421     if (SUCCEEDED(hRes))
422     {
423         hRes = RegisterTypeLib(typelib, path, NULL); /* FIXME: pass help directory */
424         ITypeLib_Release(typelib);
425         SysFreeString(path);
426     }
427
428     return hRes;
429 }
430
431 /***********************************************************************
432  *           AtlModuleRevokeClassObjects          [ATL.@]
433  */
434 HRESULT WINAPI AtlModuleRevokeClassObjects(_ATL_MODULEW *pm)
435 {
436     FIXME("%p\n", pm);
437     return E_FAIL;
438 }
439
440 /***********************************************************************
441  *           AtlModuleUnregisterServer           [ATL.@]
442  */
443 HRESULT WINAPI AtlModuleUnregisterServer(_ATL_MODULEW *pm, const CLSID *clsid)
444 {
445     FIXME("%p %s\n", pm, debugstr_guid(clsid));
446     return E_FAIL;
447 }
448
449 /***********************************************************************
450  *           AtlModuleRegisterWndClassInfoA           [ATL.@]
451  *
452  * See AtlModuleRegisterWndClassInfoW.
453  */
454 ATOM WINAPI AtlModuleRegisterWndClassInfoA(_ATL_MODULEA *pm, _ATL_WNDCLASSINFOA *wci, WNDPROC *pProc)
455 {
456     ATOM atom;
457
458     FIXME("%p %p %p semi-stub\n", pm, wci, pProc);
459
460     atom = wci->m_atom;
461     if (!atom)
462     {
463         WNDCLASSEXA wc;
464
465         TRACE("wci->m_wc.lpszClassName = %s\n", wci->m_wc.lpszClassName);
466
467         if (!wci->m_wc.lpszClassName)
468         {
469             sprintf(wci->m_szAutoName, "ATL%08lx", (UINT_PTR)wci);
470             TRACE("auto-generated class name %s\n", wci->m_szAutoName);
471             wci->m_wc.lpszClassName = wci->m_szAutoName;
472         }
473
474         atom = GetClassInfoExA(pm->m_hInst, wci->m_wc.lpszClassName, &wc);
475         if (!atom)
476             atom = RegisterClassExA(&wci->m_wc);
477
478         wci->pWndProc = wci->m_wc.lpfnWndProc;
479         wci->m_atom = atom;
480     }
481     *pProc = wci->pWndProc;
482
483     TRACE("returning 0x%04x\n", atom);
484     return atom;
485 }
486
487 /***********************************************************************
488  *           AtlModuleRegisterWndClassInfoW           [ATL.@]
489  *
490  * PARAMS
491  *  pm   [IO] Information about the module registering the window.
492  *  wci  [IO] Information about the window being registered.
493  *  pProc [O] Window procedure of the registered class.
494  *
495  * RETURNS
496  *  Atom representing the registered class.
497  *
498  * NOTES
499  *  Can be called multiple times without error, unlike RegisterClassEx().
500  *
501  *  If the class name is NULL, then a class with a name of "ATLxxxxxxxx" is
502  *  registered, where the 'x's represent a unique value.
503  *
504  */
505 ATOM WINAPI AtlModuleRegisterWndClassInfoW(_ATL_MODULEW *pm, _ATL_WNDCLASSINFOW *wci, WNDPROC *pProc)
506 {
507     ATOM atom;
508
509     FIXME("%p %p %p semi-stub\n", pm, wci, pProc);
510
511     atom = wci->m_atom;
512     if (!atom)
513     {
514         WNDCLASSEXW wc;
515
516         TRACE("wci->m_wc.lpszClassName = %s\n", debugstr_w(wci->m_wc.lpszClassName));
517
518         if (!wci->m_wc.lpszClassName)
519         {
520             static const WCHAR szFormat[] = {'A','T','L','%','0','8','l','x',0};
521             sprintfW(wci->m_szAutoName, szFormat, (UINT_PTR)wci);
522             TRACE("auto-generated class name %s\n", debugstr_w(wci->m_szAutoName));
523             wci->m_wc.lpszClassName = wci->m_szAutoName;
524         }
525
526         atom = GetClassInfoExW(pm->m_hInst, wci->m_wc.lpszClassName, &wc);
527         if (!atom)
528             atom = RegisterClassExW(&wci->m_wc);
529
530         wci->pWndProc = wci->m_wc.lpfnWndProc;
531         wci->m_atom = atom;
532     }
533     *pProc = wci->pWndProc;
534
535     TRACE("returning 0x%04x\n", atom);
536     return atom;
537 }
538
539 void WINAPI AtlHiMetricToPixel(const SIZEL* lpHiMetric, SIZEL* lpPix)
540 {
541     HDC dc = GetDC(NULL);
542     lpPix->cx = lpHiMetric->cx * GetDeviceCaps( dc, LOGPIXELSX ) / 100;
543     lpPix->cy = lpHiMetric->cy * GetDeviceCaps( dc, LOGPIXELSY ) / 100;
544     ReleaseDC( NULL, dc );
545 }
546
547 void WINAPI AtlPixelToHiMetric(const SIZEL* lpPix, SIZEL* lpHiMetric)
548 {
549     HDC dc = GetDC(NULL);
550     lpHiMetric->cx = 100 * lpPix->cx / GetDeviceCaps( dc, LOGPIXELSX );
551     lpHiMetric->cy = 100 * lpPix->cy / GetDeviceCaps( dc, LOGPIXELSY );
552     ReleaseDC( NULL, dc );
553 }
554
555 /***********************************************************************
556  *           AtlCreateTargetDC         [ATL.@]
557  */
558 HDC WINAPI AtlCreateTargetDC( HDC hdc, DVTARGETDEVICE *dv )
559 {
560     static const WCHAR displayW[] = {'d','i','s','p','l','a','y',0};
561     const WCHAR *driver = NULL, *device = NULL, *port = NULL;
562     DEVMODEW *devmode = NULL;
563
564     TRACE( "(%p, %p)\n", hdc, dv );
565
566     if (dv)
567     {
568         if (dv->tdDriverNameOffset) driver  = (WCHAR *)((char *)dv + dv->tdDriverNameOffset);
569         if (dv->tdDeviceNameOffset) device  = (WCHAR *)((char *)dv + dv->tdDeviceNameOffset);
570         if (dv->tdPortNameOffset)   port    = (WCHAR *)((char *)dv + dv->tdPortNameOffset);
571         if (dv->tdExtDevmodeOffset) devmode = (DEVMODEW *)((char *)dv + dv->tdExtDevmodeOffset);
572     }
573     else
574     {
575         if (hdc) return hdc;
576         driver = displayW;
577     }
578     return CreateDCW( driver, device, port, devmode );
579 }
580
581 /***********************************************************************
582  *           AtlModuleAddCreateWndData          [ATL.@]
583  */
584 void WINAPI AtlModuleAddCreateWndData(_ATL_MODULEW *pM, _AtlCreateWndData *pData, void* pvObject)
585 {
586     TRACE("(%p, %p, %p)\n", pM, pData, pvObject);
587
588     pData->m_pThis = pvObject;
589     pData->m_dwThreadID = GetCurrentThreadId();
590     pData->m_pNext = pM->m_pCreateWndList;
591     pM->m_pCreateWndList = pData;
592 }
593
594 /***********************************************************************
595  *           AtlModuleExtractCreateWndData      [ATL.@]
596  *
597  *  NOTE: I failed to find any good description of this function.
598  *        Tests show that this function extracts one of _AtlCreateWndData
599  *        records from the current thread from a list
600  *
601  */
602 void* WINAPI AtlModuleExtractCreateWndData(_ATL_MODULEW *pM)
603 {
604     _AtlCreateWndData **ppData;
605
606     TRACE("(%p)\n", pM);
607
608     for(ppData = &pM->m_pCreateWndList; *ppData!=NULL; ppData = &(*ppData)->m_pNext)
609     {
610         if ((*ppData)->m_dwThreadID == GetCurrentThreadId())
611         {
612             _AtlCreateWndData *pData = *ppData;
613             *ppData = pData->m_pNext;
614             return pData->m_pThis;
615         }
616     }
617     return NULL;
618 }
619
620 /* FIXME: should be in a header file */
621 typedef struct ATL_PROPMAP_ENTRY
622 {
623     LPCOLESTR szDesc;
624     DISPID dispid;
625     const CLSID* pclsidPropPage;
626     const IID* piidDispatch;
627     DWORD dwOffsetData;
628     DWORD dwSizeData;
629     VARTYPE vt;
630 } ATL_PROPMAP_ENTRY;
631
632 /***********************************************************************
633  *           AtlIPersistStreamInit_Load      [ATL.@]
634  */
635 HRESULT WINAPI AtlIPersistStreamInit_Load( LPSTREAM pStm, ATL_PROPMAP_ENTRY *pMap,
636                                            void *pThis, IUnknown *pUnk)
637 {
638     FIXME("(%p, %p, %p, %p)\n", pStm, pMap, pThis, pUnk);
639
640     return S_OK;
641 }
642
643 HRESULT WINAPI AtlIPersistStreamInit_Save(LPSTREAM pStm, BOOL fClearDirty,
644                                           ATL_PROPMAP_ENTRY *pMap, void *pThis,
645                                           IUnknown *pUnk)
646 {
647     FIXME("(%p, %d, %p, %p, %p)\n", pStm, fClearDirty, pMap, pThis, pUnk);
648
649     return S_OK;
650 }