dlls/shell32/shellole.c

   1 /*
   2  *      handling of SHELL32.DLL OLE-Objects
   3  *
   4  *      Copyright 1997  Marcus Meissner
   5  *      Copyright 1998  Juergen Schmied  <juergen.schmied@metronet.de>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #define COBJMACROS
  29 #define NONAMELESSUNION
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "shellapi.h"
  34 #include "wingdi.h"
  35 #include "winuser.h"
  36 #include "shlobj.h"
  37 #include "shlguid.h"
  38 #include "shldisp.h"
  39 #include "gdiplus.h"
  40 #include "shimgdata.h"
  41 #include "winreg.h"
  42 #include "winerror.h"
  43
  44 #include "undocshell.h"
  45 #include "wine/unicode.h"
  46 #include "shell32_main.h"
  47
  48 #include "wine/debug.h"
  49 #include "shlwapi.h"
  50 #include "debughlp.h"
  51
  52 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  53
  54 extern INT WINAPI SHStringFromGUIDW(REFGUID guid, LPWSTR lpszDest, INT cchMax);  /* shlwapi.24 */
  55 static HRESULT WINAPI ShellImageDataFactory_Constructor(IUnknown *outer, REFIID riid, void **obj);
  56
  57 /**************************************************************************
  58  * Default ClassFactory types
  59  */
  60 typedef HRESULT (CALLBACK *LPFNCREATEINSTANCE)(IUnknown* pUnkOuter, REFIID riid, LPVOID* ppvObject);
  61 static IClassFactory * IDefClF_fnConstructor(LPFNCREATEINSTANCE lpfnCI, PLONG pcRefDll, REFIID riidInst);
  62
  63 /* this table contains all CLSIDs of shell32 objects */
  64 static const struct {
  65         REFIID                  clsid;
  66         LPFNCREATEINSTANCE      lpfnCI;
  67 } InterfaceTable[] = {
  68
  69         {&CLSID_ApplicationAssociationRegistration, ApplicationAssociationRegistration_Constructor},
  70         {&CLSID_AutoComplete,   IAutoComplete_Constructor},
  71         {&CLSID_ControlPanel,   IControlPanel_Constructor},
  72         {&CLSID_DragDropHelper, IDropTargetHelper_Constructor},
  73         {&CLSID_FolderShortcut, FolderShortcut_Constructor},
  74         {&CLSID_MyComputer,     ISF_MyComputer_Constructor},
  75         {&CLSID_MyDocuments,    MyDocuments_Constructor},
  76         {&CLSID_NetworkPlaces,  ISF_NetworkPlaces_Constructor},
  77         {&CLSID_Printers,       Printers_Constructor},
  78         {&CLSID_QueryAssociations, QueryAssociations_Constructor},
  79         {&CLSID_RecycleBin,     RecycleBin_Constructor},
  80         {&CLSID_ShellDesktop,   ISF_Desktop_Constructor},
  81         {&CLSID_ShellFSFolder,  IFSFolder_Constructor},
  82         {&CLSID_ShellItem,      IShellItem_Constructor},
  83         {&CLSID_ShellLink,      IShellLink_Constructor},
  84         {&CLSID_UnixDosFolder,  UnixDosFolder_Constructor},
  85         {&CLSID_UnixFolder,     UnixFolder_Constructor},
  86         {&CLSID_ExplorerBrowser,ExplorerBrowser_Constructor},
  87         {&CLSID_KnownFolderManager, KnownFolderManager_Constructor},
  88         {&CLSID_Shell,          IShellDispatch_Constructor},
  89         {&CLSID_DestinationList, CustomDestinationList_Constructor},
  90         {&CLSID_ShellImageDataFactory, ShellImageDataFactory_Constructor},
  91         {NULL, NULL}
  92 };
  93
  94 /*************************************************************************
  95  * SHCoCreateInstance [SHELL32.102]
  96  *
  97  * Equivalent to CoCreateInstance. Under Windows 9x this function could sometimes
  98  * use the shell32 built-in "mini-COM" without the need to load ole32.dll - see
  99  * SHLoadOLE for details.
 100  *
 101  * Under wine if a "LoadWithoutCOM" value is present or the object resides in
 102  * shell32.dll the function will load the object manually without the help of ole32
 103  *
 104  * NOTES
 105  *     exported by ordinal
 106  *
 107  * SEE ALSO
 108  *     CoCreateInstance, SHLoadOLE
 109  */
 110 HRESULT WINAPI SHCoCreateInstance(
 111         LPCWSTR aclsid,
 112         const CLSID *clsid,
 113         LPUNKNOWN pUnkOuter,
 114         REFIID refiid,
 115         LPVOID *ppv)
 116 {
 117         DWORD   hres;
 118         IID     iid;
 119         const   CLSID * myclsid = clsid;
 120         WCHAR   sKeyName[MAX_PATH];
 121         static const WCHAR sCLSID[] = {'C','L','S','I','D','\\','\0'};
 122         WCHAR   sClassID[60];
 123         static const WCHAR sInProcServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2','\0'};
 124         static const WCHAR sLoadWithoutCOM[] = {'L','o','a','d','W','i','t','h','o','u','t','C','O','M','\0'};
 125         WCHAR   sDllPath[MAX_PATH];
 126         HKEY    hKey = 0;
 127         DWORD   dwSize;
 128         IClassFactory * pcf = NULL;
 129
 130         if(!ppv) return E_POINTER;
 131         *ppv=NULL;
 132
 133         /* if the clsid is a string, convert it */
 134         if (!clsid)
 135         {
 136           if (!aclsid) return REGDB_E_CLASSNOTREG;
 137           SHCLSIDFromStringW(aclsid, &iid);
 138           myclsid = &iid;
 139         }
 140
 141         TRACE("(%p,%s,unk:%p,%s,%p)\n",
 142                 aclsid,shdebugstr_guid(myclsid),pUnkOuter,shdebugstr_guid(refiid),ppv);
 143
 144         if (SUCCEEDED(DllGetClassObject(myclsid, &IID_IClassFactory,(LPVOID*)&pcf)))
 145         {
 146             hres = IClassFactory_CreateInstance(pcf, pUnkOuter, refiid, ppv);
 147             IClassFactory_Release(pcf);
 148             goto end;
 149         }
 150
 151         /* we look up the dll path in the registry */
 152         SHStringFromGUIDW(myclsid, sClassID, sizeof(sClassID)/sizeof(WCHAR));
 153         lstrcpyW(sKeyName, sCLSID);
 154         lstrcatW(sKeyName, sClassID);
 155         lstrcatW(sKeyName, sInProcServer32);
 156
 157         if (RegOpenKeyExW(HKEY_CLASSES_ROOT, sKeyName, 0, KEY_READ, &hKey))
 158             return E_ACCESSDENIED;
 159
 160         /* if a special registry key is set, we load a shell extension without help of OLE32 */
 161         if (!SHQueryValueExW(hKey, sLoadWithoutCOM, 0, 0, 0, 0))
 162         {
 163             /* load an external dll without ole32 */
 164             HANDLE hLibrary;
 165             typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
 166             DllGetClassObjectFunc DllGetClassObject;
 167
 168             dwSize = sizeof(sDllPath);
 169             SHQueryValueExW(hKey, NULL, 0,0, sDllPath, &dwSize );
 170
 171             if ((hLibrary = LoadLibraryExW(sDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH)) == 0) {
 172                 ERR("couldn't load InprocServer32 dll %s\n", debugstr_w(sDllPath));
 173                 hres = E_ACCESSDENIED;
 174                 goto end;
 175             } else if (!(DllGetClassObject = (DllGetClassObjectFunc)GetProcAddress(hLibrary, "DllGetClassObject"))) {
 176                 ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(sDllPath));
 177                 FreeLibrary( hLibrary );
 178                 hres = E_ACCESSDENIED;
 179                 goto end;
 180             } else if (FAILED(hres = DllGetClassObject(myclsid, &IID_IClassFactory, (LPVOID*)&pcf))) {
 181                     TRACE("GetClassObject failed 0x%08x\n", hres);
 182                     goto end;
 183             }
 184
 185             hres = IClassFactory_CreateInstance(pcf, pUnkOuter, refiid, ppv);
 186             IClassFactory_Release(pcf);
 187         } else {
 188
 189             /* load an external dll in the usual way */
 190             hres = CoCreateInstance(myclsid, pUnkOuter, CLSCTX_INPROC_SERVER, refiid, ppv);
 191         }
 192
 193 end:
 194         if (hKey) RegCloseKey(hKey);
 195         if(hres!=S_OK)
 196         {
 197           ERR("failed (0x%08x) to create CLSID:%s IID:%s\n",
 198               hres, shdebugstr_guid(myclsid), shdebugstr_guid(refiid));
 199           ERR("class not found in registry\n");
 200         }
 201
 202         TRACE("-- instance: %p\n",*ppv);
 203         return hres;
 204 }
 205
 206 /*************************************************************************
 207  * DllGetClassObject     [SHELL32.@]
 208  * SHDllGetClassObject   [SHELL32.128]
 209  */
 210 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
 211 {
 212         IClassFactory * pcf = NULL;
 213         HRESULT hres;
 214         int i;
 215
 216         TRACE("CLSID:%s,IID:%s\n",shdebugstr_guid(rclsid),shdebugstr_guid(iid));
 217
 218         if (!ppv) return E_INVALIDARG;
 219         *ppv = NULL;
 220
 221         /* search our internal interface table */
 222         for(i=0;InterfaceTable[i].clsid;i++) {
 223             if(IsEqualIID(InterfaceTable[i].clsid, rclsid)) {
 224                 TRACE("index[%u]\n", i);
 225                 pcf = IDefClF_fnConstructor(InterfaceTable[i].lpfnCI, NULL, NULL);
 226                 break;
 227             }
 228         }
 229
 230         if (!pcf) {
 231             FIXME("failed for CLSID=%s\n", shdebugstr_guid(rclsid));
 232             return CLASS_E_CLASSNOTAVAILABLE;
 233         }
 234
 235         hres = IClassFactory_QueryInterface(pcf, iid, ppv);
 236         IClassFactory_Release(pcf);
 237
 238         TRACE("-- pointer to class factory: %p\n",*ppv);
 239         return hres;
 240 }
 241
 242 /*************************************************************************
 243  * SHCLSIDFromString                            [SHELL32.147]
 244  *
 245  * Under Windows 9x this was an ANSI version of CLSIDFromString. It also allowed
 246  * to avoid dependency on ole32.dll (see SHLoadOLE for details).
 247  *
 248  * Under Windows NT/2000/XP this is equivalent to CLSIDFromString
 249  *
 250  * NOTES
 251  *     exported by ordinal
 252  *
 253  * SEE ALSO
 254  *     CLSIDFromString, SHLoadOLE
 255  */
 256 DWORD WINAPI SHCLSIDFromStringA (LPCSTR clsid, CLSID *id)
 257 {
 258     WCHAR buffer[40];
 259     TRACE("(%p(%s) %p)\n", clsid, clsid, id);
 260     if (!MultiByteToWideChar( CP_ACP, 0, clsid, -1, buffer, sizeof(buffer)/sizeof(WCHAR) ))
 261         return CO_E_CLASSSTRING;
 262     return CLSIDFromString( buffer, id );
 263 }
 264 DWORD WINAPI SHCLSIDFromStringW (LPCWSTR clsid, CLSID *id)
 265 {
 266         TRACE("(%p(%s) %p)\n", clsid, debugstr_w(clsid), id);
 267         return CLSIDFromString(clsid, id);
 268 }
 269 DWORD WINAPI SHCLSIDFromStringAW (LPCVOID clsid, CLSID *id)
 270 {
 271         if (SHELL_OsIsUnicode())
 272           return SHCLSIDFromStringW (clsid, id);
 273         return SHCLSIDFromStringA (clsid, id);
 274 }
 275
 276 /*************************************************************************
 277  *                       SHGetMalloc                    [SHELL32.@]
 278  *
 279  * Equivalent to CoGetMalloc(MEMCTX_TASK, ...). Under Windows 9x this function
 280  * could use the shell32 built-in "mini-COM" without the need to load ole32.dll -
 281  * see SHLoadOLE for details.
 282  *
 283  * PARAMS
 284  *  lpmal [O] Destination for IMalloc interface.
 285  *
 286  * RETURNS
 287  *  Success: S_OK. lpmal contains the shells IMalloc interface.
 288  *  Failure. An HRESULT error code.
 289  *
 290  * SEE ALSO
 291  *  CoGetMalloc, SHLoadOLE
 292  */
 293 HRESULT WINAPI SHGetMalloc(LPMALLOC *lpmal)
 294 {
 295         TRACE("(%p)\n", lpmal);
 296         return CoGetMalloc(MEMCTX_TASK, lpmal);
 297 }
 298
 299 /*************************************************************************
 300  * SHAlloc                                      [SHELL32.196]
 301  *
 302  * Equivalent to CoTaskMemAlloc. Under Windows 9x this function could use
 303  * the shell32 built-in "mini-COM" without the need to load ole32.dll -
 304  * see SHLoadOLE for details.
 305  *
 306  * NOTES
 307  *     exported by ordinal
 308  *
 309  * SEE ALSO
 310  *     CoTaskMemAlloc, SHLoadOLE
 311  */
 312 LPVOID WINAPI SHAlloc(DWORD len)
 313 {
 314         LPVOID ret;
 315
 316         ret = CoTaskMemAlloc(len);
 317         TRACE("%u bytes at %p\n",len, ret);
 318         return ret;
 319 }
 320
 321 /*************************************************************************
 322  * SHFree                                       [SHELL32.195]
 323  *
 324  * Equivalent to CoTaskMemFree. Under Windows 9x this function could use
 325  * the shell32 built-in "mini-COM" without the need to load ole32.dll -
 326  * see SHLoadOLE for details.
 327  *
 328  * NOTES
 329  *     exported by ordinal
 330  *
 331  * SEE ALSO
 332  *     CoTaskMemFree, SHLoadOLE
 333  */
 334 void WINAPI SHFree(LPVOID pv)
 335 {
 336         TRACE("%p\n",pv);
 337         CoTaskMemFree(pv);
 338 }
 339
 340 /*************************************************************************
 341  * SHGetDesktopFolder                   [SHELL32.@]
 342  */
 343 HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
 344 {
 345         HRESULT hres;
 346
 347         TRACE("(%p)\n", psf);
 348
 349         if(!psf) return E_INVALIDARG;
 350
 351         *psf = NULL;
 352         hres = ISF_Desktop_Constructor(NULL, &IID_IShellFolder, (LPVOID*)psf);
 353
 354         TRACE("-- %p->(%p) 0x%08x\n", psf, *psf, hres);
 355         return hres;
 356 }
 357 /**************************************************************************
 358  * Default ClassFactory Implementation
 359  *
 360  * SHCreateDefClassObject
 361  *
 362  * NOTES
 363  *  Helper function for dlls without their own classfactory.
 364  *  A generic classfactory is returned.
 365  *  When the CreateInstance of the cf is called the callback is executed.
 366  */
 367
 368 typedef struct
 369 {
 370     IClassFactory               IClassFactory_iface;
 371     LONG                        ref;
 372     CLSID                       *rclsid;
 373     LPFNCREATEINSTANCE          lpfnCI;
 374     const IID *                 riidInst;
 375     LONG *                      pcRefDll; /* pointer to refcounter in external dll (ugrrr...) */
 376 } IDefClFImpl;
 377
 378 static inline IDefClFImpl *impl_from_IClassFactory(IClassFactory *iface)
 379 {
 380         return CONTAINING_RECORD(iface, IDefClFImpl, IClassFactory_iface);
 381 }
 382
 383 static const IClassFactoryVtbl dclfvt;
 384
 385 /**************************************************************************
 386  *  IDefClF_fnConstructor
 387  */
 388
 389 static IClassFactory * IDefClF_fnConstructor(LPFNCREATEINSTANCE lpfnCI, PLONG pcRefDll, REFIID riidInst)
 390 {
 391         IDefClFImpl* lpclf;
 392
 393         lpclf = HeapAlloc(GetProcessHeap(),0,sizeof(IDefClFImpl));
 394         lpclf->ref = 1;
 395         lpclf->IClassFactory_iface.lpVtbl = &dclfvt;
 396         lpclf->lpfnCI = lpfnCI;
 397         lpclf->pcRefDll = pcRefDll;
 398
 399         if (pcRefDll) InterlockedIncrement(pcRefDll);
 400         lpclf->riidInst = riidInst;
 401
 402         TRACE("(%p)%s\n",lpclf, shdebugstr_guid(riidInst));
 403         return (LPCLASSFACTORY)lpclf;
 404 }
 405 /**************************************************************************
 406  *  IDefClF_fnQueryInterface
 407  */
 408 static HRESULT WINAPI IDefClF_fnQueryInterface(
 409   LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)
 410 {
 411         IDefClFImpl *This = impl_from_IClassFactory(iface);
 412
 413         TRACE("(%p)->(%s)\n",This,shdebugstr_guid(riid));
 414
 415         *ppvObj = NULL;
 416
 417         if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory)) {
 418           *ppvObj = This;
 419           InterlockedIncrement(&This->ref);
 420           return S_OK;
 421         }
 422
 423         TRACE("-- E_NOINTERFACE\n");
 424         return E_NOINTERFACE;
 425 }
 426 /******************************************************************************
 427  * IDefClF_fnAddRef
 428  */
 429 static ULONG WINAPI IDefClF_fnAddRef(LPCLASSFACTORY iface)
 430 {
 431         IDefClFImpl *This = impl_from_IClassFactory(iface);
 432         ULONG refCount = InterlockedIncrement(&This->ref);
 433
 434         TRACE("(%p)->(count=%u)\n", This, refCount - 1);
 435
 436         return refCount;
 437 }
 438 /******************************************************************************
 439  * IDefClF_fnRelease
 440  */
 441 static ULONG WINAPI IDefClF_fnRelease(LPCLASSFACTORY iface)
 442 {
 443         IDefClFImpl *This = impl_from_IClassFactory(iface);
 444         ULONG refCount = InterlockedDecrement(&This->ref);
 445
 446         TRACE("(%p)->(count=%u)\n", This, refCount + 1);
 447
 448         if (!refCount)
 449         {
 450           if (This->pcRefDll) InterlockedDecrement(This->pcRefDll);
 451
 452           TRACE("-- destroying IClassFactory(%p)\n",This);
 453           HeapFree(GetProcessHeap(),0,This);
 454           return 0;
 455         }
 456         return refCount;
 457 }
 458 /******************************************************************************
 459  * IDefClF_fnCreateInstance
 460  */
 461 static HRESULT WINAPI IDefClF_fnCreateInstance(
 462   LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObject)
 463 {
 464         IDefClFImpl *This = impl_from_IClassFactory(iface);
 465
 466         TRACE("%p->(%p,%s,%p)\n",This,pUnkOuter,shdebugstr_guid(riid),ppvObject);
 467
 468         *ppvObject = NULL;
 469
 470         if ( This->riidInst==NULL ||
 471              IsEqualCLSID(riid, This->riidInst) ||
 472              IsEqualCLSID(riid, &IID_IUnknown) )
 473         {
 474           return This->lpfnCI(pUnkOuter, riid, ppvObject);
 475         }
 476
 477         ERR("unknown IID requested %s\n",shdebugstr_guid(riid));
 478         return E_NOINTERFACE;
 479 }
 480 /******************************************************************************
 481  * IDefClF_fnLockServer
 482  */
 483 static HRESULT WINAPI IDefClF_fnLockServer(LPCLASSFACTORY iface, BOOL fLock)
 484 {
 485         IDefClFImpl *This = impl_from_IClassFactory(iface);
 486         TRACE("%p->(0x%x), not implemented\n",This, fLock);
 487         return E_NOTIMPL;
 488 }
 489
 490 static const IClassFactoryVtbl dclfvt =
 491 {
 492     IDefClF_fnQueryInterface,
 493     IDefClF_fnAddRef,
 494   IDefClF_fnRelease,
 495   IDefClF_fnCreateInstance,
 496   IDefClF_fnLockServer
 497 };
 498
 499 /******************************************************************************
 500  * SHCreateDefClassObject                       [SHELL32.70]
 501  */
 502 HRESULT WINAPI SHCreateDefClassObject(
 503         REFIID  riid,
 504         LPVOID* ppv,
 505         LPFNCREATEINSTANCE lpfnCI,      /* [in] create instance callback entry */
 506         LPDWORD pcRefDll,               /* [in/out] ref count of the dll */
 507         REFIID  riidInst)               /* [in] optional interface to the instance */
 508 {
 509         IClassFactory * pcf;
 510
 511         TRACE("%s %p %p %p %s\n",
 512               shdebugstr_guid(riid), ppv, lpfnCI, pcRefDll, shdebugstr_guid(riidInst));
 513
 514         if (! IsEqualCLSID(riid, &IID_IClassFactory) ) return E_NOINTERFACE;
 515         if (! (pcf = IDefClF_fnConstructor(lpfnCI, (PLONG)pcRefDll, riidInst))) return E_OUTOFMEMORY;
 516         *ppv = pcf;
 517         return S_OK;
 518 }
 519
 520 /*************************************************************************
 521  *  DragAcceptFiles             [SHELL32.@]
 522  */
 523 void WINAPI DragAcceptFiles(HWND hWnd, BOOL b)
 524 {
 525         LONG exstyle;
 526
 527         if( !IsWindow(hWnd) ) return;
 528         exstyle = GetWindowLongA(hWnd,GWL_EXSTYLE);
 529         if (b)
 530           exstyle |= WS_EX_ACCEPTFILES;
 531         else
 532           exstyle &= ~WS_EX_ACCEPTFILES;
 533         SetWindowLongA(hWnd,GWL_EXSTYLE,exstyle);
 534 }
 535
 536 /*************************************************************************
 537  * DragFinish           [SHELL32.@]
 538  */
 539 void WINAPI DragFinish(HDROP h)
 540 {
 541         TRACE("\n");
 542         GlobalFree(h);
 543 }
 544
 545 /*************************************************************************
 546  * DragQueryPoint               [SHELL32.@]
 547  */
 548 BOOL WINAPI DragQueryPoint(HDROP hDrop, POINT *p)
 549 {
 550         DROPFILES *lpDropFileStruct;
 551         BOOL bRet;
 552
 553         TRACE("\n");
 554
 555         lpDropFileStruct = GlobalLock(hDrop);
 556
 557         *p = lpDropFileStruct->pt;
 558         bRet = lpDropFileStruct->fNC;
 559
 560         GlobalUnlock(hDrop);
 561         return bRet;
 562 }
 563
 564 /*************************************************************************
 565  *  DragQueryFileA              [SHELL32.@]
 566  *  DragQueryFile               [SHELL32.@]
 567  */
 568 UINT WINAPI DragQueryFileA(
 569         HDROP hDrop,
 570         UINT lFile,
 571         LPSTR lpszFile,
 572         UINT lLength)
 573 {
 574         LPSTR lpDrop;
 575         UINT i = 0;
 576         DROPFILES *lpDropFileStruct = GlobalLock(hDrop);
 577
 578         TRACE("(%p, %x, %p, %u)\n",     hDrop,lFile,lpszFile,lLength);
 579
 580         if(!lpDropFileStruct) goto end;
 581
 582         lpDrop = (LPSTR) lpDropFileStruct + lpDropFileStruct->pFiles;
 583
 584         if(lpDropFileStruct->fWide) {
 585             LPWSTR lpszFileW = NULL;
 586
 587             if(lpszFile && lFile != 0xFFFFFFFF) {
 588                 lpszFileW = HeapAlloc(GetProcessHeap(), 0, lLength*sizeof(WCHAR));
 589                 if(lpszFileW == NULL) {
 590                     goto end;
 591                 }
 592             }
 593             i = DragQueryFileW(hDrop, lFile, lpszFileW, lLength);
 594
 595             if(lpszFileW) {
 596                 WideCharToMultiByte(CP_ACP, 0, lpszFileW, -1, lpszFile, lLength, 0, NULL);
 597                 HeapFree(GetProcessHeap(), 0, lpszFileW);
 598             }
 599             goto end;
 600         }
 601
 602         while (i++ < lFile)
 603         {
 604           while (*lpDrop++); /* skip filename */
 605           if (!*lpDrop)
 606           {
 607             i = (lFile == 0xFFFFFFFF) ? i : 0;
 608             goto end;
 609           }
 610         }
 611
 612         i = strlen(lpDrop);
 613         if (!lpszFile ) goto end;   /* needed buffer size */
 614         lstrcpynA (lpszFile, lpDrop, lLength);
 615 end:
 616         GlobalUnlock(hDrop);
 617         return i;
 618 }
 619
 620 /*************************************************************************
 621  *  DragQueryFileW              [SHELL32.@]
 622  */
 623 UINT WINAPI DragQueryFileW(
 624         HDROP hDrop,
 625         UINT lFile,
 626         LPWSTR lpszwFile,
 627         UINT lLength)
 628 {
 629         LPWSTR lpwDrop;
 630         UINT i = 0;
 631         DROPFILES *lpDropFileStruct = GlobalLock(hDrop);
 632
 633         TRACE("(%p, %x, %p, %u)\n", hDrop,lFile,lpszwFile,lLength);
 634
 635         if(!lpDropFileStruct) goto end;
 636
 637         lpwDrop = (LPWSTR) ((LPSTR)lpDropFileStruct + lpDropFileStruct->pFiles);
 638
 639         if(lpDropFileStruct->fWide == FALSE) {
 640             LPSTR lpszFileA = NULL;
 641
 642             if(lpszwFile && lFile != 0xFFFFFFFF) {
 643                 lpszFileA = HeapAlloc(GetProcessHeap(), 0, lLength);
 644                 if(lpszFileA == NULL) {
 645                     goto end;
 646                 }
 647             }
 648             i = DragQueryFileA(hDrop, lFile, lpszFileA, lLength);
 649
 650             if(lpszFileA) {
 651                 MultiByteToWideChar(CP_ACP, 0, lpszFileA, -1, lpszwFile, lLength);
 652                 HeapFree(GetProcessHeap(), 0, lpszFileA);
 653             }
 654             goto end;
 655         }
 656
 657         i = 0;
 658         while (i++ < lFile)
 659         {
 660           while (*lpwDrop++); /* skip filename */
 661           if (!*lpwDrop)
 662           {
 663             i = (lFile == 0xFFFFFFFF) ? i : 0;
 664             goto end;
 665           }
 666         }
 667
 668         i = strlenW(lpwDrop);
 669         if ( !lpszwFile) goto end;   /* needed buffer size */
 670         lstrcpynW (lpszwFile, lpwDrop, lLength);
 671 end:
 672         GlobalUnlock(hDrop);
 673         return i;
 674 }
 675
 676 /*************************************************************************
 677  *  SHPropStgCreate             [SHELL32.685]
 678  */
 679 HRESULT WINAPI SHPropStgCreate(IPropertySetStorage *psstg, REFFMTID fmtid,
 680         const CLSID *pclsid, DWORD grfFlags, DWORD grfMode,
 681         DWORD dwDisposition, IPropertyStorage **ppstg, UINT *puCodePage)
 682 {
 683     PROPSPEC prop;
 684     PROPVARIANT ret;
 685     HRESULT hres;
 686
 687     TRACE("%p %s %s %x %x %x %p %p\n", psstg, debugstr_guid(fmtid), debugstr_guid(pclsid),
 688             grfFlags, grfMode, dwDisposition, ppstg, puCodePage);
 689
 690     hres = IPropertySetStorage_Open(psstg, fmtid, grfMode, ppstg);
 691
 692     switch(dwDisposition) {
 693     case CREATE_ALWAYS:
 694         if(SUCCEEDED(hres)) {
 695             IPropertyStorage_Release(*ppstg);
 696             hres = IPropertySetStorage_Delete(psstg, fmtid);
 697             if(FAILED(hres))
 698                 return hres;
 699             hres = E_FAIL;
 700         }
 701
 702     case OPEN_ALWAYS:
 703     case CREATE_NEW:
 704         if(FAILED(hres))
 705             hres = IPropertySetStorage_Create(psstg, fmtid, pclsid,
 706                     grfFlags, grfMode, ppstg);
 707
 708     case OPEN_EXISTING:
 709         if(FAILED(hres))
 710             return hres;
 711
 712         if(puCodePage) {
 713             prop.ulKind = PRSPEC_PROPID;
 714             prop.u.propid = PID_CODEPAGE;
 715             hres = IPropertyStorage_ReadMultiple(*ppstg, 1, &prop, &ret);
 716             if(FAILED(hres) || ret.vt!=VT_I2)
 717                 *puCodePage = 0;
 718             else
 719                 *puCodePage = ret.u.iVal;
 720         }
 721     }
 722
 723     return S_OK;
 724 }
 725
 726 /*************************************************************************
 727  *  SHPropStgReadMultiple       [SHELL32.688]
 728  */
 729 HRESULT WINAPI SHPropStgReadMultiple(IPropertyStorage *pps, UINT uCodePage,
 730         ULONG cpspec, const PROPSPEC *rgpspec, PROPVARIANT *rgvar)
 731 {
 732     STATPROPSETSTG stat;
 733     HRESULT hres;
 734
 735     FIXME("%p %u %u %p %p\n", pps, uCodePage, cpspec, rgpspec, rgvar);
 736
 737     memset(rgvar, 0, cpspec*sizeof(PROPVARIANT));
 738     hres = IPropertyStorage_ReadMultiple(pps, cpspec, rgpspec, rgvar);
 739     if(FAILED(hres))
 740         return hres;
 741
 742     if(!uCodePage) {
 743         PROPSPEC prop;
 744         PROPVARIANT ret;
 745
 746         prop.ulKind = PRSPEC_PROPID;
 747         prop.u.propid = PID_CODEPAGE;
 748         hres = IPropertyStorage_ReadMultiple(pps, 1, &prop, &ret);
 749         if(FAILED(hres) || ret.vt!=VT_I2)
 750             return S_OK;
 751
 752         uCodePage = ret.u.iVal;
 753     }
 754
 755     hres = IPropertyStorage_Stat(pps, &stat);
 756     if(FAILED(hres))
 757         return S_OK;
 758
 759     /* TODO: do something with codepage and stat */
 760     return S_OK;
 761 }
 762
 763 /*************************************************************************
 764  *  SHPropStgWriteMultiple      [SHELL32.689]
 765  */
 766 HRESULT WINAPI SHPropStgWriteMultiple(IPropertyStorage *pps, UINT *uCodePage,
 767         ULONG cpspec, const PROPSPEC *rgpspec, PROPVARIANT *rgvar, PROPID propidNameFirst)
 768 {
 769     STATPROPSETSTG stat;
 770     UINT codepage;
 771     HRESULT hres;
 772
 773     FIXME("%p %p %u %p %p %d\n", pps, uCodePage, cpspec, rgpspec, rgvar, propidNameFirst);
 774
 775     hres = IPropertyStorage_Stat(pps, &stat);
 776     if(FAILED(hres))
 777         return hres;
 778
 779     if(uCodePage && *uCodePage)
 780         codepage = *uCodePage;
 781     else {
 782         PROPSPEC prop;
 783         PROPVARIANT ret;
 784
 785         prop.ulKind = PRSPEC_PROPID;
 786         prop.u.propid = PID_CODEPAGE;
 787         hres = IPropertyStorage_ReadMultiple(pps, 1, &prop, &ret);
 788         if(FAILED(hres))
 789             return hres;
 790         if(ret.vt!=VT_I2 || !ret.u.iVal)
 791             return E_FAIL;
 792
 793         codepage = ret.u.iVal;
 794         if(uCodePage)
 795             *uCodePage = codepage;
 796     }
 797
 798     /* TODO: do something with codepage and stat */
 799
 800     hres = IPropertyStorage_WriteMultiple(pps, cpspec, rgpspec, rgvar, propidNameFirst);
 801     return hres;
 802 }
 803
 804 /*************************************************************************
 805  *  SHCreateQueryCancelAutoPlayMoniker [SHELL32.@]
 806  */
 807 HRESULT WINAPI SHCreateQueryCancelAutoPlayMoniker(IMoniker **moniker)
 808 {
 809     TRACE("%p\n", moniker);
 810
 811     if (!moniker) return E_INVALIDARG;
 812     return CreateClassMoniker(&CLSID_QueryCancelAutoPlay, moniker);
 813 }
 814
 815 static HRESULT gpstatus_to_hresult(GpStatus status)
 816 {
 817     switch (status)
 818     {
 819     case Ok:
 820         return S_OK;
 821     case InvalidParameter:
 822         return E_INVALIDARG;
 823     case OutOfMemory:
 824         return E_OUTOFMEMORY;
 825     case NotImplemented:
 826         return E_NOTIMPL;
 827     default:
 828         return E_FAIL;
 829     }
 830 }
 831
 832 /* IShellImageData */
 833 typedef struct
 834 {
 835     IShellImageData IShellImageData_iface;
 836     LONG ref;
 837
 838     WCHAR *path;
 839     GpImage *image;
 840 } ShellImageData;
 841
 842 static inline ShellImageData *impl_from_IShellImageData(IShellImageData *iface)
 843 {
 844     return CONTAINING_RECORD(iface, ShellImageData, IShellImageData_iface);
 845 }
 846
 847 static HRESULT WINAPI ShellImageData_QueryInterface(IShellImageData *iface, REFIID riid, void **obj)
 848 {
 849     ShellImageData *This = impl_from_IShellImageData(iface);
 850
 851     TRACE("%p, %s, %p\n", This, debugstr_guid(riid), obj);
 852
 853     if (IsEqualIID(riid, &IID_IShellImageData) || IsEqualIID(riid, &IID_IUnknown))
 854     {
 855         *obj = &This->IShellImageData_iface;
 856         IShellImageData_AddRef(iface);
 857         return S_OK;
 858     }
 859
 860     *obj = NULL;
 861     return E_NOINTERFACE;
 862 }
 863
 864 static ULONG WINAPI ShellImageData_AddRef(IShellImageData *iface)
 865 {
 866     ShellImageData *This = impl_from_IShellImageData(iface);
 867     ULONG ref = InterlockedIncrement(&This->ref);
 868
 869     TRACE("%p, %u\n", This, ref);
 870
 871     return ref;
 872 }
 873
 874 static ULONG WINAPI ShellImageData_Release(IShellImageData *iface)
 875 {
 876     ShellImageData *This = impl_from_IShellImageData(iface);
 877     ULONG ref = InterlockedDecrement(&This->ref);
 878
 879     TRACE("%p, %u\n", This, ref);
 880
 881     if (!ref)
 882     {
 883         GdipDisposeImage(This->image);
 884         HeapFree(GetProcessHeap(), 0, This->path);
 885         SHFree(This);
 886     }
 887
 888     return ref;
 889 }
 890
 891 static HRESULT WINAPI ShellImageData_Decode(IShellImageData *iface, DWORD flags, ULONG cx_desired, ULONG cy_desired)
 892 {
 893     ShellImageData *This = impl_from_IShellImageData(iface);
 894     GpImage *image;
 895     HRESULT hr;
 896
 897     TRACE("%p, %#x, %u, %u\n", This, flags, cx_desired, cy_desired);
 898
 899     if (This->image)
 900         return S_FALSE;
 901
 902     if (flags & SHIMGDEC_LOADFULL)
 903         FIXME("LOADFULL flag ignored\n");
 904
 905     hr = gpstatus_to_hresult(GdipLoadImageFromFile(This->path, &image));
 906     if (FAILED(hr))
 907         return hr;
 908
 909     if (flags & SHIMGDEC_THUMBNAIL)
 910     {
 911         hr = gpstatus_to_hresult(GdipGetImageThumbnail(image, cx_desired, cy_desired, &This->image, NULL, NULL));
 912         GdipDisposeImage(image);
 913     }
 914     else
 915         This->image = image;
 916
 917     return hr;
 918 }
 919
 920 static HRESULT WINAPI ShellImageData_Draw(IShellImageData *iface, HDC hdc, RECT *dest, RECT *src)
 921 {
 922     ShellImageData *This = impl_from_IShellImageData(iface);
 923     GpGraphics *graphics;
 924     HRESULT hr;
 925
 926     TRACE("%p, %p, %s, %s\n", This, hdc, wine_dbgstr_rect(dest), wine_dbgstr_rect(src));
 927
 928     if (!This->image)
 929         return E_FAIL;
 930
 931     if (!dest)
 932         return E_INVALIDARG;
 933
 934     if (!src)
 935         return S_OK;
 936
 937     hr = gpstatus_to_hresult(GdipCreateFromHDC(hdc, &graphics));
 938     if (FAILED(hr))
 939         return hr;
 940
 941     hr = gpstatus_to_hresult(GdipDrawImageRectRectI(graphics, This->image, dest->left, dest->top, dest->right - dest->left,
 942         dest->bottom - dest->top, src->left, src->top, src->right - src->left, src->bottom - src->top,
 943         UnitPixel, NULL, NULL, NULL));
 944     GdipDeleteGraphics(graphics);
 945
 946     return hr;
 947 }
 948
 949 static HRESULT WINAPI ShellImageData_NextFrame(IShellImageData *iface)
 950 {
 951     ShellImageData *This = impl_from_IShellImageData(iface);
 952
 953     FIXME("%p: stub\n", This);
 954
 955     return E_NOTIMPL;
 956 }
 957
 958 static HRESULT WINAPI ShellImageData_NextPage(IShellImageData *iface)
 959 {
 960     ShellImageData *This = impl_from_IShellImageData(iface);
 961
 962     FIXME("%p: stub\n", This);
 963
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI ShellImageData_PrevPage(IShellImageData *iface)
 968 {
 969     ShellImageData *This = impl_from_IShellImageData(iface);
 970
 971     FIXME("%p: stub\n", This);
 972
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI ShellImageData_IsTransparent(IShellImageData *iface)
 977 {
 978     ShellImageData *This = impl_from_IShellImageData(iface);
 979
 980     FIXME("%p: stub\n", This);
 981
 982     return E_NOTIMPL;
 983 }
 984
 985 static HRESULT WINAPI ShellImageData_IsAnimated(IShellImageData *iface)
 986 {
 987     ShellImageData *This = impl_from_IShellImageData(iface);
 988
 989     FIXME("%p: stub\n", This);
 990
 991     return E_NOTIMPL;
 992 }
 993
 994 static HRESULT WINAPI ShellImageData_IsVector(IShellImageData *iface)
 995 {
 996     ShellImageData *This = impl_from_IShellImageData(iface);
 997
 998     FIXME("%p: stub\n", This);
 999
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI ShellImageData_IsMultipage(IShellImageData *iface)
1004 {
1005     ShellImageData *This = impl_from_IShellImageData(iface);
1006
1007     FIXME("%p: stub\n", This);
1008
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI ShellImageData_IsEditable(IShellImageData *iface)
1013 {
1014     ShellImageData *This = impl_from_IShellImageData(iface);
1015
1016     FIXME("%p: stub\n", This);
1017
1018     return E_NOTIMPL;
1019 }
1020
1021 static HRESULT WINAPI ShellImageData_IsPrintable(IShellImageData *iface)
1022 {
1023     ShellImageData *This = impl_from_IShellImageData(iface);
1024
1025     FIXME("%p: stub\n", This);
1026
1027     return E_NOTIMPL;
1028 }
1029
1030 static HRESULT WINAPI ShellImageData_IsDecoded(IShellImageData *iface)
1031 {
1032     ShellImageData *This = impl_from_IShellImageData(iface);
1033
1034     FIXME("%p: stub\n", This);
1035
1036     return E_NOTIMPL;
1037 }
1038
1039 static HRESULT WINAPI ShellImageData_GetCurrentPage(IShellImageData *iface, ULONG *page)
1040 {
1041     ShellImageData *This = impl_from_IShellImageData(iface);
1042
1043     FIXME("%p: stub\n", This);
1044
1045     return E_NOTIMPL;
1046 }
1047
1048 static HRESULT WINAPI ShellImageData_GetPageCount(IShellImageData *iface, ULONG *count)
1049 {
1050     ShellImageData *This = impl_from_IShellImageData(iface);
1051
1052     FIXME("%p, %p: stub\n", This, count);
1053
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI ShellImageDate_SelectPage(IShellImageData *iface, ULONG page)
1058 {
1059     ShellImageData *This = impl_from_IShellImageData(iface);
1060
1061     FIXME("%p, %u: stub\n", This, page);
1062
1063     return E_NOTIMPL;
1064 }
1065
1066 static HRESULT WINAPI ShellImageData_GetSize(IShellImageData *iface, SIZE *size)
1067 {
1068     ShellImageData *This = impl_from_IShellImageData(iface);
1069     REAL cx, cy;
1070     HRESULT hr;
1071
1072     TRACE("%p, %p\n", This, size);
1073
1074     if (!This->image)
1075         return E_FAIL;
1076
1077     hr = gpstatus_to_hresult(GdipGetImageDimension(This->image, &cx, &cy));
1078     if (SUCCEEDED(hr))
1079     {
1080         size->cx = cx;
1081         size->cy = cy;
1082     }
1083
1084     return hr;
1085 }
1086
1087 static HRESULT WINAPI ShellImageData_GetRawDataFormat(IShellImageData *iface, GUID *format)
1088 {
1089     ShellImageData *This = impl_from_IShellImageData(iface);
1090
1091     FIXME("%p, %p: stub\n", This, format);
1092
1093     return E_NOTIMPL;
1094 }
1095
1096 static HRESULT WINAPI ShellImageData_GetPixelFormat(IShellImageData *iface, PixelFormat *format)
1097 {
1098     ShellImageData *This = impl_from_IShellImageData(iface);
1099
1100     FIXME("%p, %p: stub\n", This, format);
1101
1102     return E_NOTIMPL;
1103 }
1104
1105 static HRESULT WINAPI ShellImageData_GetDelay(IShellImageData *iface, DWORD *delay)
1106 {
1107     ShellImageData *This = impl_from_IShellImageData(iface);
1108
1109     FIXME("%p, %p: stub\n", This, delay);
1110
1111     return E_NOTIMPL;
1112 }
1113
1114 static HRESULT WINAPI ShellImageData_GetProperties(IShellImageData *iface, DWORD mode, IPropertySetStorage **props)
1115 {
1116     ShellImageData *This = impl_from_IShellImageData(iface);
1117
1118     FIXME("%p, %#x, %p: stub\n", This, mode, props);
1119
1120     return E_NOTIMPL;
1121 }
1122
1123 static HRESULT WINAPI ShellImageData_Rotate(IShellImageData *iface, DWORD angle)
1124 {
1125     ShellImageData *This = impl_from_IShellImageData(iface);
1126
1127     FIXME("%p, %u: stub\n", This, angle);
1128
1129     return E_NOTIMPL;
1130 }
1131
1132 static HRESULT WINAPI ShellImageData_Scale(IShellImageData *iface, ULONG cx, ULONG cy, InterpolationMode mode)
1133 {
1134     ShellImageData *This = impl_from_IShellImageData(iface);
1135
1136     FIXME("%p, %u, %u, %#x: stub\n", This, cx, cy, mode);
1137
1138     return E_NOTIMPL;
1139 }
1140
1141 static HRESULT WINAPI ShellImageData_DiscardEdit(IShellImageData *iface)
1142 {
1143     ShellImageData *This = impl_from_IShellImageData(iface);
1144
1145     FIXME("%p: stub\n", This);
1146
1147     return E_NOTIMPL;
1148 }
1149
1150 static HRESULT WINAPI ShellImageDate_SetEncoderParams(IShellImageData *iface, IPropertyBag *params)
1151 {
1152     ShellImageData *This = impl_from_IShellImageData(iface);
1153
1154     FIXME("%p, %p: stub\n", This, params);
1155
1156     return E_NOTIMPL;
1157 }
1158
1159 static HRESULT WINAPI ShellImageData_DisplayName(IShellImageData *iface, LPWSTR name, UINT count)
1160 {
1161     ShellImageData *This = impl_from_IShellImageData(iface);
1162
1163     FIXME("%p, %p, %u: stub\n", This, name, count);
1164
1165     return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI ShellImageData_GetResolution(IShellImageData *iface, ULONG *res_x, ULONG *res_y)
1169 {
1170     ShellImageData *This = impl_from_IShellImageData(iface);
1171
1172     FIXME("%p, %p, %p: stub\n", This, res_x, res_y);
1173
1174     return E_NOTIMPL;
1175 }
1176
1177 static HRESULT WINAPI ShellImageData_GetEncoderParams(IShellImageData *iface, GUID *format, EncoderParameters **params)
1178 {
1179     ShellImageData *This = impl_from_IShellImageData(iface);
1180
1181     FIXME("%p, %p, %p: stub\n", This, format, params);
1182
1183     return E_NOTIMPL;
1184 }
1185
1186 static HRESULT WINAPI ShellImageData_RegisterAbort(IShellImageData *iface, IShellImageDataAbort *abort,
1187     IShellImageDataAbort **prev)
1188 {
1189     ShellImageData *This = impl_from_IShellImageData(iface);
1190
1191     FIXME("%p, %p, %p: stub\n", This, abort, prev);
1192
1193     return E_NOTIMPL;
1194 }
1195
1196 static HRESULT WINAPI ShellImageData_CloneFrame(IShellImageData *iface, Image **frame)
1197 {
1198     ShellImageData *This = impl_from_IShellImageData(iface);
1199
1200     FIXME("%p, %p: stub\n", This, frame);
1201
1202     return E_NOTIMPL;
1203 }
1204
1205 static HRESULT WINAPI ShellImageData_ReplaceFrame(IShellImageData *iface, Image *frame)
1206 {
1207     ShellImageData *This = impl_from_IShellImageData(iface);
1208
1209     FIXME("%p, %p: stub\n", This, frame);
1210
1211     return E_NOTIMPL;
1212 }
1213
1214 static const IShellImageDataVtbl ShellImageDataVtbl =
1215 {
1216     ShellImageData_QueryInterface,
1217     ShellImageData_AddRef,
1218     ShellImageData_Release,
1219     ShellImageData_Decode,
1220     ShellImageData_Draw,
1221     ShellImageData_NextFrame,
1222     ShellImageData_NextPage,
1223     ShellImageData_PrevPage,
1224     ShellImageData_IsTransparent,
1225     ShellImageData_IsAnimated,
1226     ShellImageData_IsVector,
1227     ShellImageData_IsMultipage,
1228     ShellImageData_IsEditable,
1229     ShellImageData_IsPrintable,
1230     ShellImageData_IsDecoded,
1231     ShellImageData_GetCurrentPage,
1232     ShellImageData_GetPageCount,
1233     ShellImageDate_SelectPage,
1234     ShellImageData_GetSize,
1235     ShellImageData_GetRawDataFormat,
1236     ShellImageData_GetPixelFormat,
1237     ShellImageData_GetDelay,
1238     ShellImageData_GetProperties,
1239     ShellImageData_Rotate,
1240     ShellImageData_Scale,
1241     ShellImageData_DiscardEdit,
1242     ShellImageDate_SetEncoderParams,
1243     ShellImageData_DisplayName,
1244     ShellImageData_GetResolution,
1245     ShellImageData_GetEncoderParams,
1246     ShellImageData_RegisterAbort,
1247     ShellImageData_CloneFrame,
1248     ShellImageData_ReplaceFrame,
1249 };
1250
1251 static HRESULT create_shellimagedata_from_path(const WCHAR *path, IShellImageData **data)
1252 {
1253     ShellImageData *This;
1254
1255     This = SHAlloc(sizeof(*This));
1256
1257     This->IShellImageData_iface.lpVtbl = &ShellImageDataVtbl;
1258     This->ref = 1;
1259
1260     This->path = strdupW(path);
1261     This->image = NULL;
1262
1263     *data = &This->IShellImageData_iface;
1264     return S_OK;
1265 }
1266
1267 /* IShellImageDataFactory */
1268 static HRESULT WINAPI ShellImageDataFactory_QueryInterface(IShellImageDataFactory *iface, REFIID riid, void **obj)
1269 {
1270     TRACE("(%p, %s, %p)\n", iface, debugstr_guid(riid), obj);
1271
1272     if (IsEqualIID(&IID_IShellImageDataFactory, riid) || IsEqualIID(&IID_IUnknown, riid))
1273     {
1274         *obj = iface;
1275     }
1276     else
1277     {
1278         FIXME("not implemented for %s\n", debugstr_guid(riid));
1279         *obj = NULL;
1280         return E_NOINTERFACE;
1281     }
1282
1283     IUnknown_AddRef((IUnknown*)*obj);
1284     return S_OK;
1285 }
1286
1287 static ULONG WINAPI ShellImageDataFactory_AddRef(IShellImageDataFactory *iface)
1288 {
1289     TRACE("(%p)\n", iface);
1290
1291     return 2;
1292 }
1293
1294 static ULONG WINAPI ShellImageDataFactory_Release(IShellImageDataFactory *iface)
1295 {
1296     TRACE("(%p)\n", iface);
1297
1298     return 1;
1299 }
1300
1301 static HRESULT WINAPI ShellImageDataFactory_CreateIShellImageData(IShellImageDataFactory *iface, IShellImageData **data)
1302 {
1303     FIXME("%p, %p: stub\n", iface, data);
1304
1305     return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI ShellImageDataFactory_CreateImageFromFile(IShellImageDataFactory *iface, const WCHAR *path,
1309     IShellImageData **data)
1310 {
1311     TRACE("%p, %s, %p\n", iface, debugstr_w(path), data);
1312
1313     return create_shellimagedata_from_path(path, data);
1314 }
1315
1316 static HRESULT WINAPI ShellImageDataFactory_CreateImageFromStream(IShellImageDataFactory *iface, IStream *stream,
1317     IShellImageData **data)
1318 {
1319     FIXME("%p, %p, %p: stub\n", iface, stream, data);
1320
1321     return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI ShellImageDataFactory_GetDataFormatFromPath(IShellImageDataFactory *iface, const WCHAR *path,
1325     GUID *format)
1326 {
1327     FIXME("%p, %s, %p: stub\n", iface, debugstr_w(path), format);
1328
1329     return E_NOTIMPL;
1330 }
1331
1332 static const IShellImageDataFactoryVtbl ShellImageDataFactoryVtbl =
1333 {
1334     ShellImageDataFactory_QueryInterface,
1335     ShellImageDataFactory_AddRef,
1336     ShellImageDataFactory_Release,
1337     ShellImageDataFactory_CreateIShellImageData,
1338     ShellImageDataFactory_CreateImageFromFile,
1339     ShellImageDataFactory_CreateImageFromStream,
1340     ShellImageDataFactory_GetDataFormatFromPath,
1341 };
1342
1343 static IShellImageDataFactory ShellImageDataFactory = { &ShellImageDataFactoryVtbl };
1344
1345 HRESULT WINAPI ShellImageDataFactory_Constructor(IUnknown *outer, REFIID riid, void **obj)
1346 {
1347     TRACE("%p %s %p\n", outer, debugstr_guid(riid), obj);
1348
1349     if (outer)
1350         return CLASS_E_NOAGGREGATION;
1351
1352     return IShellImageDataFactory_QueryInterface(&ShellImageDataFactory, riid, obj);
1353 }