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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "winuser.h"
  30 #include "wine/debug.h"
  31 #include "objbase.h"
  32 #include "objidl.h"
  33 #include "ole2.h"
  34 #include "atlbase.h"
  35 #include "atliface.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(atl);
  38
  39 HINSTANCE hInst;
  40
  41 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  42 {
  43     TRACE("(0x%p, %ld, %p)\n",hinstDLL,fdwReason,lpvReserved);
  44
  45     if (fdwReason == DLL_PROCESS_ATTACH) {
  46         DisableThreadLibraryCalls(hinstDLL);
  47         hInst = hinstDLL;
  48     }
  49     return TRUE;
  50 }
  51
  52 #define ATLVer1Size 100
  53
  54 HRESULT WINAPI AtlModuleInit(_ATL_MODULEA* pM, _ATL_OBJMAP_ENTRYA* p, HINSTANCE h)
  55 {
  56     INT i;
  57     UINT size;
  58
  59     FIXME("SEMI-STUB (%p %p %p)\n",pM,p,h);
  60
  61     size = pM->cbSize;
  62     if  (size != sizeof(_ATL_MODULEA) && size != ATLVer1Size)
  63     {
  64         FIXME("Unknown structure version (size %i)\n",size);
  65         return E_INVALIDARG;
  66     }
  67
  68     memset(pM,0,pM->cbSize);
  69     pM->cbSize = size;
  70     pM->m_hInst = h;
  71     pM->m_hInstResource = h;
  72     pM->m_hInstTypeLib = h;
  73     pM->m_pObjMap = p;
  74     pM->m_hHeap = GetProcessHeap();
  75
  76     /* call mains */
  77     i = 0;
  78     if (pM->m_pObjMap != NULL  && size > ATLVer1Size)
  79     {
  80         while (pM->m_pObjMap[i].pclsid != NULL)
  81         {
  82             TRACE("Initializing object %i %p\n",i,p[i].pfnObjectMain);
  83             if (p[i].pfnObjectMain)
  84                 p[i].pfnObjectMain(TRUE);
  85             i++;
  86         }
  87     }
  88
  89     return S_OK;
  90 }
  91
  92 HRESULT WINAPI AtlModuleTerm(_ATL_MODULEA* pM)
  93 {
  94     _ATL_TERMFUNC_ELEM *iter = pM->m_pTermFuncs, *tmp;
  95
  96     TRACE("(%p)\n", pM);
  97
  98     while(iter) {
  99         iter->pFunc(iter->dw);
 100         tmp = iter;
 101         iter = iter->pNext;
 102         HeapFree(GetProcessHeap(), 0, tmp);
 103     }
 104
 105     HeapFree(GetProcessHeap(), 0, pM);
 106
 107     return S_OK;
 108 }
 109
 110 HRESULT WINAPI AtlModuleAddTermFunc(_ATL_MODULEW *pM, _ATL_TERMFUNC *pFunc, DWORD_PTR dw)
 111 {
 112     _ATL_TERMFUNC_ELEM *termfunc_elem;
 113
 114     TRACE("(%p %p %ld)\n", pM, pFunc, dw);
 115
 116     termfunc_elem = HeapAlloc(GetProcessHeap(), 0, sizeof(_ATL_TERMFUNC_ELEM));
 117     termfunc_elem->pFunc = pFunc;
 118     termfunc_elem->dw = dw;
 119     termfunc_elem->pNext = pM->m_pTermFuncs;
 120
 121     pM->m_pTermFuncs = termfunc_elem;
 122
 123     return S_OK;
 124 }
 125
 126 HRESULT WINAPI AtlModuleRegisterClassObjects(_ATL_MODULEA *pM, DWORD dwClsContext,
 127                                              DWORD dwFlags)
 128 {
 129     HRESULT hRes = S_OK;
 130     int i=0;
 131
 132     TRACE("(%p %li %li)\n",pM, dwClsContext, dwFlags);
 133
 134     if (pM == NULL)
 135         return E_INVALIDARG;
 136
 137     while(pM->m_pObjMap[i].pclsid != NULL)
 138     {
 139         IUnknown* pUnknown;
 140         _ATL_OBJMAP_ENTRYA *obj = &(pM->m_pObjMap[i]);
 141         HRESULT rc;
 142
 143         TRACE("Registering object %i\n",i);
 144         if (obj->pfnGetClassObject)
 145         {
 146             rc = obj->pfnGetClassObject(obj->pfnCreateInstance, &IID_IUnknown,
 147                                    (LPVOID*)&pUnknown);
 148             if (SUCCEEDED (rc) )
 149             {
 150                 CoRegisterClassObject(obj->pclsid, pUnknown, dwClsContext,
 151                                       dwFlags, &obj->dwRegister);
 152                 if (pUnknown)
 153                     IUnknown_Release(pUnknown);
 154             }
 155         }
 156         i++;
 157     }
 158
 159    return hRes;
 160 }
 161
 162 HRESULT WINAPI AtlModuleUnregisterServerEx(_ATL_MODULEA* pM, BOOL bUnRegTypeLib, const CLSID* pCLSID)
 163 {
 164     FIXME("(%p, %i, %p) stub\n", pM, bUnRegTypeLib, pCLSID);
 165     return S_OK;
 166 }
 167
 168 HRESULT WINAPI AtlInternalQueryInterface(LPVOID this, const _ATL_INTMAP_ENTRY* pEntries,  REFIID iid, LPVOID* ppvObject)
 169 {
 170     int i = 0;
 171     HRESULT rc = E_NOINTERFACE;
 172     TRACE("(%p, %p, %p, %p)\n",this, pEntries, iid, ppvObject);
 173
 174     if (IsEqualGUID(iid,&IID_IUnknown))
 175     {
 176         TRACE("Returning IUnknown\n");
 177         *ppvObject = this;
 178         IUnknown_AddRef((IUnknown*)this);
 179         return S_OK;
 180     }
 181
 182     while (pEntries[i].pFunc != 0)
 183     {
 184         TRACE("Trying entry %i (%p %li %p)\n",i,pEntries[i].piid,
 185               pEntries[i].dw, pEntries[i].pFunc);
 186
 187         if (pEntries[i].piid && IsEqualGUID(iid,pEntries[i].piid))
 188         {
 189             TRACE("MATCH\n");
 190             if (pEntries[i].pFunc == (_ATL_CREATORARGFUNC*)1)
 191             {
 192                 TRACE("Offset\n");
 193                 *ppvObject = ((LPSTR)this+pEntries[i].dw);
 194                 IUnknown_AddRef((IUnknown*)this);
 195                 rc = S_OK;
 196             }
 197             else
 198             {
 199                 TRACE("Function\n");
 200                 rc = pEntries[i].pFunc(this, iid, ppvObject,0);
 201             }
 202             break;
 203         }
 204         i++;
 205     }
 206     TRACE("Done returning (0x%lx)\n",rc);
 207     return rc;
 208 }
 209
 210 /***********************************************************************
 211  *           AtlModuleRegisterServer         [ATL.@]
 212  *
 213  */
 214 HRESULT WINAPI AtlModuleRegisterServer(_ATL_MODULEW* pM, BOOL bRegTypeLib, const CLSID* clsid)
 215 {
 216     FIXME("%p %d %s\n", pM, bRegTypeLib, debugstr_guid(clsid));
 217     return S_OK;
 218 }
 219
 220 /***********************************************************************
 221  *           AtlAdvise         [ATL.@]
 222  */
 223 HRESULT WINAPI AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, LPDWORD pdw)
 224 {
 225     FIXME("%p %p %p %p\n", pUnkCP, pUnk, iid, pdw);
 226     return E_FAIL;
 227 }
 228
 229 /***********************************************************************
 230  *           AtlUnadvise         [ATL.@]
 231  */
 232 HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw)
 233 {
 234     FIXME("%p %p %ld\n", pUnkCP, iid, dw);
 235     return S_OK;
 236 }
 237
 238 /***********************************************************************
 239  *           AtlFreeMarshalStream         [ATL.@]
 240  */
 241 HRESULT WINAPI AtlFreeMarshalStream(IStream *stm)
 242 {
 243     FIXME("%p\n", stm);
 244     return S_OK;
 245 }
 246
 247 /***********************************************************************
 248  *           AtlMarshalPtrInProc         [ATL.@]
 249  */
 250 HRESULT WINAPI AtlMarshalPtrInProc(IUnknown *pUnk, const IID *iid, IStream **pstm)
 251 {
 252     FIXME("%p %p %p\n", pUnk, iid, pstm);
 253     return E_FAIL;
 254 }
 255
 256 /***********************************************************************
 257  *           AtlUnmarshalPtr              [ATL.@]
 258  */
 259 HRESULT WINAPI AtlUnmarshalPtr(IStream *stm, const IID *iid, IUnknown **ppUnk)
 260 {
 261     FIXME("%p %p %p\n", stm, iid, ppUnk);
 262     return E_FAIL;
 263 }
 264
 265 /***********************************************************************
 266  *           AtlModuleGetClassObject              [ATL.@]
 267  */
 268 HRESULT WINAPI AtlModuleGetClassObject(_ATL_MODULEW *pm, REFCLSID rclsid,
 269                                        REFIID riid, LPVOID *ppv)
 270 {
 271     FIXME("%p %p %p %p\n", pm, rclsid, riid, ppv);
 272     return E_FAIL;
 273 }
 274
 275 /***********************************************************************
 276  *           AtlModuleGetClassObject              [ATL.@]
 277  */
 278 HRESULT WINAPI AtlModuleRegisterTypeLib(_ATL_MODULEW *pm, LPCOLESTR lpszIndex)
 279 {
 280     FIXME("%p %s\n", pm, debugstr_w(lpszIndex));
 281     return E_FAIL;
 282 }
 283
 284 /***********************************************************************
 285  *           AtlModuleRevokeClassObjects          [ATL.@]
 286  */
 287 HRESULT WINAPI AtlModuleRevokeClassObjects(_ATL_MODULEW *pm)
 288 {
 289     FIXME("%p\n", pm);
 290     return E_FAIL;
 291 }
 292
 293 /***********************************************************************
 294  *           AtlModuleUnregisterServer           [ATL.@]
 295  */
 296 HRESULT WINAPI AtlModuleUnregisterServer(_ATL_MODULEW *pm, const CLSID *clsid)
 297 {
 298     FIXME("%p %s\n", pm, debugstr_guid(clsid));
 299     return E_FAIL;
 300 }