git.oblomov.eu Git - wine/blob - 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 100
  57
  58 HRESULT WINAPI AtlModuleInit(_ATL_MODULEA* pM, _ATL_OBJMAP_ENTRYA* 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_MODULEA) && 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_MODULEA *pM, LPCOLESTR lpszIndex,
 101                                     BSTR *pbstrPath, ITypeLib **ppTypeLib)
 102 {
 103     FIXME("(%p, %s, %p, %p): stub\n", pM, debugstr_w(lpszIndex), pbstrPath, ppTypeLib);
 104     return E_FAIL;
 105 }
 106
 107 HRESULT WINAPI AtlModuleTerm(_ATL_MODULEA* pM)
 108 {
 109     _ATL_TERMFUNC_ELEM *iter = pM->m_pTermFuncs, *tmp;
 110
 111     TRACE("(%p)\n", pM);
 112
 113     while(iter) {
 114         iter->pFunc(iter->dw);
 115         tmp = iter;
 116         iter = iter->pNext;
 117         HeapFree(GetProcessHeap(), 0, tmp);
 118     }
 119
 120     HeapFree(GetProcessHeap(), 0, pM);
 121
 122     return S_OK;
 123 }
 124
 125 HRESULT WINAPI AtlModuleAddTermFunc(_ATL_MODULEW *pM, _ATL_TERMFUNC *pFunc, DWORD_PTR dw)
 126 {
 127     _ATL_TERMFUNC_ELEM *termfunc_elem;
 128
 129     TRACE("(%p %p %ld)\n", pM, pFunc, dw);
 130
 131     termfunc_elem = HeapAlloc(GetProcessHeap(), 0, sizeof(_ATL_TERMFUNC_ELEM));
 132     termfunc_elem->pFunc = pFunc;
 133     termfunc_elem->dw = dw;
 134     termfunc_elem->pNext = pM->m_pTermFuncs;
 135
 136     pM->m_pTermFuncs = termfunc_elem;
 137
 138     return S_OK;
 139 }
 140
 141 HRESULT WINAPI AtlModuleRegisterClassObjects(_ATL_MODULEA *pM, DWORD dwClsContext,
 142                                              DWORD dwFlags)
 143 {
 144     HRESULT hRes = S_OK;
 145     int i=0;
 146
 147     TRACE("(%p %i %i)\n",pM, dwClsContext, dwFlags);
 148
 149     if (pM == NULL)
 150         return E_INVALIDARG;
 151
 152     while(pM->m_pObjMap[i].pclsid != NULL)
 153     {
 154         IUnknown* pUnknown;
 155         _ATL_OBJMAP_ENTRYA *obj = &(pM->m_pObjMap[i]);
 156         HRESULT rc;
 157
 158         TRACE("Registering object %i\n",i);
 159         if (obj->pfnGetClassObject)
 160         {
 161             rc = obj->pfnGetClassObject(obj->pfnCreateInstance, &IID_IUnknown,
 162                                    (LPVOID*)&pUnknown);
 163             if (SUCCEEDED (rc) )
 164             {
 165                 CoRegisterClassObject(obj->pclsid, pUnknown, dwClsContext,
 166                                       dwFlags, &obj->dwRegister);
 167                 if (pUnknown)
 168                     IUnknown_Release(pUnknown);
 169             }
 170         }
 171         i++;
 172     }
 173
 174    return hRes;
 175 }
 176
 177 HRESULT WINAPI AtlModuleUnregisterServerEx(_ATL_MODULEA* pM, BOOL bUnRegTypeLib, const CLSID* pCLSID)
 178 {
 179     FIXME("(%p, %i, %p) stub\n", pM, bUnRegTypeLib, pCLSID);
 180     return S_OK;
 181 }
 182
 183 /***********************************************************************
 184  *           AtlAxWinInit          [ATL.@]
 185  * Initializes the control-hosting code: registering the AtlAxWin7 and AtlAxWinLic7 window
 186  * classes and some messages.
 187  *
 188  * RETURNS
 189  *  TRUE or FALSE
 190  */
 191
 192 BOOL WINAPI AtlAxWinInit(void)
 193 {
 194     FIXME("Try use native atl.dll if possible\n");
 195     return FALSE;
 196 }
 197
 198
 199 IUnknown* WINAPI AtlComPtrAssign(IUnknown** pp, IUnknown *p)
 200 {
 201     TRACE("(%p %p)\n", pp, p);
 202
 203     if (p) IUnknown_AddRef(p);
 204     if (*pp) IUnknown_Release(*pp);
 205     *pp = p;
 206     return p;
 207 }
 208
 209
 210 HRESULT WINAPI AtlInternalQueryInterface(LPVOID this, const _ATL_INTMAP_ENTRY* pEntries,  REFIID iid, LPVOID* ppvObject)
 211 {
 212     int i = 0;
 213     HRESULT rc = E_NOINTERFACE;
 214     TRACE("(%p, %p, %p, %p)\n",this, pEntries, iid, ppvObject);
 215
 216     if (IsEqualGUID(iid,&IID_IUnknown))
 217     {
 218         TRACE("Returning IUnknown\n");
 219         *ppvObject = this;
 220         IUnknown_AddRef((IUnknown*)this);
 221         return S_OK;
 222     }
 223
 224     while (pEntries[i].pFunc != 0)
 225     {
 226         TRACE("Trying entry %i (%p %i %p)\n",i,pEntries[i].piid,
 227               pEntries[i].dw, pEntries[i].pFunc);
 228
 229         if (pEntries[i].piid && IsEqualGUID(iid,pEntries[i].piid))
 230         {
 231             TRACE("MATCH\n");
 232             if (pEntries[i].pFunc == (_ATL_CREATORARGFUNC*)1)
 233             {
 234                 TRACE("Offset\n");
 235                 *ppvObject = ((LPSTR)this+pEntries[i].dw);
 236                 IUnknown_AddRef((IUnknown*)this);
 237                 rc = S_OK;
 238             }
 239             else
 240             {
 241                 TRACE("Function\n");
 242                 rc = pEntries[i].pFunc(this, iid, ppvObject,0);
 243             }
 244             break;
 245         }
 246         i++;
 247     }
 248     TRACE("Done returning (0x%x)\n",rc);
 249     return rc;
 250 }
 251
 252 /***********************************************************************
 253  *           AtlModuleRegisterServer         [ATL.@]
 254  *
 255  */
 256 HRESULT WINAPI AtlModuleRegisterServer(_ATL_MODULEW* pM, BOOL bRegTypeLib, const CLSID* clsid)
 257 {
 258     FIXME("%p %d %s\n", pM, bRegTypeLib, debugstr_guid(clsid));
 259     return S_OK;
 260 }
 261
 262 /***********************************************************************
 263  *           AtlAdvise         [ATL.@]
 264  */
 265 HRESULT WINAPI AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, LPDWORD pdw)
 266 {
 267     FIXME("%p %p %p %p\n", pUnkCP, pUnk, iid, pdw);
 268     return E_FAIL;
 269 }
 270
 271 /***********************************************************************
 272  *           AtlUnadvise         [ATL.@]
 273  */
 274 HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw)
 275 {
 276     FIXME("%p %p %d\n", pUnkCP, iid, dw);
 277     return S_OK;
 278 }
 279
 280 /***********************************************************************
 281  *           AtlFreeMarshalStream         [ATL.@]
 282  */
 283 HRESULT WINAPI AtlFreeMarshalStream(IStream *stm)
 284 {
 285     FIXME("%p\n", stm);
 286     return S_OK;
 287 }
 288
 289 /***********************************************************************
 290  *           AtlMarshalPtrInProc         [ATL.@]
 291  */
 292 HRESULT WINAPI AtlMarshalPtrInProc(IUnknown *pUnk, const IID *iid, IStream **pstm)
 293 {
 294     FIXME("%p %p %p\n", pUnk, iid, pstm);
 295     return E_FAIL;
 296 }
 297
 298 /***********************************************************************
 299  *           AtlUnmarshalPtr              [ATL.@]
 300  */
 301 HRESULT WINAPI AtlUnmarshalPtr(IStream *stm, const IID *iid, IUnknown **ppUnk)
 302 {
 303     FIXME("%p %p %p\n", stm, iid, ppUnk);
 304     return E_FAIL;
 305 }
 306
 307 /***********************************************************************
 308  *           AtlModuleGetClassObject              [ATL.@]
 309  */
 310 HRESULT WINAPI AtlModuleGetClassObject(_ATL_MODULEW *pm, REFCLSID rclsid,
 311                                        REFIID riid, LPVOID *ppv)
 312 {
 313     int i;
 314
 315     TRACE("%p %s %s %p\n", pm, debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 316
 317     if (pm == NULL)
 318         return E_INVALIDARG;
 319
 320     for (i = 0; pm->m_pObjMap[i].pclsid != NULL; i++)
 321     {
 322         if (IsEqualCLSID(pm->m_pObjMap[i].pclsid, rclsid))
 323         {
 324             _ATL_OBJMAP_ENTRYW *obj = &pm->m_pObjMap[i];
 325
 326             TRACE("found object %i\n", i);
 327             if (obj->pfnGetClassObject)
 328                 return obj->pfnGetClassObject(obj->pfnCreateInstance, riid, ppv);
 329         }
 330     }
 331
 332     WARN("no class object found for %s\n", debugstr_guid(rclsid));
 333
 334     return E_FAIL;
 335 }
 336
 337 /***********************************************************************
 338  *           AtlModuleGetClassObject              [ATL.@]
 339  */
 340 HRESULT WINAPI AtlModuleRegisterTypeLib(_ATL_MODULEW *pm, LPCOLESTR lpszIndex)
 341 {
 342     FIXME("%p %s\n", pm, debugstr_w(lpszIndex));
 343     return E_FAIL;
 344 }
 345
 346 /***********************************************************************
 347  *           AtlModuleRevokeClassObjects          [ATL.@]
 348  */
 349 HRESULT WINAPI AtlModuleRevokeClassObjects(_ATL_MODULEW *pm)
 350 {
 351     FIXME("%p\n", pm);
 352     return E_FAIL;
 353 }
 354
 355 /***********************************************************************
 356  *           AtlModuleUnregisterServer           [ATL.@]
 357  */
 358 HRESULT WINAPI AtlModuleUnregisterServer(_ATL_MODULEW *pm, const CLSID *clsid)
 359 {
 360     FIXME("%p %s\n", pm, debugstr_guid(clsid));
 361     return E_FAIL;
 362 }
 363
 364 /***********************************************************************
 365  *           AtlAxCreateControl           [ATL.@]
 366  */
 367 HRESULT WINAPI AtlAxCreateControl(LPCOLESTR lpszName, HWND hWnd,
 368         IStream *pStream, IUnknown **ppUnkContainer)
 369 {
 370     FIXME("%s %p %p %p)\n", debugstr_w(lpszName), hWnd, pStream, ppUnkContainer);
 371     return E_NOTIMPL;
 372 }
 373
 374 /***********************************************************************
 375  *           AtlModuleRegisterWndClassInfoW           [ATL.@]
 376  *
 377  * PARAMS
 378  *  pm   [IO] Information about the module registering the window.
 379  *  wci  [IO] Information about the window being registered.
 380  *  pProc [O] Window procedure of the registered class.
 381  *
 382  * RETURNS
 383  *  Atom representing the registered class.
 384  *
 385  * NOTES
 386  *  Can be called multiple times without error, unlike RegisterClassEx().
 387  *
 388  *  If the class name is NULL then it a class with a name of "ATLxxxxxxxx" is
 389  *  registered, where the x's represent an unique value.
 390  *
 391  */
 392 ATOM WINAPI AtlModuleRegisterWndClassInfoW(_ATL_MODULEW *pm, _ATL_WNDCLASSINFOW *wci, WNDPROC *pProc)
 393 {
 394     ATOM atom;
 395
 396     FIXME("%p %p %p semi-stub\n", pm, wci, pProc);
 397
 398     atom = wci->m_atom;
 399     if (!atom)
 400     {
 401         WNDCLASSEXW wc;
 402
 403         TRACE("wci->m_wc.lpszClassName = %s\n", debugstr_w(wci->m_wc.lpszClassName));
 404
 405         if (!wci->m_wc.lpszClassName)
 406         {
 407             static const WCHAR szFormat[] = {'A','T','L','%','0','8','x',0};
 408             sprintfW(wci->m_szAutoName, szFormat, (UINT)(UINT_PTR)wci);
 409             TRACE("auto-generated class name %s\n", debugstr_w(wci->m_szAutoName));
 410             wci->m_wc.lpszClassName = wci->m_szAutoName;
 411         }
 412
 413         atom = GetClassInfoExW(pm->m_hInst, wci->m_wc.lpszClassName, &wc);
 414         if (!atom)
 415             atom = RegisterClassExW(&wci->m_wc);
 416
 417         wci->pWndProc = wci->m_wc.lpfnWndProc;
 418         wci->m_atom = atom;
 419     }
 420     *pProc = wci->pWndProc;
 421
 422     TRACE("returning 0x%04x\n", atom);
 423     return atom;
 424 }
 425
 426 void WINAPI AtlHiMetricToPixel(const SIZEL* lpHiMetric, SIZEL* lpPix)
 427 {
 428     HDC dc = GetDC(NULL);
 429     lpPix->cx = lpHiMetric->cx * GetDeviceCaps( dc, LOGPIXELSX ) / 100;
 430     lpPix->cy = lpHiMetric->cy * GetDeviceCaps( dc, LOGPIXELSY ) / 100;
 431     ReleaseDC( NULL, dc );
 432 }
 433
 434 void WINAPI AtlPixelToHiMetric(const SIZEL* lpPix, SIZEL* lpHiMetric)
 435 {
 436     HDC dc = GetDC(NULL);
 437     lpHiMetric->cx = 100 * lpPix->cx / GetDeviceCaps( dc, LOGPIXELSX );
 438     lpHiMetric->cy = 100 * lpPix->cy / GetDeviceCaps( dc, LOGPIXELSY );
 439     ReleaseDC( NULL, dc );
 440 }