Ignore:
Timestamp:
Oct 19, 1999, 12:23:27 PM (26 years ago)
Author:
phaller
Message:

Fix: debug info

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shellole.cpp

    r1215 r1353  
    1 /* $Id: shellole.cpp,v 1.2 1999-10-09 11:17:05 sandervl Exp $ */
     1/* $Id: shellole.cpp,v 1.3 1999-10-19 10:23:27 phaller Exp $ */
     2
    23/*
    3  *      handling of SHELL32.DLL OLE-Objects
    4  *
    5  *      Copyright 1997  Marcus Meissner
    6  *      Copyright 1998  Juergen Schmied  <juergen.schmied@metronet.de>
    7  *
    8  */
     4 * Win32 SHELL32 for OS/2
     5 *
     6 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     7 * Project Odin Software License can be found in LICENSE.TXT
     8 *
     9 * handling of SHELL32.DLL OLE-Objects
     10 *
     11 * Copyright 1997 Marcus Meissner
     12 * Copyright 1998 Juergen Schmied  <juergen.schmied@metronet.de>
     13 *
     14 */
     15
     16
     17/*****************************************************************************
     18 * Includes                                                                  *
     19 *****************************************************************************/
     20
     21#include <odin.h>
     22#include <odinwrap.h>
     23#include <os2sel.h>
    924
    1025#include <stdlib.h>
    1126#include <string.h>
    12 #include <odin.h>
    1327
    1428#define ICOM_CINTERFACE 1
    … …  
    3347#include <misc.h>
    3448
    35 DEFAULT_DEBUG_CHANNEL(shell)
     49
     50/*****************************************************************************
     51 * Implementation                                                            *
     52 *****************************************************************************/
     53
     54ODINDEBUGCHANNEL(SHELL32-SHELLOLE)
     55
    3656
    3757DWORD WINAPI SHCLSIDFromStringA (LPSTR clsid, CLSID *id);
    … …  
    4363 *     exported by ordinal
    4464 */
    45 LRESULT WINAPI SHCoCreateInstance(
    46         LPSTR aclsid,
    47         REFCLSID clsid,
    48         IUnknown * unknownouter,
    49         REFIID refiid,
    50         LPVOID *ppv)
    51 {
    52         char    xclsid[48], xiid[48], xuout[48];
    53         DWORD   hres;
    54         IID     iid;
    55         CLSID * myclsid = (CLSID*)clsid;
    56        
    57         WINE_StringFromCLSID(refiid,xiid);
    58 
    59         if (!clsid)
    60         {
    61           if (!aclsid) return REGDB_E_CLASSNOTREG;
    62           SHCLSIDFromStringA(aclsid, &iid);
    63           myclsid = &iid;
    64         }
    65 
    66         WINE_StringFromCLSID(myclsid,xclsid);
    67         WINE_StringFromCLSID(refiid,xiid);
    68         if (unknownouter)
    69                 WINE_StringFromCLSID((const CLSID*)unknownouter,xuout);
    70        
    71         TRACE("(%p,\n\tCLSID:\t%s\n\tUOUT:\t%s\n\tIID:\t%s,%p)\n",
    72                 aclsid,xclsid,unknownouter?xuout:"nil",xiid,ppv);
    73 
    74         hres = CoCreateInstance(myclsid, NULL, CLSCTX_INPROC_SERVER, refiid, ppv);
    75 
    76         if(hres!=S_OK)
    77         {
    78           ERR("failed (0x%08lx) to create \n\tCLSID:\t%s\n\tIID:\t%s\n", hres, xclsid, xiid);
    79           ERR("you might need to import the winedefault.reg\n");
    80         }
    81 
    82         return hres;
     65
     66ODINFUNCTION5(LRESULT, SHCoCreateInstance, LPSTR,     aclsid,
     67                                           REFCLSID,  clsid,
     68                                           IUnknown*, unknownouter,
     69                                           REFIID,    refiid,
     70                                           LPVOID*,   ppv)
     71{
     72   char  xclsid[48], xiid[48], xuout[48];
     73   DWORD hres;
     74   IID   iid;
     75   CLSID * myclsid = (CLSID*)clsid;
     76
     77   WINE_StringFromCLSID(refiid,xiid);
     78
     79   if (!clsid)
     80   {
     81     if (!aclsid) return REGDB_E_CLASSNOTREG;
     82     SHCLSIDFromStringA(aclsid, &iid);
     83     myclsid = &iid;
     84   }
     85
     86   WINE_StringFromCLSID(myclsid,xclsid);
     87   WINE_StringFromCLSID(refiid,xiid);
     88   if (unknownouter)
     89      WINE_StringFromCLSID((const CLSID*)unknownouter,xuout);
     90
     91   dprintf(("SHELL32:SHCoCreateInstance (%p,CLSID:%s UOUT:%s IID:%s,%p)\n",
     92            aclsid,
     93            xclsid,
     94            unknownouter?xuout:"nil",xiid,ppv));
     95
     96   hres = CoCreateInstance(myclsid, NULL, CLSCTX_INPROC_SERVER, refiid, ppv);
     97
     98   if(hres!=S_OK)
     99   {
     100     dprintf(("SHELL32:SHCoCreateInstance failed (0x%08lx) to create CLSID:%s IID:%s\n",
     101              hres,
     102              xclsid,
     103              xiid));
     104     dprintf(("SHELL32:SHCoCreateInstance you might need to import the winedefault.reg\n"));
     105   }
     106
     107   return hres;
    83108}
    84109
    … …  
    86111 * SHELL32_DllGetClassObject   [SHELL32.128]
    87112 */
    88 HRESULT WINAPI SHELL32_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
    89 {       HRESULT hres = E_OUTOFMEMORY;
    90         LPCLASSFACTORY lpclf;
    91 
    92         char xclsid[50],xiid[50];
    93         WINE_StringFromCLSID((LPCLSID)rclsid,xclsid);
    94         WINE_StringFromCLSID((LPCLSID)iid,xiid);
    95         TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n",xclsid,xiid);
    96        
    97         *ppv = NULL;
    98 
    99         if(IsEqualCLSID(rclsid, &CLSID_PaperBin))
    100         {
    101           ERR("paper bin not implemented\n");
    102           return CLASS_E_CLASSNOTAVAILABLE;
    103         }
    104         if(IsEqualCLSID(rclsid, &CLSID_ShellDesktop)||
    105            IsEqualCLSID(rclsid, &CLSID_ShellLink))
    106         {
    107           lpclf = IClassFactory_Constructor( rclsid );
    108 
    109           if(lpclf)
    110           {
    111             hres = IClassFactory_QueryInterface(lpclf,iid, ppv);
    112             IClassFactory_Release(lpclf);
    113           }
    114         }
    115         else
    116         {
    117           WARN("-- CLSID not found\n");
    118           hres = CLASS_E_CLASSNOTAVAILABLE;
    119         }
    120         TRACE("-- pointer to class factory: %p\n",*ppv);
    121         return hres;
     113
     114ODINFUNCTION3(HRESULT, SHELL32_DllGetClassObject, REFCLSID, rclsid,
     115                                                  REFIID,   iid,
     116                                                  LPVOID*,  ppv)
     117{
     118   HRESULT  hres = E_OUTOFMEMORY;
     119   LPCLASSFACTORY lpclf;
     120
     121   char xclsid[50],xiid[50];
     122   WINE_StringFromCLSID((LPCLSID)rclsid,xclsid);
     123   WINE_StringFromCLSID((LPCLSID)iid,xiid);
     124   dprintf(("SHELL32:SHELL32_DllGetClassObject CLSID:%s, IID:%s\n",
     125            xclsid,
     126            xiid));
     127
     128   *ppv = NULL;
     129
     130   if(IsEqualCLSID(rclsid, &CLSID_PaperBin))
     131   {
     132     dprintf(("SHELL32:SHELL32_DllGetClassObject paper bin not implemented\n"));
     133     return CLASS_E_CLASSNOTAVAILABLE;
     134   }
     135   if(IsEqualCLSID(rclsid, &CLSID_ShellDesktop)||
     136      IsEqualCLSID(rclsid, &CLSID_ShellLink))
     137   {
     138     lpclf = IClassFactory_Constructor( rclsid );
     139
     140     if(lpclf)
     141     {
     142       hres = IClassFactory_QueryInterface(lpclf,iid, ppv);
     143       IClassFactory_Release(lpclf);
     144     }
     145   }
     146   else
     147   {
     148     dprintf(("SHELL32:SHELL32_DllGetClassObject -- CLSID not found\n"));
     149     hres = CLASS_E_CLASSNOTAVAILABLE;
     150   }
     151   dprintf(("SHELL32:SHELL32_DllGetClassObject -- pointer to class factory: %p\n",
     152            *ppv));
     153   return hres;
    122154}
    123155
    124156/*************************************************************************
    125  * SHCLSIDFromString                            [SHELL32.147]
     157 * SHCLSIDFromString                              [SHELL32.147]
    126158 *
    127159 * NOTES
    128160 *     exported by ordinal
    129161 */
    130 DWORD WINAPI SHCLSIDFromStringA (LPSTR clsid, CLSID *id)
    131 {
    132         TRACE("(%p(%s) %p)\n", clsid, clsid, id);
    133         return CLSIDFromStringA(clsid, id);
    134 }
    135 DWORD WINAPI SHCLSIDFromStringW (LPWSTR clsid, CLSID *id)
    136 {
    137         TRACE("(%p(%s) %p)\n", clsid, debugstr_w(clsid), id);
    138         return CLSIDFromString(clsid, id);
    139 }
    140 DWORD WINAPI SHCLSIDFromStringAW (LPVOID clsid, CLSID *id)
    141 {
    142         if (VERSION_OsIsUnicode())
    143           return SHCLSIDFromStringW ((LPWSTR)clsid, id);
    144         return SHCLSIDFromStringA ((LPSTR)clsid, id);
    145 }
     162ODINFUNCTION2(DWORD, SHCLSIDFromStringA, LPSTR,  clsid,
     163                                         CLSID*, id)
     164{
     165   return CLSIDFromStringA(clsid, id);
     166}
     167
     168
     169ODINFUNCTION2(DWORD, SHCLSIDFromStringW, LPWSTR, clsid,
     170                                         CLSID*, id)
     171{
     172   return CLSIDFromString(clsid, id);
     173}
     174
     175
     176ODINFUNCTION2(DWORD, SHCLSIDFromStringAW, LPVOID, clsid,
     177                                          CLSID*, id)
     178{
     179   if (VERSION_OsIsUnicode())
     180     return SHCLSIDFromStringW ((LPWSTR)clsid, id);
     181   return SHCLSIDFromStringA ((LPSTR)clsid, id);
     182}
     183
    146184
    147185/*************************************************************************
    148  *                       SHGetMalloc                    [SHELL32.220]
     186 *        SHGetMalloc                          [SHELL32.220]
    149187 * returns the interface to shell malloc.
    150188 *
    … …  
    155193 * heap (ProcessHeap).
    156194 */
    157 DWORD WINAPI SHGetMalloc(LPMALLOC *lpmal)
    158 {
    159         TRACE("(%p)\n", lpmal);
    160         return CoGetMalloc(0,lpmal);
    161 }
     195
     196ODINFUNCTION1(DWORD, SHGetMalloc, LPMALLOC*, lpmal)
     197{
     198  return CoGetMalloc(0,lpmal);
     199}
     200
    162201
    163202/*************************************************************************
    164  * SHGetDesktopFolder                   [SHELL32.216]
     203 * SHGetDesktopFolder                          [SHELL32.216]
    165204 */
    166205LPSHELLFOLDER pdesktopfolder=NULL;
    167206
    168 DWORD WINAPI SHGetDesktopFolder(IShellFolder **psf)
    169 {
    170         HRESULT hres = S_OK;
    171         LPCLASSFACTORY lpclf;
    172         TRACE_(shell)("%p->(%p)\n",psf,*psf);
    173 
    174         *psf=NULL;
    175 
    176         if (!pdesktopfolder)
    177         {
    178           lpclf = IClassFactory_Constructor(&CLSID_ShellDesktop);
    179           if(lpclf)
    180           {
    181             hres = IClassFactory_CreateInstance(lpclf,NULL,(REFIID)&IID_IShellFolder, (LPVOID*)&pdesktopfolder);
    182             IClassFactory_Release(lpclf);
    183           }
    184         }
    185        
    186         if (pdesktopfolder)
    187         {
    188           /* even if we create the folder, add a ref so the application canŽt destroy the folder*/
    189           IShellFolder_AddRef(pdesktopfolder);
    190           *psf = pdesktopfolder;
    191         }
    192 
    193         TRACE_(shell)("-- %p->(%p)\n",psf, *psf);
    194         return hres;
     207ODINFUNCTION1(DWORD, SHGetDesktopFolder, IShellFolder**, psf)
     208{
     209   HRESULT  hres = S_OK;
     210   LPCLASSFACTORY lpclf;
     211   dprintf(("SHELL32: SHGetDesktopFolder %p->(%p)\n",psf,*psf));
     212
     213   *psf=NULL;
     214
     215   if (!pdesktopfolder)
     216   {
     217     lpclf = IClassFactory_Constructor(&CLSID_ShellDesktop);
     218     if(lpclf)
     219     {
     220       hres = IClassFactory_CreateInstance(lpclf,NULL,(REFIID)&IID_IShellFolder, (LPVOID*)&pdesktopfolder);
     221       IClassFactory_Release(lpclf);
     222     }
     223   }
     224
     225   if (pdesktopfolder)
     226   {
     227     /* even if we create the folder, add a ref so the application canŽt destroy the folder*/
     228     IShellFolder_AddRef(pdesktopfolder);
     229     *psf = pdesktopfolder;
     230   }
     231
     232   dprintf(("SHELL32: SHGetDesktopFolder-- %p->(%p)\n",psf, *psf));
     233   return hres;
    195234}
    196235
    … …  
    204243    ICOM_VTABLE(IClassFactory)* lpvtbl;
    205244    DWORD                       ref;
    206     CLSID                       *rclsid;
     245    CLSID         *rclsid;
    207246} IClassFactoryImpl;
    208247
    … …  
    215254  LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)
    216255{
    217         ICOM_THIS(IClassFactoryImpl,iface);
    218         char    xriid[50];
    219         WINE_StringFromCLSID((LPCLSID)riid,xriid);
    220         TRACE("(%p)->(\n\tIID:\t%s)\n",This,xriid);
    221 
    222         *ppvObj = NULL;
    223 
    224         if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
    225         { *ppvObj = This;
    226         }
    227         else if(IsEqualIID(riid, &IID_IClassFactory))  /*IClassFactory*/
    228         { *ppvObj = (IClassFactory*)This;
    229         }
    230 
    231         if(*ppvObj)
    232         { IUnknown_AddRef((LPUNKNOWN)*ppvObj);         
    233           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
    234           return S_OK;
    235         }
    236         TRACE("-- Interface: %s E_NOINTERFACE\n", xriid);
    237         return E_NOINTERFACE;
     256   ICOM_THIS(IClassFactoryImpl,iface);
     257   char  xriid[50];
     258   WINE_StringFromCLSID((LPCLSID)riid,xriid);
     259
     260   dprintf(("SHELL32: IClassFactory_fnQueryInterface (%p)->(\n\tIID:\t%s)\n",This,xriid));
     261
     262   *ppvObj = NULL;
     263
     264   if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
     265   { *ppvObj = This;
     266   }
     267   else if(IsEqualIID(riid, &IID_IClassFactory))  /*IClassFactory*/
     268   { *ppvObj = (IClassFactory*)This;
     269   }
     270
     271   if(*ppvObj)
     272   { IUnknown_AddRef((LPUNKNOWN)*ppvObj);
     273     dprintf(("SHELL32: IClassFactory_fnQueryInterface -- Interface: (%p)->(%p)\n",ppvObj,*ppvObj));
     274     return S_OK;
     275   }
     276   dprintf(("SHELL32: IClassFactory_fnQueryInterface -- Interface: %s E_NOINTERFACE\n", xriid));
     277   return E_NOINTERFACE;
    238278}
    239279/******************************************************************************
    … …  
    242282static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface)
    243283{
    244         ICOM_THIS(IClassFactoryImpl,iface);
    245         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    246 
    247         shell32_ObjCount++;
    248         return ++(This->ref);
     284   ICOM_THIS(IClassFactoryImpl,iface);
     285   dprintf(("SHELL32: IClassFactory_fnAddRef (%p)->(count=%lu)\n",This,This->ref));
     286
     287   shell32_ObjCount++;
     288   return ++(This->ref);
    249289}
    250290/******************************************************************************
    … …  
    253293static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
    254294{
    255         ICOM_THIS(IClassFactoryImpl,iface);
    256         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    257 
    258         shell32_ObjCount--;
    259         if (!--(This->ref))
    260         { TRACE("-- destroying IClassFactory(%p)\n",This);
    261                 HeapFree(GetProcessHeap(),0,This);
    262                 return 0;
    263         }
    264         return This->ref;
     295   ICOM_THIS(IClassFactoryImpl,iface);
     296   dprintf(("SHELL32: IClassFactory_fnRelease (%p)->(count=%lu)\n",This,This->ref));
     297
     298   shell32_ObjCount--;
     299   if (!--(This->ref))
     300   { dprintf(("SHELL32: IClassFactory_fnRelease -- destroying IClassFactory(%p)\n",This));
     301      HeapFree(GetProcessHeap(),0,This);
     302      return 0;
     303   }
     304   return This->ref;
    265305}
    266306/******************************************************************************
    … …  
    270310  LPCLASSFACTORY iface, LPUNKNOWN pUnknown, REFIID riid, LPVOID *ppObject)
    271311{
    272         ICOM_THIS(IClassFactoryImpl,iface);
    273         IUnknown *pObj = NULL;
    274         HRESULT hres;
    275         char    xriid[50];
    276 
    277         WINE_StringFromCLSID((LPCLSID)riid,xriid);
    278         TRACE("%p->(%p,\n\tIID:\t%s,%p)\n",This,pUnknown,xriid,ppObject);
    279 
    280         *ppObject = NULL;
    281                
    282         if(pUnknown)
    283         {
    284           return(CLASS_E_NOAGGREGATION);
    285         }
    286 
    287         if (IsEqualCLSID(This->rclsid, &CLSID_ShellDesktop))
    288         {
    289           pObj = (IUnknown *)ISF_Desktop_Constructor();
    290         }
    291         else if (IsEqualCLSID(This->rclsid, &CLSID_ShellLink))
    292         {
    293           pObj = (IUnknown *)IShellLink_Constructor(FALSE);
    294         }
    295         else
    296         {
    297           ERR("unknown IID requested\n\tIID:\t%s\n",xriid);
    298           return(E_NOINTERFACE);
    299         }
    300        
    301         if (!pObj)
    302         {
    303           return(E_OUTOFMEMORY);
    304         }
    305        
    306         hres = IUnknown_QueryInterface(pObj,riid, ppObject);
    307         IUnknown_Release(pObj);
    308 
    309         TRACE("-- Object created: (%p)->%p\n",This,*ppObject);
    310 
    311         return hres;
     312   ICOM_THIS(IClassFactoryImpl,iface);
     313   IUnknown *pObj = NULL;
     314   HRESULT hres;
     315   char  xriid[50];
     316
     317   WINE_StringFromCLSID((LPCLSID)riid,xriid);
     318   dprintf(("SHELL32: IClassFactory_fnCreateInstance %p->(%p,\n\tIID:\t%s,%p)\n",This,pUnknown,xriid,ppObject));
     319
     320   *ppObject = NULL;
     321
     322   if(pUnknown)
     323   {
     324     return(CLASS_E_NOAGGREGATION);
     325   }
     326
     327   if (IsEqualCLSID(This->rclsid, &CLSID_ShellDesktop))
     328   {
     329     pObj = (IUnknown *)ISF_Desktop_Constructor();
     330   }
     331   else if (IsEqualCLSID(This->rclsid, &CLSID_ShellLink))
     332   {
     333     pObj = (IUnknown *)IShellLink_Constructor(FALSE);
     334   }
     335   else
     336   {
     337     dprintf(("SHELL32: IClassFactory_fnCreateInstance unknown IID requested\n\tIID:\t%s\n",xriid));
     338     return(E_NOINTERFACE);
     339   }
     340
     341   if (!pObj)
     342   {
     343     return(E_OUTOFMEMORY);
     344   }
     345
     346   hres = IUnknown_QueryInterface(pObj,riid, ppObject);
     347   IUnknown_Release(pObj);
     348
     349   dprintf(("SHELL32: IClassFactory_fnCreateInstance -- Object created: (%p)->%p\n",This,*ppObject));
     350
     351   return hres;
    312352}
    313353/******************************************************************************
    … …  
    316356static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface, BOOL fLock)
    317357{
    318         ICOM_THIS(IClassFactoryImpl,iface);
    319         TRACE("%p->(0x%x), not implemented\n",This, fLock);
    320         return E_NOTIMPL;
     358   ICOM_THIS(IClassFactoryImpl,iface);
     359   dprintf(("SHELL32: IClassFactory_fnLockServer %p->(0x%x), not implemented\n",This, fLock));
     360   return E_NOTIMPL;
    321361}
    322362
    … …  
    337377LPCLASSFACTORY IClassFactory_Constructor(REFCLSID rclsid)
    338378{
    339         IClassFactoryImpl* lpclf;
    340 
    341         lpclf= (IClassFactoryImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IClassFactoryImpl));
    342         lpclf->ref = 1;
    343         lpclf->lpvtbl = &clfvt;
    344         lpclf->rclsid = (CLSID*)rclsid;
    345 
    346         TRACE("(%p)->()\n",lpclf);
    347         shell32_ObjCount++;
    348         return (LPCLASSFACTORY)lpclf;
     379   IClassFactoryImpl* lpclf;
     380
     381   lpclf= (IClassFactoryImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IClassFactoryImpl));
     382   lpclf->ref = 1;
     383   lpclf->lpvtbl = &clfvt;
     384   lpclf->rclsid = (CLSID*)rclsid;
     385
     386   dprintf(("SHELL32: IClassFactory_Constructor (%p)->()\n",lpclf));
     387   shell32_ObjCount++;
     388   return (LPCLASSFACTORY)lpclf;
    349389}
    350390
    … …  
    366406    ICOM_VTABLE(IClassFactory)* lpvtbl;
    367407    DWORD                       ref;
    368     CLSID                       *rclsid;
    369     LPFNCREATEINSTANCE          lpfnCI;
    370     const IID *                 riidInst;
    371     UINT *                      pcRefDll; /* pointer to refcounter in external dll (ugrrr...) */
     408    CLSID         *rclsid;
     409    LPFNCREATEINSTANCE                      lpfnCI;
     410    const IID *                             riidInst;
     411    UINT *        pcRefDll; /* pointer to refcounter in external dll (ugrrr...) */
    372412} IDefClFImpl;
    373413
    … …  
    380420  LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)
    381421{
    382         ICOM_THIS(IDefClFImpl,iface);
    383         char    xriid[50];
    384         WINE_StringFromCLSID((LPCLSID)riid,xriid);
    385         TRACE("(%p)->(\n\tIID:\t%s)\n",This,xriid);
    386 
    387         *ppvObj = NULL;
    388 
    389         if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
    390         { *ppvObj = This;
    391         }
    392         else if(IsEqualIID(riid, &IID_IClassFactory))  /*IClassFactory*/
    393         { *ppvObj = (IClassFactory*)This;
    394         }
    395 
    396         if(*ppvObj)
    397         { IUnknown_AddRef((LPUNKNOWN)*ppvObj);         
    398           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
    399           return S_OK;
    400         }
    401         TRACE("-- Interface: %s E_NOINTERFACE\n", xriid);
    402         return E_NOINTERFACE;
     422   ICOM_THIS(IDefClFImpl,iface);
     423   char  xriid[50];
     424   WINE_StringFromCLSID((LPCLSID)riid,xriid);
     425   dprintf(("SHELL32: IDefClF_fnQueryInterface (%p)->(\n\tIID:\t%s)\n",This,xriid));
     426
     427   *ppvObj = NULL;
     428
     429   if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
     430   { *ppvObj = This;
     431   }
     432   else if(IsEqualIID(riid, &IID_IClassFactory))  /*IClassFactory*/
     433   { *ppvObj = (IClassFactory*)This;
     434   }
     435
     436   if(*ppvObj)
     437   { IUnknown_AddRef((LPUNKNOWN)*ppvObj);
     438     dprintf(("SHELL32: IDefClF_fnQueryInterface -- Interface: (%p)->(%p)\n",ppvObj,*ppvObj));
     439     return S_OK;
     440   }
     441   dprintf(("SHELL32: IDefClF_fnQueryInterface -- Interface: %s E_NOINTERFACE\n", xriid));
     442   return E_NOINTERFACE;
    403443}
    404444/******************************************************************************
    … …  
    407447static ULONG WINAPI IDefClF_fnAddRef(LPCLASSFACTORY iface)
    408448{
    409         ICOM_THIS(IDefClFImpl,iface);
    410         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    411 
    412         shell32_ObjCount++;
    413 
    414         return ++(This->ref);
     449   ICOM_THIS(IDefClFImpl,iface);
     450   dprintf(("SHELL32: IDefClF_fnAddRef (%p)->(count=%lu)\n",This,This->ref));
     451
     452   shell32_ObjCount++;
     453
     454   return ++(This->ref);
    415455}
    416456/******************************************************************************
    … …  
    419459static ULONG WINAPI IDefClF_fnRelease(LPCLASSFACTORY iface)
    420460{
    421         ICOM_THIS(IDefClFImpl,iface);
    422         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    423 
    424         shell32_ObjCount--;
    425 
    426         if (!--(This->ref))
    427         {
    428           if (This->pcRefDll)
    429             (*This->pcRefDll)--;
    430 
    431           TRACE("-- destroying IClassFactory(%p)\n",This);
    432           HeapFree(GetProcessHeap(),0,This);
    433           return 0;
    434         }
    435         return This->ref;
     461   ICOM_THIS(IDefClFImpl,iface);
     462   dprintf(("SHELL32: IDefClF_fnRelease (%p)->(count=%lu)\n",This,This->ref));
     463
     464   shell32_ObjCount--;
     465
     466   if (!--(This->ref))
     467   {
     468     if (This->pcRefDll)
     469       (*This->pcRefDll)--;
     470
     471     dprintf(("SHELL32: IDefClF_fn -- destroying IClassFactory(%p)\n",This));
     472     HeapFree(GetProcessHeap(),0,This);
     473     return 0;
     474   }
     475   return This->ref;
    436476}
    437477/******************************************************************************
    … …  
    441481  LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObject)
    442482{
    443         ICOM_THIS(IDefClFImpl,iface);
    444         char    xriid[50];
    445 
    446         WINE_StringFromCLSID((LPCLSID)riid,xriid);
    447         TRACE("%p->(%p,\n\tIID:\t%s,%p)\n",This,pUnkOuter,xriid,ppvObject);
    448 
    449         *ppvObject = NULL;
    450                
    451         if(pUnkOuter)
    452           return(CLASS_E_NOAGGREGATION);
    453 
    454         if ( This->riidInst==NULL ||
    455              IsEqualCLSID(riid, This->riidInst) ||
    456              IsEqualCLSID(riid, &IID_IUnknown) )
    457         {
    458           return This->lpfnCI(pUnkOuter, riid, ppvObject);
    459         }
    460 
    461         ERR("unknown IID requested\n\tIID:\t%s\n",xriid);
    462         return E_NOINTERFACE;
     483   ICOM_THIS(IDefClFImpl,iface);
     484   char  xriid[50];
     485
     486   WINE_StringFromCLSID((LPCLSID)riid,xriid);
     487   dprintf(("SHELL32: IDefClF_fnCreateInterface %p->(%p,\n\tIID:\t%s,%p)\n",This,pUnkOuter,xriid,ppvObject));
     488
     489   *ppvObject = NULL;
     490
     491   if(pUnkOuter)
     492     return(CLASS_E_NOAGGREGATION);
     493
     494   if ( This->riidInst==NULL ||
     495        IsEqualCLSID(riid, This->riidInst) ||
     496        IsEqualCLSID(riid, &IID_IUnknown) )
     497   {
     498     return This->lpfnCI(pUnkOuter, riid, ppvObject);
     499   }
     500
     501   dprintf(("SHELL32: IDefClF_fn unknown IID requested\n\tIID:\t%s\n",xriid));
     502   return E_NOINTERFACE;
    463503}
    464504/******************************************************************************
    … …  
    467507static HRESULT WINAPI IDefClF_fnLockServer(LPCLASSFACTORY iface, BOOL fLock)
    468508{
    469         ICOM_THIS(IDefClFImpl,iface);
    470         TRACE("%p->(0x%x), not implemented\n",This, fLock);
    471         return E_NOTIMPL;
     509   ICOM_THIS(IDefClFImpl,iface);
     510   dprintf(("SHELL32: IDefClF_fnLockServer %p->(0x%x), not implemented\n",This, fLock));
     511   return E_NOTIMPL;
    472512}
    473513
    … …  
    488528IClassFactory * IDefClF_fnConstructor(LPFNCREATEINSTANCE lpfnCI, UINT * pcRefDll, REFIID riidInst)
    489529{
    490         IDefClFImpl* lpclf;
    491         char    xriidInst[50];
    492 
    493         WINE_StringFromCLSID((LPCLSID)riidInst,xriidInst);
    494 
    495         lpclf = (IDefClFImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDefClFImpl));
    496         lpclf->ref = 1;
    497         lpclf->lpvtbl = &dclfvt;
    498         lpclf->lpfnCI = lpfnCI;
    499         lpclf->pcRefDll = pcRefDll;
    500 
    501         if (pcRefDll)
    502           (*pcRefDll)++;
    503 
    504         lpclf->riidInst = riidInst;
    505 
    506         TRACE("(%p)\n\tIID:\t%s\n",lpclf, xriidInst);
    507         shell32_ObjCount++;
    508         return (LPCLASSFACTORY)lpclf;
    509 }
    510 
    511 
    512 /******************************************************************************
    513  * SHCreateDefClassObject                       [SHELL32.70]
    514  */
    515 HRESULT WINAPI SHCreateDefClassObject(
    516         REFIID  riid,                           
    517         LPVOID* ppv,   
    518         LPFNCREATEINSTANCE lpfnCI,      /* create instance callback entry */
    519         UINT    *pcRefDll,              /* ref count of the dll */
    520         REFIID  riidInst)               /* optional interface to the instance */
    521 {
    522 
    523         char xriid[50],xriidInst[50];
    524         WINE_StringFromCLSID((LPCLSID)riid,xriid);
    525         WINE_StringFromCLSID((LPCLSID)riidInst,xriidInst);
    526 
    527         TRACE("\n\tIID:\t%s %p %p %p \n\tIIDIns:\t%s\n",
    528         xriid, ppv, lpfnCI, pcRefDll, xriidInst);
    529 
    530         if ( IsEqualCLSID(riid, &IID_IClassFactory) )
    531         {
    532           IClassFactory * pcf = IDefClF_fnConstructor(lpfnCI, pcRefDll, riidInst);
    533           if (pcf)
    534           {
    535             *ppv = pcf;
    536             return NOERROR;
    537           }
    538           return E_OUTOFMEMORY;
    539         }
    540         return E_NOINTERFACE;
    541 }
    542 
     530   IDefClFImpl* lpclf;
     531   char  xriidInst[50];
     532
     533   WINE_StringFromCLSID((LPCLSID)riidInst,xriidInst);
     534
     535   lpclf = (IDefClFImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDefClFImpl));
     536   lpclf->ref = 1;
     537   lpclf->lpvtbl = &dclfvt;
     538   lpclf->lpfnCI = lpfnCI;
     539   lpclf->pcRefDll = pcRefDll;
     540
     541   if (pcRefDll)
     542     (*pcRefDll)++;
     543
     544   lpclf->riidInst = riidInst;
     545
     546   dprintf(("SHELL32: IDefClF_fnConstructor (%p)\n\tIID:\t%s\n",lpclf, xriidInst));
     547   shell32_ObjCount++;
     548   return (LPCLASSFACTORY)lpclf;
     549}
     550
     551
     552/******************************************************************************
     553 * SHCreateDefClassObject                      [SHELL32.70]
     554 */
     555
     556ODINFUNCTION5(HRESULT, SHCreateDefClassObject, REFIID,            riid,
     557                                               LPVOID*,           ppv,
     558                                               LPFNCREATEINSTANCE,lpfnCI,
     559                                               UINT*,             pcRefDll,
     560                                               REFIID,            riidInst)
     561{
     562
     563   char xriid[50],xriidInst[50];
     564   WINE_StringFromCLSID((LPCLSID)riid,xriid);
     565   WINE_StringFromCLSID((LPCLSID)riidInst,xriidInst);
     566
     567   dprintf(("SHELL32: SHCreateDefClassObject \n\tIID:\t%s %p %p %p \n\tIIDIns:\t%s\n",
     568   xriid, ppv, lpfnCI, pcRefDll, xriidInst));
     569
     570   if ( IsEqualCLSID(riid, &IID_IClassFactory) )
     571   {
     572     IClassFactory * pcf = IDefClF_fnConstructor(lpfnCI, pcRefDll, riidInst);
     573     if (pcf)
     574     {
     575       *ppv = pcf;
     576       return NOERROR;
     577     }
     578     return E_OUTOFMEMORY;
     579   }
     580   return E_NOINTERFACE;
     581}
     582
Note: See TracChangeset for help on using the changeset viewer.