git.oblomov.eu Git - wine/blob - dlls/scrrun/filesystem.c

   1 /*
   2  * Copyright 2012 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "config.h"
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "ole2.h"
  27 #include "olectl.h"
  28 #include "dispex.h"
  29 #include "scrrun.h"
  30 #include "scrrun_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(scrrun);
  35
  36 struct folder {
  37     IFolder IFolder_iface;
  38     LONG ref;
  39 };
  40
  41 static inline struct folder *impl_from_IFolder(IFolder *iface)
  42 {
  43     return CONTAINING_RECORD(iface, struct folder, IFolder_iface);
  44 }
  45
  46 static HRESULT WINAPI folder_QueryInterface(IFolder *iface, REFIID riid, void **obj)
  47 {
  48     struct folder *This = impl_from_IFolder(iface);
  49
  50     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
  51
  52     *obj = NULL;
  53
  54     if (IsEqualGUID( riid, &IID_IFolder ) ||
  55         IsEqualGUID( riid, &IID_IUnknown))
  56     {
  57         *obj = iface;
  58         IFolder_AddRef(iface);
  59     }
  60     else
  61         return E_NOINTERFACE;
  62
  63     return S_OK;
  64 }
  65
  66 static ULONG WINAPI folder_AddRef(IFolder *iface)
  67 {
  68     struct folder *This = impl_from_IFolder(iface);
  69     ULONG ref = InterlockedIncrement(&This->ref);
  70     TRACE("(%p)->(%d)\n", This, ref);
  71     return ref;
  72 }
  73
  74 static ULONG WINAPI folder_Release(IFolder *iface)
  75 {
  76     struct folder *This = impl_from_IFolder(iface);
  77     ULONG ref = InterlockedDecrement(&This->ref);
  78     TRACE("(%p)->(%d)\n", This, ref);
  79
  80     if (!ref)
  81         heap_free(This);
  82
  83     return ref;
  84 }
  85
  86 static HRESULT WINAPI folder_GetTypeInfoCount(IFolder *iface, UINT *pctinfo)
  87 {
  88     struct folder *This = impl_from_IFolder(iface);
  89     TRACE("(%p)->(%p)\n", This, pctinfo);
  90     *pctinfo = 1;
  91     return S_OK;
  92 }
  93
  94 static HRESULT WINAPI folder_GetTypeInfo(IFolder *iface, UINT iTInfo,
  95                                         LCID lcid, ITypeInfo **ppTInfo)
  96 {
  97     struct folder *This = impl_from_IFolder(iface);
  98     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
  99     return get_typeinfo(IFolder_tid, ppTInfo);
 100 }
 101
 102 static HRESULT WINAPI folder_GetIDsOfNames(IFolder *iface, REFIID riid,
 103                                         LPOLESTR *rgszNames, UINT cNames,
 104                                         LCID lcid, DISPID *rgDispId)
 105 {
 106     struct folder *This = impl_from_IFolder(iface);
 107     ITypeInfo *typeinfo;
 108     HRESULT hr;
 109
 110     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 111
 112     hr = get_typeinfo(IFolder_tid, &typeinfo);
 113     if(SUCCEEDED(hr))
 114     {
 115         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 116         ITypeInfo_Release(typeinfo);
 117     }
 118
 119     return hr;
 120 }
 121
 122 static HRESULT WINAPI folder_Invoke(IFolder *iface, DISPID dispIdMember,
 123                                       REFIID riid, LCID lcid, WORD wFlags,
 124                                       DISPPARAMS *pDispParams, VARIANT *pVarResult,
 125                                       EXCEPINFO *pExcepInfo, UINT *puArgErr)
 126 {
 127     struct folder *This = impl_from_IFolder(iface);
 128     ITypeInfo *typeinfo;
 129     HRESULT hr;
 130
 131     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 132            lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 133
 134     hr = get_typeinfo(IFolder_tid, &typeinfo);
 135     if(SUCCEEDED(hr))
 136     {
 137         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
 138                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 139         ITypeInfo_Release(typeinfo);
 140     }
 141
 142     return hr;
 143 }
 144
 145 static HRESULT WINAPI folder_get_Path(IFolder *iface, BSTR *path)
 146 {
 147     struct folder *This = impl_from_IFolder(iface);
 148     FIXME("(%p)->(%p): stub\n", This, path);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI folder_get_Name(IFolder *iface, BSTR *name)
 153 {
 154     struct folder *This = impl_from_IFolder(iface);
 155     FIXME("(%p)->(%p): stub\n", This, name);
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI folder_put_Name(IFolder *iface, BSTR name)
 160 {
 161     struct folder *This = impl_from_IFolder(iface);
 162     FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI folder_get_ShortPath(IFolder *iface, BSTR *path)
 167 {
 168     struct folder *This = impl_from_IFolder(iface);
 169     FIXME("(%p)->(%p): stub\n", This, path);
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI folder_get_ShortName(IFolder *iface, BSTR *name)
 174 {
 175     struct folder *This = impl_from_IFolder(iface);
 176     FIXME("(%p)->(%p): stub\n", This, name);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI folder_get_Drive(IFolder *iface, IDrive **drive)
 181 {
 182     struct folder *This = impl_from_IFolder(iface);
 183     FIXME("(%p)->(%p): stub\n", This, drive);
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI folder_get_ParentFolder(IFolder *iface, IFolder **parent)
 188 {
 189     struct folder *This = impl_from_IFolder(iface);
 190     FIXME("(%p)->(%p): stub\n", This, parent);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI folder_get_Attributes(IFolder *iface, FileAttribute *attr)
 195 {
 196     struct folder *This = impl_from_IFolder(iface);
 197     FIXME("(%p)->(%p): stub\n", This, attr);
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI folder_put_Attributes(IFolder *iface, FileAttribute attr)
 202 {
 203     struct folder *This = impl_from_IFolder(iface);
 204     FIXME("(%p)->(0x%x): stub\n", This, attr);
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI folder_get_DateCreated(IFolder *iface, DATE *date)
 209 {
 210     struct folder *This = impl_from_IFolder(iface);
 211     FIXME("(%p)->(%p): stub\n", This, date);
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI folder_get_DateLastModified(IFolder *iface, DATE *date)
 216 {
 217     struct folder *This = impl_from_IFolder(iface);
 218     FIXME("(%p)->(%p): stub\n", This, date);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI folder_get_DateLastAccessed(IFolder *iface, DATE *date)
 223 {
 224     struct folder *This = impl_from_IFolder(iface);
 225     FIXME("(%p)->(%p): stub\n", This, date);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI folder_get_Type(IFolder *iface, BSTR *type)
 230 {
 231     struct folder *This = impl_from_IFolder(iface);
 232     FIXME("(%p)->(%p): stub\n", This, type);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI folder_Delete(IFolder *iface, VARIANT_BOOL force)
 237 {
 238     struct folder *This = impl_from_IFolder(iface);
 239     FIXME("(%p)->(%x): stub\n", This, force);
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI folder_Copy(IFolder *iface, BSTR dest, VARIANT_BOOL overwrite)
 244 {
 245     struct folder *This = impl_from_IFolder(iface);
 246     FIXME("(%p)->(%s %x): stub\n", This, debugstr_w(dest), overwrite);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI folder_Move(IFolder *iface, BSTR dest)
 251 {
 252     struct folder *This = impl_from_IFolder(iface);
 253     FIXME("(%p)->(%s): stub\n", This, debugstr_w(dest));
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI folder_get_IsRootFolder(IFolder *iface, VARIANT_BOOL *isroot)
 258 {
 259     struct folder *This = impl_from_IFolder(iface);
 260     FIXME("(%p)->(%p): stub\n", This, isroot);
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI folder_get_Size(IFolder *iface, VARIANT *size)
 265 {
 266     struct folder *This = impl_from_IFolder(iface);
 267     FIXME("(%p)->(%p): stub\n", This, size);
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI folder_get_SubFolders(IFolder *iface, IFolderCollection **folders)
 272 {
 273     struct folder *This = impl_from_IFolder(iface);
 274     FIXME("(%p)->(%p): stub\n", This, folders);
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI folder_get_Files(IFolder *iface, IFileCollection **files)
 279 {
 280     struct folder *This = impl_from_IFolder(iface);
 281     FIXME("(%p)->(%p): stub\n", This, files);
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI folder_CreateTextFile(IFolder *iface, BSTR filename, VARIANT_BOOL overwrite,
 286     VARIANT_BOOL unicode, ITextStream **stream)
 287 {
 288     struct folder *This = impl_from_IFolder(iface);
 289     FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream);
 290     return E_NOTIMPL;
 291 }
 292
 293 static const IFolderVtbl foldervtbl = {
 294     folder_QueryInterface,
 295     folder_AddRef,
 296     folder_Release,
 297     folder_GetTypeInfoCount,
 298     folder_GetTypeInfo,
 299     folder_GetIDsOfNames,
 300     folder_Invoke,
 301     folder_get_Path,
 302     folder_get_Name,
 303     folder_put_Name,
 304     folder_get_ShortPath,
 305     folder_get_ShortName,
 306     folder_get_Drive,
 307     folder_get_ParentFolder,
 308     folder_get_Attributes,
 309     folder_put_Attributes,
 310     folder_get_DateCreated,
 311     folder_get_DateLastModified,
 312     folder_get_DateLastAccessed,
 313     folder_get_Type,
 314     folder_Delete,
 315     folder_Copy,
 316     folder_Move,
 317     folder_get_IsRootFolder,
 318     folder_get_Size,
 319     folder_get_SubFolders,
 320     folder_get_Files,
 321     folder_CreateTextFile
 322 };
 323
 324 static HRESULT create_folder(IFolder **folder)
 325 {
 326     struct folder *This;
 327
 328     This = heap_alloc(sizeof(struct folder));
 329     if (!This) return E_OUTOFMEMORY;
 330
 331     This->IFolder_iface.lpVtbl = &foldervtbl;
 332     This->ref = 1;
 333
 334     *folder = &This->IFolder_iface;
 335
 336     return S_OK;
 337 }
 338
 339 static HRESULT WINAPI filesys_QueryInterface(IFileSystem3 *iface, REFIID riid, void **ppvObject)
 340 {
 341     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 342
 343     if ( IsEqualGUID( riid, &IID_IFileSystem3 ) ||
 344          IsEqualGUID( riid, &IID_IFileSystem ) ||
 345          IsEqualGUID( riid, &IID_IDispatch ) ||
 346          IsEqualGUID( riid, &IID_IUnknown ) )
 347     {
 348         *ppvObject = iface;
 349     }
 350     else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
 351     {
 352         TRACE("Interface IDispatchEx not supported - returning NULL\n");
 353         *ppvObject = NULL;
 354         return E_NOINTERFACE;
 355     }
 356     else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
 357     {
 358         TRACE("Interface IObjectWithSite not supported - returning NULL\n");
 359         *ppvObject = NULL;
 360         return E_NOINTERFACE;
 361     }
 362     else
 363     {
 364         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 365         return E_NOINTERFACE;
 366     }
 367
 368     IFileSystem3_AddRef(iface);
 369
 370     return S_OK;
 371 }
 372
 373 static ULONG WINAPI filesys_AddRef(IFileSystem3 *iface)
 374 {
 375     TRACE("%p\n", iface);
 376
 377     return 2;
 378 }
 379
 380 static ULONG WINAPI filesys_Release(IFileSystem3 *iface)
 381 {
 382     TRACE("%p\n", iface);
 383
 384     return 1;
 385 }
 386
 387 static HRESULT WINAPI filesys_GetTypeInfoCount(IFileSystem3 *iface, UINT *pctinfo)
 388 {
 389     TRACE("(%p)->(%p)\n", iface, pctinfo);
 390
 391     *pctinfo = 1;
 392     return S_OK;
 393 }
 394
 395 static HRESULT WINAPI filesys_GetTypeInfo(IFileSystem3 *iface, UINT iTInfo,
 396                                         LCID lcid, ITypeInfo **ppTInfo)
 397 {
 398     TRACE("(%p)->(%u %u %p)\n", iface, iTInfo, lcid, ppTInfo);
 399     return get_typeinfo(IFileSystem3_tid, ppTInfo);
 400 }
 401
 402 static HRESULT WINAPI filesys_GetIDsOfNames(IFileSystem3 *iface, REFIID riid,
 403                                         LPOLESTR *rgszNames, UINT cNames,
 404                                         LCID lcid, DISPID *rgDispId)
 405 {
 406     ITypeInfo *typeinfo;
 407     HRESULT hr;
 408
 409     TRACE("(%p)->(%s %p %u %u %p)\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 410
 411     hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
 412     if(SUCCEEDED(hr))
 413     {
 414         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 415         ITypeInfo_Release(typeinfo);
 416     }
 417
 418     return hr;
 419 }
 420
 421 static HRESULT WINAPI filesys_Invoke(IFileSystem3 *iface, DISPID dispIdMember,
 422                                       REFIID riid, LCID lcid, WORD wFlags,
 423                                       DISPPARAMS *pDispParams, VARIANT *pVarResult,
 424                                       EXCEPINFO *pExcepInfo, UINT *puArgErr)
 425 {
 426     ITypeInfo *typeinfo;
 427     HRESULT hr;
 428
 429     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", iface, dispIdMember, debugstr_guid(riid),
 430            lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 431
 432     hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
 433     if(SUCCEEDED(hr))
 434     {
 435         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
 436                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 437         ITypeInfo_Release(typeinfo);
 438     }
 439
 440     return hr;
 441 }
 442
 443 static HRESULT WINAPI filesys_get_Drives(IFileSystem3 *iface, IDriveCollection **ppdrives)
 444 {
 445     FIXME("%p %p\n", iface, ppdrives);
 446
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI filesys_BuildPath(IFileSystem3 *iface, BSTR Path,
 451                                             BSTR Name, BSTR *pbstrResult)
 452 {
 453     FIXME("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), pbstrResult);
 454
 455     return E_NOTIMPL;
 456 }
 457
 458 static HRESULT WINAPI filesys_GetDriveName(IFileSystem3 *iface, BSTR Path,
 459                                             BSTR *pbstrResult)
 460 {
 461     FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 462
 463     return E_NOTIMPL;
 464 }
 465
 466 static HRESULT WINAPI filesys_GetParentFolderName(IFileSystem3 *iface, BSTR Path,
 467                                             BSTR *pbstrResult)
 468 {
 469     FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 470
 471     return E_NOTIMPL;
 472 }
 473
 474 static HRESULT WINAPI filesys_GetFileName(IFileSystem3 *iface, BSTR Path,
 475                                             BSTR *pbstrResult)
 476 {
 477     FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 478
 479     return E_NOTIMPL;
 480 }
 481
 482 static HRESULT WINAPI filesys_GetBaseName(IFileSystem3 *iface, BSTR Path,
 483                                             BSTR *pbstrResult)
 484 {
 485     FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 486
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI filesys_GetExtensionName(IFileSystem3 *iface, BSTR Path,
 491                                             BSTR *pbstrResult)
 492 {
 493     FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 494
 495     return E_NOTIMPL;
 496 }
 497
 498 static HRESULT WINAPI filesys_GetAbsolutePathName(IFileSystem3 *iface, BSTR Path,
 499                                             BSTR *pbstrResult)
 500 {
 501     FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
 502
 503     return E_NOTIMPL;
 504 }
 505
 506 static HRESULT WINAPI filesys_GetTempName(IFileSystem3 *iface, BSTR *pbstrResult)
 507 {
 508     FIXME("%p %p\n", iface, pbstrResult);
 509
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT WINAPI filesys_DriveExists(IFileSystem3 *iface, BSTR DriveSpec,
 514                                             VARIANT_BOOL *pfExists)
 515 {
 516     FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), pfExists);
 517
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI filesys_FileExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
 522 {
 523     DWORD attrs;
 524     TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
 525
 526     if (!ret) return E_POINTER;
 527
 528     attrs = GetFileAttributesW(path);
 529     *ret = attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
 530     return S_OK;
 531 }
 532
 533 static HRESULT WINAPI filesys_FolderExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
 534 {
 535     DWORD attrs;
 536     TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
 537
 538     if (!ret) return E_POINTER;
 539
 540     attrs = GetFileAttributesW(path);
 541     *ret = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
 542
 543     return S_OK;
 544 }
 545
 546 static HRESULT WINAPI filesys_GetDrive(IFileSystem3 *iface, BSTR DriveSpec,
 547                                             IDrive **ppdrive)
 548 {
 549     FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), ppdrive);
 550
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI filesys_GetFile(IFileSystem3 *iface, BSTR FilePath,
 555                                             IFile **ppfile)
 556 {
 557     FIXME("%p %s %p\n", iface, debugstr_w(FilePath), ppfile);
 558
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI filesys_GetFolder(IFileSystem3 *iface, BSTR FolderPath,
 563                                             IFolder **ppfolder)
 564 {
 565     FIXME("%p %s %p\n", iface, debugstr_w(FolderPath), ppfolder);
 566
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI filesys_GetSpecialFolder(IFileSystem3 *iface,
 571                                             SpecialFolderConst SpecialFolder,
 572                                             IFolder **ppfolder)
 573 {
 574     FIXME("%p %d %p\n", iface, SpecialFolder, ppfolder);
 575
 576     return E_NOTIMPL;
 577 }
 578
 579 static HRESULT WINAPI filesys_DeleteFile(IFileSystem3 *iface, BSTR FileSpec,
 580                                             VARIANT_BOOL Force)
 581 {
 582     FIXME("%p %s %d\n", iface, debugstr_w(FileSpec), Force);
 583
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI filesys_DeleteFolder(IFileSystem3 *iface, BSTR FolderSpec,
 588                                             VARIANT_BOOL Force)
 589 {
 590     FIXME("%p %s %d\n", iface, debugstr_w(FolderSpec), Force);
 591
 592     return E_NOTIMPL;
 593 }
 594
 595 static HRESULT WINAPI filesys_MoveFile(IFileSystem3 *iface, BSTR Source,
 596                                             BSTR Destination)
 597 {
 598     FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
 599
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI filesys_MoveFolder(IFileSystem3 *iface,BSTR Source,
 604                                             BSTR Destination)
 605 {
 606     FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
 607
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT WINAPI filesys_CopyFile(IFileSystem3 *iface, BSTR Source,
 612                                             BSTR Destination, VARIANT_BOOL OverWriteFiles)
 613 {
 614     FIXME("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
 615
 616     return E_NOTIMPL;
 617 }
 618
 619 static HRESULT WINAPI filesys_CopyFolder(IFileSystem3 *iface, BSTR Source,
 620                                             BSTR Destination, VARIANT_BOOL OverWriteFiles)
 621 {
 622     FIXME("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
 623
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI filesys_CreateFolder(IFileSystem3 *iface, BSTR path,
 628                                             IFolder **folder)
 629 {
 630     BOOL ret;
 631
 632     TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), folder);
 633
 634     ret = CreateDirectoryW(path, NULL);
 635     if (!ret)
 636     {
 637         *folder = NULL;
 638         if (GetLastError() == ERROR_ALREADY_EXISTS) return CTL_E_FILEALREADYEXISTS;
 639         return HRESULT_FROM_WIN32(GetLastError());
 640     }
 641
 642     return create_folder(folder);
 643 }
 644
 645 static HRESULT WINAPI filesys_CreateTextFile(IFileSystem3 *iface, BSTR FileName,
 646                                             VARIANT_BOOL Overwrite, VARIANT_BOOL Unicode,
 647                                             ITextStream **ppts)
 648 {
 649     FIXME("%p %s %d %d %p\n", iface, debugstr_w(FileName), Overwrite, Unicode, ppts);
 650
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT WINAPI filesys_OpenTextFile(IFileSystem3 *iface, BSTR FileName,
 655                                             IOMode IOMode, VARIANT_BOOL Create,
 656                                             Tristate Format, ITextStream **ppts)
 657 {
 658     FIXME("%p %s %d %d %d %p\n", iface, debugstr_w(FileName), IOMode, Create, Format, ppts);
 659
 660     return E_NOTIMPL;
 661 }
 662
 663 static HRESULT WINAPI filesys_GetStandardStream(IFileSystem3 *iface,
 664                                             StandardStreamTypes StandardStreamType,
 665                                             VARIANT_BOOL Unicode,
 666                                             ITextStream **ppts)
 667 {
 668     FIXME("%p %d %d %p\n", iface, StandardStreamType, Unicode, ppts);
 669
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI filesys_GetFileVersion(IFileSystem3 *iface, BSTR FileName,
 674                                             BSTR *FileVersion)
 675 {
 676     FIXME("%p %s %p\n", iface, debugstr_w(FileName), FileVersion);
 677
 678     return E_NOTIMPL;
 679 }
 680
 681 static const struct IFileSystem3Vtbl filesys_vtbl =
 682 {
 683     filesys_QueryInterface,
 684     filesys_AddRef,
 685     filesys_Release,
 686     filesys_GetTypeInfoCount,
 687     filesys_GetTypeInfo,
 688     filesys_GetIDsOfNames,
 689     filesys_Invoke,
 690     filesys_get_Drives,
 691     filesys_BuildPath,
 692     filesys_GetDriveName,
 693     filesys_GetParentFolderName,
 694     filesys_GetFileName,
 695     filesys_GetBaseName,
 696     filesys_GetExtensionName,
 697     filesys_GetAbsolutePathName,
 698     filesys_GetTempName,
 699     filesys_DriveExists,
 700     filesys_FileExists,
 701     filesys_FolderExists,
 702     filesys_GetDrive,
 703     filesys_GetFile,
 704     filesys_GetFolder,
 705     filesys_GetSpecialFolder,
 706     filesys_DeleteFile,
 707     filesys_DeleteFolder,
 708     filesys_MoveFile,
 709     filesys_MoveFolder,
 710     filesys_CopyFile,
 711     filesys_CopyFolder,
 712     filesys_CreateFolder,
 713     filesys_CreateTextFile,
 714     filesys_OpenTextFile,
 715     filesys_GetStandardStream,
 716     filesys_GetFileVersion
 717 };
 718
 719 static IFileSystem3 filesystem = { &filesys_vtbl };
 720
 721 HRESULT WINAPI FileSystem_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 722 {
 723     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 724
 725     return IFileSystem3_QueryInterface(&filesystem, riid, ppv);
 726 }