?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d10core: Implement ID3D10Multithread.
[wine/multimedia.git] / dlls / scrrun / filesystem.c
blob21aaf700d1e5b1e926259d52b2cf5f1063f8954c
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 #include <limits.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "ole2.h"
28 #include "olectl.h"
29 #include "dispex.h"
30 #include "ntsecapi.h"
31 #include "scrrun.h"
32 #include "scrrun_private.h"
33
34 #include "wine/debug.h"
35 #include "wine/unicode.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(scrrun);
38
39 static const WCHAR bsW[] = {'\\',0};
40
41 struct foldercollection {
42 IFolderCollection IFolderCollection_iface;
43 LONG ref;
44 BSTR path;
45 };
46
47 struct filecollection {
48 IFileCollection IFileCollection_iface;
49 LONG ref;
50 BSTR path;
51 };
52
53 struct enumdata {
54 union
55 {
56 struct
57 {
58 struct foldercollection *coll;
59 HANDLE find;
60 } foldercoll;
61 struct
62 {
63 struct filecollection *coll;
64 HANDLE find;
65 } filecoll;
66 } u;
67 };
68
69 struct enumvariant {
70 IEnumVARIANT IEnumVARIANT_iface;
71 LONG ref;
72
73 struct enumdata data;
74 };
75
76 struct folder {
77 IFolder IFolder_iface;
78 LONG ref;
79 BSTR path;
80 };
81
82 struct file {
83 IFile IFile_iface;
84 LONG ref;
85
86 WCHAR *path;
87 };
88
89 struct textstream {
90 ITextStream ITextStream_iface;
91 LONG ref;
92
93 IOMode mode;
94 };
95
96 enum iotype {
97 IORead,
98 IOWrite
99 };
100
101 static inline struct folder *impl_from_IFolder(IFolder *iface)
102 {
103 return CONTAINING_RECORD(iface, struct folder, IFolder_iface);
104 }
105
106 static inline struct file *impl_from_IFile(IFile *iface)
107 {
108 return CONTAINING_RECORD(iface, struct file, IFile_iface);
109 }
110
111 static inline struct textstream *impl_from_ITextStream(ITextStream *iface)
112 {
113 return CONTAINING_RECORD(iface, struct textstream, ITextStream_iface);
114 }
115
116 static inline struct foldercollection *impl_from_IFolderCollection(IFolderCollection *iface)
117 {
118 return CONTAINING_RECORD(iface, struct foldercollection, IFolderCollection_iface);
119 }
120
121 static inline struct filecollection *impl_from_IFileCollection(IFileCollection *iface)
122 {
123 return CONTAINING_RECORD(iface, struct filecollection, IFileCollection_iface);
124 }
125
126 static inline struct enumvariant *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
127 {
128 return CONTAINING_RECORD(iface, struct enumvariant, IEnumVARIANT_iface);
129 }
130
131 static inline HRESULT create_error(DWORD err)
132 {
133 switch(err) {
134 case ERROR_FILE_NOT_FOUND: return CTL_E_FILENOTFOUND;
135 case ERROR_PATH_NOT_FOUND: return CTL_E_PATHNOTFOUND;
136 case ERROR_ACCESS_DENIED: return CTL_E_PERMISSIONDENIED;
137 case ERROR_FILE_EXISTS: return CTL_E_FILEALREADYEXISTS;
138 case ERROR_ALREADY_EXISTS: return CTL_E_FILEALREADYEXISTS;
139 default:
140 FIXME("Unsupported error code: %d\n", err);
141 return E_FAIL;
142 }
143 }
144
145 static HRESULT create_folder(const WCHAR*, IFolder**);
146 static HRESULT create_file(BSTR, IFile**);
147 static HRESULT create_foldercoll_enum(struct foldercollection*, IUnknown**);
148 static HRESULT create_filecoll_enum(struct filecollection*, IUnknown**);
149
150 static inline BOOL is_dir_data(const WIN32_FIND_DATAW *data)
151 {
152 static const WCHAR dotdotW[] = {'.','.',0};
153 static const WCHAR dotW[] = {'.',0};
154
155 return (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
156 strcmpW(data->cFileName, dotdotW) &&
157 strcmpW(data->cFileName, dotW);
158 }
159
160 static inline BOOL is_file_data(const WIN32_FIND_DATAW *data)
161 {
162 return !(data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
163 }
164
165 static BSTR get_full_path(BSTR path, const WIN32_FIND_DATAW *data)
166 {
167 int len = SysStringLen(path);
168 WCHAR buffW[MAX_PATH];
169
170 strcpyW(buffW, path);
171 if (path[len-1] != '\\')
172 strcatW(buffW, bsW);
173 strcatW(buffW, data->cFileName);
174
175 return SysAllocString(buffW);
176 }
177
178 static BOOL textstream_check_iomode(struct textstream *This, enum iotype type)
179 {
180 if (type == IORead)
181 return This->mode == ForWriting || This->mode == ForAppending;
182 else
183 return TRUE;
184 }
185
186 static HRESULT WINAPI textstream_QueryInterface(ITextStream *iface, REFIID riid, void **obj)
187 {
188 struct textstream *This = impl_from_ITextStream(iface);
189
190 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
191
192 if (IsEqualIID(riid, &IID_ITextStream) ||
193 IsEqualIID(riid, &IID_IDispatch) ||
194 IsEqualIID(riid, &IID_IUnknown))
195 {
196 *obj = iface;
197 ITextStream_AddRef(iface);
198 return S_OK;
199 }
200
201 *obj = NULL;
202 return E_NOINTERFACE;
203 }
204
205 static ULONG WINAPI textstream_AddRef(ITextStream *iface)
206 {
207 struct textstream *This = impl_from_ITextStream(iface);
208 ULONG ref = InterlockedIncrement(&This->ref);
209 TRACE("(%p)->(%d)\n", This, ref);
210 return ref;
211 }
212
213 static ULONG WINAPI textstream_Release(ITextStream *iface)
214 {
215 struct textstream *This = impl_from_ITextStream(iface);
216 ULONG ref = InterlockedDecrement(&This->ref);
217 TRACE("(%p)->(%d)\n", This, ref);
218
219 if (!ref)
220 heap_free(This);
221
222 return ref;
223 }
224
225 static HRESULT WINAPI textstream_GetTypeInfoCount(ITextStream *iface, UINT *pctinfo)
226 {
227 struct textstream *This = impl_from_ITextStream(iface);
228 TRACE("(%p)->(%p)\n", This, pctinfo);
229 *pctinfo = 1;
230 return S_OK;
231 }
232
233 static HRESULT WINAPI textstream_GetTypeInfo(ITextStream *iface, UINT iTInfo,
234 LCID lcid, ITypeInfo **ppTInfo)
235 {
236 struct textstream *This = impl_from_ITextStream(iface);
237 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
238 return get_typeinfo(ITextStream_tid, ppTInfo);
239 }
240
241 static HRESULT WINAPI textstream_GetIDsOfNames(ITextStream *iface, REFIID riid,
242 LPOLESTR *rgszNames, UINT cNames,
243 LCID lcid, DISPID *rgDispId)
244 {
245 struct textstream *This = impl_from_ITextStream(iface);
246 ITypeInfo *typeinfo;
247 HRESULT hr;
248
249 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
250
251 hr = get_typeinfo(ITextStream_tid, &typeinfo);
252 if(SUCCEEDED(hr))
253 {
254 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
255 ITypeInfo_Release(typeinfo);
256 }
257
258 return hr;
259 }
260
261 static HRESULT WINAPI textstream_Invoke(ITextStream *iface, DISPID dispIdMember,
262 REFIID riid, LCID lcid, WORD wFlags,
263 DISPPARAMS *pDispParams, VARIANT *pVarResult,
264 EXCEPINFO *pExcepInfo, UINT *puArgErr)
265 {
266 struct textstream *This = impl_from_ITextStream(iface);
267 ITypeInfo *typeinfo;
268 HRESULT hr;
269
270 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
271 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
272
273 hr = get_typeinfo(ITextStream_tid, &typeinfo);
274 if(SUCCEEDED(hr))
275 {
276 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
277 pDispParams, pVarResult, pExcepInfo, puArgErr);
278 ITypeInfo_Release(typeinfo);
279 }
280
281 return hr;
282 }
283
284 static HRESULT WINAPI textstream_get_Line(ITextStream *iface, LONG *line)
285 {
286 struct textstream *This = impl_from_ITextStream(iface);
287 FIXME("(%p)->(%p): stub\n", This, line);
288 return E_NOTIMPL;
289 }
290
291 static HRESULT WINAPI textstream_get_Column(ITextStream *iface, LONG *column)
292 {
293 struct textstream *This = impl_from_ITextStream(iface);
294 FIXME("(%p)->(%p): stub\n", This, column);
295 return E_NOTIMPL;
296 }
297
298 static HRESULT WINAPI textstream_get_AtEndOfStream(ITextStream *iface, VARIANT_BOOL *eos)
299 {
300 struct textstream *This = impl_from_ITextStream(iface);
301 FIXME("(%p)->(%p): stub\n", This, eos);
302 return E_NOTIMPL;
303 }
304
305 static HRESULT WINAPI textstream_get_AtEndOfLine(ITextStream *iface, VARIANT_BOOL *eol)
306 {
307 struct textstream *This = impl_from_ITextStream(iface);
308 FIXME("(%p)->(%p): stub\n", This, eol);
309 return E_NOTIMPL;
310 }
311
312 static HRESULT WINAPI textstream_Read(ITextStream *iface, LONG len, BSTR *text)
313 {
314 struct textstream *This = impl_from_ITextStream(iface);
315 FIXME("(%p)->(%p): stub\n", This, text);
316
317 if (textstream_check_iomode(This, IORead))
318 return CTL_E_BADFILEMODE;
319
320 return E_NOTIMPL;
321 }
322
323 static HRESULT WINAPI textstream_ReadLine(ITextStream *iface, BSTR *text)
324 {
325 struct textstream *This = impl_from_ITextStream(iface);
326 FIXME("(%p)->(%p): stub\n", This, text);
327
328 if (textstream_check_iomode(This, IORead))
329 return CTL_E_BADFILEMODE;
330
331 return E_NOTIMPL;
332 }
333
334 static HRESULT WINAPI textstream_ReadAll(ITextStream *iface, BSTR *text)
335 {
336 struct textstream *This = impl_from_ITextStream(iface);
337 FIXME("(%p)->(%p): stub\n", This, text);
338
339 if (textstream_check_iomode(This, IORead))
340 return CTL_E_BADFILEMODE;
341
342 return E_NOTIMPL;
343 }
344
345 static HRESULT WINAPI textstream_Write(ITextStream *iface, BSTR text)
346 {
347 struct textstream *This = impl_from_ITextStream(iface);
348 FIXME("(%p)->(%s): stub\n", This, debugstr_w(text));
349 return E_NOTIMPL;
350 }
351
352 static HRESULT WINAPI textstream_WriteLine(ITextStream *iface, BSTR text)
353 {
354 struct textstream *This = impl_from_ITextStream(iface);
355 FIXME("(%p)->(%s): stub\n", This, debugstr_w(text));
356 return E_NOTIMPL;
357 }
358
359 static HRESULT WINAPI textstream_WriteBlankLines(ITextStream *iface, LONG lines)
360 {
361 struct textstream *This = impl_from_ITextStream(iface);
362 FIXME("(%p)->(%d): stub\n", This, lines);
363 return E_NOTIMPL;
364 }
365
366 static HRESULT WINAPI textstream_Skip(ITextStream *iface, LONG count)
367 {
368 struct textstream *This = impl_from_ITextStream(iface);
369 FIXME("(%p)->(%d): stub\n", This, count);
370 return E_NOTIMPL;
371 }
372
373 static HRESULT WINAPI textstream_SkipLine(ITextStream *iface)
374 {
375 struct textstream *This = impl_from_ITextStream(iface);
376 FIXME("(%p): stub\n", This);
377 return E_NOTIMPL;
378 }
379
380 static HRESULT WINAPI textstream_Close(ITextStream *iface)
381 {
382 struct textstream *This = impl_from_ITextStream(iface);
383 FIXME("(%p): stub\n", This);
384 return E_NOTIMPL;
385 }
386
387 static const ITextStreamVtbl textstreamvtbl = {
388 textstream_QueryInterface,
389 textstream_AddRef,
390 textstream_Release,
391 textstream_GetTypeInfoCount,
392 textstream_GetTypeInfo,
393 textstream_GetIDsOfNames,
394 textstream_Invoke,
395 textstream_get_Line,
396 textstream_get_Column,
397 textstream_get_AtEndOfStream,
398 textstream_get_AtEndOfLine,
399 textstream_Read,
400 textstream_ReadLine,
401 textstream_ReadAll,
402 textstream_Write,
403 textstream_WriteLine,
404 textstream_WriteBlankLines,
405 textstream_Skip,
406 textstream_SkipLine,
407 textstream_Close
408 };
409
410 static HRESULT create_textstream(IOMode mode, ITextStream **ret)
411 {
412 struct textstream *stream;
413
414 stream = heap_alloc(sizeof(struct textstream));
415 if (!stream) return E_OUTOFMEMORY;
416
417 stream->ITextStream_iface.lpVtbl = &textstreamvtbl;
418 stream->ref = 1;
419 stream->mode = mode;
420
421 *ret = &stream->ITextStream_iface;
422 return S_OK;
423 }
424
425 static HRESULT WINAPI enumvariant_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
426 {
427 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
428
429 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
430
431 *obj = NULL;
432
433 if (IsEqualIID( riid, &IID_IEnumVARIANT ) ||
434 IsEqualIID( riid, &IID_IUnknown ))
435 {
436 *obj = iface;
437 IEnumVARIANT_AddRef(iface);
438 }
439 else
440 return E_NOINTERFACE;
441
442 return S_OK;
443 }
444
445 static ULONG WINAPI enumvariant_AddRef(IEnumVARIANT *iface)
446 {
447 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
448 ULONG ref = InterlockedIncrement(&This->ref);
449 TRACE("(%p)->(%d)\n", This, ref);
450 return ref;
451 }
452
453 static ULONG WINAPI foldercoll_enumvariant_Release(IEnumVARIANT *iface)
454 {
455 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
456 ULONG ref = InterlockedDecrement(&This->ref);
457
458 TRACE("(%p)->(%d)\n", This, ref);
459
460 if (!ref)
461 {
462 IFolderCollection_Release(&This->data.u.foldercoll.coll->IFolderCollection_iface);
463 FindClose(This->data.u.foldercoll.find);
464 heap_free(This);
465 }
466
467 return ref;
468 }
469
470 static HANDLE start_enumeration(const WCHAR *path, WIN32_FIND_DATAW *data)
471 {
472 static const WCHAR allW[] = {'*',0};
473 WCHAR pathW[MAX_PATH];
474 int len;
475 HANDLE handle;
476
477 strcpyW(pathW, path);
478 len = strlenW(pathW);
479 if (pathW[len-1] != '\\')
480 strcatW(pathW, bsW);
481 strcatW(pathW, allW);
482 handle = FindFirstFileW(pathW, data);
483 if (handle == INVALID_HANDLE_VALUE) return 0;
484
485 /* find first dir */
486 while (1)
487 {
488 if (is_dir_data(data))
489 break;
490
491 if (!FindNextFileW(handle, data))
492 {
493 FindClose(handle);
494 return 0;
495 }
496 }
497 return handle;
498 }
499
500 static HRESULT WINAPI foldercoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
501 {
502 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
503 HANDLE handle = This->data.u.foldercoll.find;
504 WIN32_FIND_DATAW data;
505 ULONG count = 0;
506
507 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
508
509 if (fetched)
510 *fetched = 0;
511
512 if (!celt) return S_OK;
513
514 if (!handle)
515 {
516 handle = start_enumeration(This->data.u.foldercoll.coll->path, &data);
517 if (!handle) return S_FALSE;
518
519 This->data.u.foldercoll.find = handle;
520 }
521 else
522 {
523 if (!FindNextFileW(handle, &data))
524 return S_FALSE;
525 }
526
527 do
528 {
529 if (is_dir_data(&data))
530 {
531 IFolder *folder;
532 HRESULT hr;
533 BSTR str;
534
535 str = get_full_path(This->data.u.foldercoll.coll->path, &data);
536 hr = create_folder(str, &folder);
537 SysFreeString(str);
538 if (FAILED(hr)) return hr;
539
540 V_VT(&var[count]) = VT_DISPATCH;
541 V_DISPATCH(&var[count]) = (IDispatch*)folder;
542 count++;
543
544 if (count >= celt) break;
545 }
546 } while (FindNextFileW(handle, &data));
547
548 if (fetched)
549 *fetched = count;
550
551 return (count < celt) ? S_FALSE : S_OK;
552 }
553
554 static HRESULT WINAPI foldercoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
555 {
556 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
557 HANDLE handle = This->data.u.foldercoll.find;
558 WIN32_FIND_DATAW data;
559
560 TRACE("(%p)->(%d)\n", This, celt);
561
562 if (!celt) return S_OK;
563
564 if (!handle)
565 {
566 handle = start_enumeration(This->data.u.foldercoll.coll->path, &data);
567 if (!handle) return S_FALSE;
568
569 This->data.u.foldercoll.find = handle;
570 }
571 else
572 {
573 if (!FindNextFileW(handle, &data))
574 return S_FALSE;
575 }
576
577 do
578 {
579 if (is_dir_data(&data))
580 --celt;
581
582 if (!celt) break;
583 } while (FindNextFileW(handle, &data));
584
585 return celt ? S_FALSE : S_OK;
586 }
587
588 static HRESULT WINAPI foldercoll_enumvariant_Reset(IEnumVARIANT *iface)
589 {
590 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
591
592 TRACE("(%p)\n", This);
593
594 FindClose(This->data.u.foldercoll.find);
595 This->data.u.foldercoll.find = NULL;
596
597 return S_OK;
598 }
599
600 static HRESULT WINAPI foldercoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
601 {
602 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
603 TRACE("(%p)->(%p)\n", This, pclone);
604 return create_foldercoll_enum(This->data.u.foldercoll.coll, (IUnknown**)pclone);
605 }
606
607 static const IEnumVARIANTVtbl foldercollenumvariantvtbl = {
608 enumvariant_QueryInterface,
609 enumvariant_AddRef,
610 foldercoll_enumvariant_Release,
611 foldercoll_enumvariant_Next,
612 foldercoll_enumvariant_Skip,
613 foldercoll_enumvariant_Reset,
614 foldercoll_enumvariant_Clone
615 };
616
617 static HRESULT create_foldercoll_enum(struct foldercollection *collection, IUnknown **newenum)
618 {
619 struct enumvariant *This;
620
621 *newenum = NULL;
622
623 This = heap_alloc(sizeof(*This));
624 if (!This) return E_OUTOFMEMORY;
625
626 This->IEnumVARIANT_iface.lpVtbl = &foldercollenumvariantvtbl;
627 This->ref = 1;
628 This->data.u.foldercoll.find = NULL;
629 This->data.u.foldercoll.coll = collection;
630 IFolderCollection_AddRef(&collection->IFolderCollection_iface);
631
632 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
633
634 return S_OK;
635 }
636
637 static ULONG WINAPI filecoll_enumvariant_Release(IEnumVARIANT *iface)
638 {
639 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
640 ULONG ref = InterlockedDecrement(&This->ref);
641
642 TRACE("(%p)->(%d)\n", This, ref);
643
644 if (!ref)
645 {
646 IFileCollection_Release(&This->data.u.filecoll.coll->IFileCollection_iface);
647 FindClose(This->data.u.filecoll.find);
648 heap_free(This);
649 }
650
651 return ref;
652 }
653
654 static HRESULT WINAPI filecoll_enumvariant_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
655 {
656 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
657 HANDLE handle = This->data.u.filecoll.find;
658 WIN32_FIND_DATAW data;
659 ULONG count = 0;
660
661 TRACE("(%p)->(%d %p %p)\n", This, celt, var, fetched);
662
663 if (fetched)
664 *fetched = 0;
665
666 if (!handle)
667 {
668 static const WCHAR allW[] = {'*',0};
669 WCHAR pathW[MAX_PATH];
670 BSTR parent = This->data.u.filecoll.coll->path;
671 int len;
672
673 strcpyW(pathW, parent);
674 len = SysStringLen(parent);
675 if (parent[len-1] != '\\')
676 strcatW(pathW, bsW);
677 strcatW(pathW, allW);
678 handle = FindFirstFileW(pathW, &data);
679 if (handle == INVALID_HANDLE_VALUE)
680 return S_FALSE;
681
682 while (1)
683 {
684 if (is_file_data(&data))
685 break;
686 else
687 if (!FindNextFileW(handle, &data))
688 {
689 FindClose(handle);
690 return S_FALSE;
691 }
692 }
693
694 This->data.u.filecoll.find = handle;
695 }
696 else if (celt)
697 FindNextFileW(handle, &data);
698
699 do
700 {
701 if (count >= celt) break;
702
703 if (is_file_data(&data))
704 {
705 IFile *file;
706 HRESULT hr;
707 BSTR str;
708
709 str = get_full_path(This->data.u.filecoll.coll->path, &data);
710 hr = create_file(str, &file);
711 SysFreeString(str);
712 if (FAILED(hr)) return hr;
713
714 V_VT(&var[count]) = VT_DISPATCH;
715 V_DISPATCH(&var[count]) = (IDispatch*)file;
716 count++;
717 }
718 } while (FindNextFileW(handle, &data));
719
720 if (count < celt)
721 return S_FALSE;
722
723 if (fetched)
724 *fetched = count;
725
726 return S_OK;
727 }
728
729 static HRESULT WINAPI filecoll_enumvariant_Skip(IEnumVARIANT *iface, ULONG celt)
730 {
731 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
732 HANDLE handle = This->data.u.filecoll.find;
733 WIN32_FIND_DATAW data;
734
735 TRACE("(%p)->(%d)\n", This, celt);
736
737 while (FindNextFileW(handle, &data) && celt)
738 if (is_file_data(&data))
739 --celt;
740
741 return celt ? S_FALSE : S_OK;
742 }
743
744 static HRESULT WINAPI filecoll_enumvariant_Reset(IEnumVARIANT *iface)
745 {
746 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
747
748 TRACE("(%p)\n", This);
749
750 FindClose(This->data.u.filecoll.find);
751 This->data.u.filecoll.find = NULL;
752
753 return S_OK;
754 }
755
756 static HRESULT WINAPI filecoll_enumvariant_Clone(IEnumVARIANT *iface, IEnumVARIANT **pclone)
757 {
758 struct enumvariant *This = impl_from_IEnumVARIANT(iface);
759 TRACE("(%p)->(%p)\n", This, pclone);
760 return create_filecoll_enum(This->data.u.filecoll.coll, (IUnknown**)pclone);
761 }
762
763 static const IEnumVARIANTVtbl filecollenumvariantvtbl = {
764 enumvariant_QueryInterface,
765 enumvariant_AddRef,
766 filecoll_enumvariant_Release,
767 filecoll_enumvariant_Next,
768 filecoll_enumvariant_Skip,
769 filecoll_enumvariant_Reset,
770 filecoll_enumvariant_Clone
771 };
772
773 static HRESULT create_filecoll_enum(struct filecollection *collection, IUnknown **newenum)
774 {
775 struct enumvariant *This;
776
777 *newenum = NULL;
778
779 This = heap_alloc(sizeof(*This));
780 if (!This) return E_OUTOFMEMORY;
781
782 This->IEnumVARIANT_iface.lpVtbl = &filecollenumvariantvtbl;
783 This->ref = 1;
784 This->data.u.filecoll.coll = collection;
785 IFileCollection_AddRef(&collection->IFileCollection_iface);
786
787 *newenum = (IUnknown*)&This->IEnumVARIANT_iface;
788
789 return S_OK;
790 }
791
792 static HRESULT WINAPI foldercoll_QueryInterface(IFolderCollection *iface, REFIID riid, void **obj)
793 {
794 struct foldercollection *This = impl_from_IFolderCollection(iface);
795
796 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
797
798 *obj = NULL;
799
800 if (IsEqualIID( riid, &IID_IFolderCollection ) ||
801 IsEqualIID( riid, &IID_IDispatch ) ||
802 IsEqualIID( riid, &IID_IUnknown ))
803 {
804 *obj = iface;
805 IFolderCollection_AddRef(iface);
806 }
807 else
808 return E_NOINTERFACE;
809
810 return S_OK;
811 }
812
813 static ULONG WINAPI foldercoll_AddRef(IFolderCollection *iface)
814 {
815 struct foldercollection *This = impl_from_IFolderCollection(iface);
816 ULONG ref = InterlockedIncrement(&This->ref);
817 TRACE("(%p)->(%d)\n", This, ref);
818 return ref;
819 }
820
821 static ULONG WINAPI foldercoll_Release(IFolderCollection *iface)
822 {
823 struct foldercollection *This = impl_from_IFolderCollection(iface);
824 ULONG ref = InterlockedDecrement(&This->ref);
825 TRACE("(%p)->(%d)\n", This, ref);
826
827 if (!ref)
828 {
829 SysFreeString(This->path);
830 heap_free(This);
831 }
832
833 return ref;
834 }
835
836 static HRESULT WINAPI foldercoll_GetTypeInfoCount(IFolderCollection *iface, UINT *pctinfo)
837 {
838 struct foldercollection *This = impl_from_IFolderCollection(iface);
839 TRACE("(%p)->(%p)\n", This, pctinfo);
840 *pctinfo = 1;
841 return S_OK;
842 }
843
844 static HRESULT WINAPI foldercoll_GetTypeInfo(IFolderCollection *iface, UINT iTInfo,
845 LCID lcid, ITypeInfo **ppTInfo)
846 {
847 struct foldercollection *This = impl_from_IFolderCollection(iface);
848 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
849 return get_typeinfo(IFolderCollection_tid, ppTInfo);
850 }
851
852 static HRESULT WINAPI foldercoll_GetIDsOfNames(IFolderCollection *iface, REFIID riid,
853 LPOLESTR *rgszNames, UINT cNames,
854 LCID lcid, DISPID *rgDispId)
855 {
856 struct foldercollection *This = impl_from_IFolderCollection(iface);
857 ITypeInfo *typeinfo;
858 HRESULT hr;
859
860 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
861
862 hr = get_typeinfo(IFolderCollection_tid, &typeinfo);
863 if(SUCCEEDED(hr))
864 {
865 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
866 ITypeInfo_Release(typeinfo);
867 }
868
869 return hr;
870 }
871
872 static HRESULT WINAPI foldercoll_Invoke(IFolderCollection *iface, DISPID dispIdMember,
873 REFIID riid, LCID lcid, WORD wFlags,
874 DISPPARAMS *pDispParams, VARIANT *pVarResult,
875 EXCEPINFO *pExcepInfo, UINT *puArgErr)
876 {
877 struct foldercollection *This = impl_from_IFolderCollection(iface);
878 ITypeInfo *typeinfo;
879 HRESULT hr;
880
881 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
882 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
883
884 hr = get_typeinfo(IFolderCollection_tid, &typeinfo);
885 if(SUCCEEDED(hr))
886 {
887 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
888 pDispParams, pVarResult, pExcepInfo, puArgErr);
889 ITypeInfo_Release(typeinfo);
890 }
891
892 return hr;
893 }
894
895 static HRESULT WINAPI foldercoll_Add(IFolderCollection *iface, BSTR name, IFolder **folder)
896 {
897 struct foldercollection *This = impl_from_IFolderCollection(iface);
898 FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(name), folder);
899 return E_NOTIMPL;
900 }
901
902 static HRESULT WINAPI foldercoll_get_Item(IFolderCollection *iface, VARIANT key, IFolder **folder)
903 {
904 struct foldercollection *This = impl_from_IFolderCollection(iface);
905 FIXME("(%p)->(%p): stub\n", This, folder);
906 return E_NOTIMPL;
907 }
908
909 static HRESULT WINAPI foldercoll_get__NewEnum(IFolderCollection *iface, IUnknown **newenum)
910 {
911 struct foldercollection *This = impl_from_IFolderCollection(iface);
912
913 TRACE("(%p)->(%p)\n", This, newenum);
914
915 if(!newenum)
916 return E_POINTER;
917
918 return create_foldercoll_enum(This, newenum);
919 }
920
921 static HRESULT WINAPI foldercoll_get_Count(IFolderCollection *iface, LONG *count)
922 {
923 struct foldercollection *This = impl_from_IFolderCollection(iface);
924 static const WCHAR allW[] = {'\\','*',0};
925 WIN32_FIND_DATAW data;
926 WCHAR pathW[MAX_PATH];
927 HANDLE handle;
928
929 TRACE("(%p)->(%p)\n", This, count);
930
931 if(!count)
932 return E_POINTER;
933
934 *count = 0;
935
936 strcpyW(pathW, This->path);
937 strcatW(pathW, allW);
938 handle = FindFirstFileW(pathW, &data);
939 if (handle == INVALID_HANDLE_VALUE)
940 return HRESULT_FROM_WIN32(GetLastError());
941
942 do
943 {
944 if (is_dir_data(&data))
945 *count += 1;
946 } while (FindNextFileW(handle, &data));
947 FindClose(handle);
948
949 return S_OK;
950 }
951
952 static const IFolderCollectionVtbl foldercollvtbl = {
953 foldercoll_QueryInterface,
954 foldercoll_AddRef,
955 foldercoll_Release,
956 foldercoll_GetTypeInfoCount,
957 foldercoll_GetTypeInfo,
958 foldercoll_GetIDsOfNames,
959 foldercoll_Invoke,
960 foldercoll_Add,
961 foldercoll_get_Item,
962 foldercoll_get__NewEnum,
963 foldercoll_get_Count
964 };
965
966 static HRESULT create_foldercoll(BSTR path, IFolderCollection **folders)
967 {
968 struct foldercollection *This;
969
970 *folders = NULL;
971
972 This = heap_alloc(sizeof(struct foldercollection));
973 if (!This) return E_OUTOFMEMORY;
974
975 This->IFolderCollection_iface.lpVtbl = &foldercollvtbl;
976 This->ref = 1;
977 This->path = SysAllocString(path);
978 if (!This->path)
979 {
980 heap_free(This);
981 return E_OUTOFMEMORY;
982 }
983
984 *folders = &This->IFolderCollection_iface;
985
986 return S_OK;
987 }
988
989 static HRESULT WINAPI filecoll_QueryInterface(IFileCollection *iface, REFIID riid, void **obj)
990 {
991 struct filecollection *This = impl_from_IFileCollection(iface);
992
993 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
994
995 *obj = NULL;
996
997 if (IsEqualIID( riid, &IID_IFileCollection ) ||
998 IsEqualIID( riid, &IID_IDispatch ) ||
999 IsEqualIID( riid, &IID_IUnknown ))
1000 {
1001 *obj = iface;
1002 IFileCollection_AddRef(iface);
1003 }
1004 else
1005 return E_NOINTERFACE;
1006
1007 return S_OK;
1008 }
1009
1010 static ULONG WINAPI filecoll_AddRef(IFileCollection *iface)
1011 {
1012 struct filecollection *This = impl_from_IFileCollection(iface);
1013 ULONG ref = InterlockedIncrement(&This->ref);
1014 TRACE("(%p)->(%d)\n", This, ref);
1015 return ref;
1016 }
1017
1018 static ULONG WINAPI filecoll_Release(IFileCollection *iface)
1019 {
1020 struct filecollection *This = impl_from_IFileCollection(iface);
1021 ULONG ref = InterlockedDecrement(&This->ref);
1022 TRACE("(%p)->(%d)\n", This, ref);
1023
1024 if (!ref)
1025 {
1026 SysFreeString(This->path);
1027 heap_free(This);
1028 }
1029
1030 return ref;
1031 }
1032
1033 static HRESULT WINAPI filecoll_GetTypeInfoCount(IFileCollection *iface, UINT *pctinfo)
1034 {
1035 struct filecollection *This = impl_from_IFileCollection(iface);
1036 TRACE("(%p)->(%p)\n", This, pctinfo);
1037 *pctinfo = 1;
1038 return S_OK;
1039 }
1040
1041 static HRESULT WINAPI filecoll_GetTypeInfo(IFileCollection *iface, UINT iTInfo,
1042 LCID lcid, ITypeInfo **ppTInfo)
1043 {
1044 struct filecollection *This = impl_from_IFileCollection(iface);
1045 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1046 return get_typeinfo(IFileCollection_tid, ppTInfo);
1047 }
1048
1049 static HRESULT WINAPI filecoll_GetIDsOfNames(IFileCollection *iface, REFIID riid,
1050 LPOLESTR *rgszNames, UINT cNames,
1051 LCID lcid, DISPID *rgDispId)
1052 {
1053 struct filecollection *This = impl_from_IFileCollection(iface);
1054 ITypeInfo *typeinfo;
1055 HRESULT hr;
1056
1057 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1058
1059 hr = get_typeinfo(IFileCollection_tid, &typeinfo);
1060 if(SUCCEEDED(hr))
1061 {
1062 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1063 ITypeInfo_Release(typeinfo);
1064 }
1065
1066 return hr;
1067 }
1068
1069 static HRESULT WINAPI filecoll_Invoke(IFileCollection *iface, DISPID dispIdMember,
1070 REFIID riid, LCID lcid, WORD wFlags,
1071 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1072 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1073 {
1074 struct filecollection *This = impl_from_IFileCollection(iface);
1075 ITypeInfo *typeinfo;
1076 HRESULT hr;
1077
1078 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1079 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1080
1081 hr = get_typeinfo(IFileCollection_tid, &typeinfo);
1082 if(SUCCEEDED(hr))
1083 {
1084 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1085 pDispParams, pVarResult, pExcepInfo, puArgErr);
1086 ITypeInfo_Release(typeinfo);
1087 }
1088
1089 return hr;
1090 }
1091
1092 static HRESULT WINAPI filecoll_get_Item(IFileCollection *iface, VARIANT Key, IFile **file)
1093 {
1094 struct filecollection *This = impl_from_IFileCollection(iface);
1095 FIXME("(%p)->(%p)\n", This, file);
1096 return E_NOTIMPL;
1097 }
1098
1099 static HRESULT WINAPI filecoll_get__NewEnum(IFileCollection *iface, IUnknown **ppenum)
1100 {
1101 struct filecollection *This = impl_from_IFileCollection(iface);
1102
1103 TRACE("(%p)->(%p)\n", This, ppenum);
1104
1105 if(!ppenum)
1106 return E_POINTER;
1107
1108 return create_filecoll_enum(This, ppenum);
1109 }
1110
1111 static HRESULT WINAPI filecoll_get_Count(IFileCollection *iface, LONG *count)
1112 {
1113 struct filecollection *This = impl_from_IFileCollection(iface);
1114 FIXME("(%p)->(%p)\n", This, count);
1115 return E_NOTIMPL;
1116 }
1117
1118 static const IFileCollectionVtbl filecollectionvtbl = {
1119 filecoll_QueryInterface,
1120 filecoll_AddRef,
1121 filecoll_Release,
1122 filecoll_GetTypeInfoCount,
1123 filecoll_GetTypeInfo,
1124 filecoll_GetIDsOfNames,
1125 filecoll_Invoke,
1126 filecoll_get_Item,
1127 filecoll_get__NewEnum,
1128 filecoll_get_Count
1129 };
1130
1131 static HRESULT create_filecoll(BSTR path, IFileCollection **files)
1132 {
1133 struct filecollection *This;
1134
1135 *files = NULL;
1136
1137 This = heap_alloc(sizeof(*This));
1138 if (!This) return E_OUTOFMEMORY;
1139
1140 This->IFileCollection_iface.lpVtbl = &filecollectionvtbl;
1141 This->ref = 1;
1142 This->path = SysAllocString(path);
1143 if (!This->path)
1144 {
1145 heap_free(This);
1146 return E_OUTOFMEMORY;
1147 }
1148
1149 *files = &This->IFileCollection_iface;
1150 return S_OK;
1151 }
1152
1153 static HRESULT WINAPI folder_QueryInterface(IFolder *iface, REFIID riid, void **obj)
1154 {
1155 struct folder *This = impl_from_IFolder(iface);
1156
1157 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1158
1159 *obj = NULL;
1160
1161 if (IsEqualIID( riid, &IID_IFolder ) ||
1162 IsEqualIID( riid, &IID_IDispatch ) ||
1163 IsEqualIID( riid, &IID_IUnknown))
1164 {
1165 *obj = iface;
1166 IFolder_AddRef(iface);
1167 }
1168 else
1169 return E_NOINTERFACE;
1170
1171 return S_OK;
1172 }
1173
1174 static ULONG WINAPI folder_AddRef(IFolder *iface)
1175 {
1176 struct folder *This = impl_from_IFolder(iface);
1177 ULONG ref = InterlockedIncrement(&This->ref);
1178 TRACE("(%p)->(%d)\n", This, ref);
1179 return ref;
1180 }
1181
1182 static ULONG WINAPI folder_Release(IFolder *iface)
1183 {
1184 struct folder *This = impl_from_IFolder(iface);
1185 ULONG ref = InterlockedDecrement(&This->ref);
1186 TRACE("(%p)->(%d)\n", This, ref);
1187
1188 if (!ref)
1189 {
1190 SysFreeString(This->path);
1191 heap_free(This);
1192 }
1193
1194 return ref;
1195 }
1196
1197 static HRESULT WINAPI folder_GetTypeInfoCount(IFolder *iface, UINT *pctinfo)
1198 {
1199 struct folder *This = impl_from_IFolder(iface);
1200 TRACE("(%p)->(%p)\n", This, pctinfo);
1201 *pctinfo = 1;
1202 return S_OK;
1203 }
1204
1205 static HRESULT WINAPI folder_GetTypeInfo(IFolder *iface, UINT iTInfo,
1206 LCID lcid, ITypeInfo **ppTInfo)
1207 {
1208 struct folder *This = impl_from_IFolder(iface);
1209 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1210 return get_typeinfo(IFolder_tid, ppTInfo);
1211 }
1212
1213 static HRESULT WINAPI folder_GetIDsOfNames(IFolder *iface, REFIID riid,
1214 LPOLESTR *rgszNames, UINT cNames,
1215 LCID lcid, DISPID *rgDispId)
1216 {
1217 struct folder *This = impl_from_IFolder(iface);
1218 ITypeInfo *typeinfo;
1219 HRESULT hr;
1220
1221 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1222
1223 hr = get_typeinfo(IFolder_tid, &typeinfo);
1224 if(SUCCEEDED(hr))
1225 {
1226 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1227 ITypeInfo_Release(typeinfo);
1228 }
1229
1230 return hr;
1231 }
1232
1233 static HRESULT WINAPI folder_Invoke(IFolder *iface, DISPID dispIdMember,
1234 REFIID riid, LCID lcid, WORD wFlags,
1235 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1236 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1237 {
1238 struct folder *This = impl_from_IFolder(iface);
1239 ITypeInfo *typeinfo;
1240 HRESULT hr;
1241
1242 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1243 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1244
1245 hr = get_typeinfo(IFolder_tid, &typeinfo);
1246 if(SUCCEEDED(hr))
1247 {
1248 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1249 pDispParams, pVarResult, pExcepInfo, puArgErr);
1250 ITypeInfo_Release(typeinfo);
1251 }
1252
1253 return hr;
1254 }
1255
1256 static HRESULT WINAPI folder_get_Path(IFolder *iface, BSTR *path)
1257 {
1258 struct folder *This = impl_from_IFolder(iface);
1259 FIXME("(%p)->(%p): stub\n", This, path);
1260 return E_NOTIMPL;
1261 }
1262
1263 static HRESULT WINAPI folder_get_Name(IFolder *iface, BSTR *name)
1264 {
1265 struct folder *This = impl_from_IFolder(iface);
1266 WCHAR *ptr;
1267
1268 TRACE("(%p)->(%p)\n", This, name);
1269
1270 if(!name)
1271 return E_POINTER;
1272
1273 *name = NULL;
1274
1275 ptr = strrchrW(This->path, '\\');
1276 if (ptr)
1277 {
1278 *name = SysAllocString(ptr+1);
1279 TRACE("%s\n", debugstr_w(*name));
1280 if (!*name) return E_OUTOFMEMORY;
1281 }
1282 else
1283 return E_FAIL;
1284
1285 return S_OK;
1286 }
1287
1288 static HRESULT WINAPI folder_put_Name(IFolder *iface, BSTR name)
1289 {
1290 struct folder *This = impl_from_IFolder(iface);
1291 FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
1292 return E_NOTIMPL;
1293 }
1294
1295 static HRESULT WINAPI folder_get_ShortPath(IFolder *iface, BSTR *path)
1296 {
1297 struct folder *This = impl_from_IFolder(iface);
1298 FIXME("(%p)->(%p): stub\n", This, path);
1299 return E_NOTIMPL;
1300 }
1301
1302 static HRESULT WINAPI folder_get_ShortName(IFolder *iface, BSTR *name)
1303 {
1304 struct folder *This = impl_from_IFolder(iface);
1305 FIXME("(%p)->(%p): stub\n", This, name);
1306 return E_NOTIMPL;
1307 }
1308
1309 static HRESULT WINAPI folder_get_Drive(IFolder *iface, IDrive **drive)
1310 {
1311 struct folder *This = impl_from_IFolder(iface);
1312 FIXME("(%p)->(%p): stub\n", This, drive);
1313 return E_NOTIMPL;
1314 }
1315
1316 static HRESULT WINAPI folder_get_ParentFolder(IFolder *iface, IFolder **parent)
1317 {
1318 struct folder *This = impl_from_IFolder(iface);
1319 FIXME("(%p)->(%p): stub\n", This, parent);
1320 return E_NOTIMPL;
1321 }
1322
1323 static HRESULT WINAPI folder_get_Attributes(IFolder *iface, FileAttribute *attr)
1324 {
1325 struct folder *This = impl_from_IFolder(iface);
1326 FIXME("(%p)->(%p): stub\n", This, attr);
1327 return E_NOTIMPL;
1328 }
1329
1330 static HRESULT WINAPI folder_put_Attributes(IFolder *iface, FileAttribute attr)
1331 {
1332 struct folder *This = impl_from_IFolder(iface);
1333 FIXME("(%p)->(0x%x): stub\n", This, attr);
1334 return E_NOTIMPL;
1335 }
1336
1337 static HRESULT WINAPI folder_get_DateCreated(IFolder *iface, DATE *date)
1338 {
1339 struct folder *This = impl_from_IFolder(iface);
1340 FIXME("(%p)->(%p): stub\n", This, date);
1341 return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI folder_get_DateLastModified(IFolder *iface, DATE *date)
1345 {
1346 struct folder *This = impl_from_IFolder(iface);
1347 FIXME("(%p)->(%p): stub\n", This, date);
1348 return E_NOTIMPL;
1349 }
1350
1351 static HRESULT WINAPI folder_get_DateLastAccessed(IFolder *iface, DATE *date)
1352 {
1353 struct folder *This = impl_from_IFolder(iface);
1354 FIXME("(%p)->(%p): stub\n", This, date);
1355 return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI folder_get_Type(IFolder *iface, BSTR *type)
1359 {
1360 struct folder *This = impl_from_IFolder(iface);
1361 FIXME("(%p)->(%p): stub\n", This, type);
1362 return E_NOTIMPL;
1363 }
1364
1365 static HRESULT WINAPI folder_Delete(IFolder *iface, VARIANT_BOOL force)
1366 {
1367 struct folder *This = impl_from_IFolder(iface);
1368 FIXME("(%p)->(%x): stub\n", This, force);
1369 return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI folder_Copy(IFolder *iface, BSTR dest, VARIANT_BOOL overwrite)
1373 {
1374 struct folder *This = impl_from_IFolder(iface);
1375 FIXME("(%p)->(%s %x): stub\n", This, debugstr_w(dest), overwrite);
1376 return E_NOTIMPL;
1377 }
1378
1379 static HRESULT WINAPI folder_Move(IFolder *iface, BSTR dest)
1380 {
1381 struct folder *This = impl_from_IFolder(iface);
1382 FIXME("(%p)->(%s): stub\n", This, debugstr_w(dest));
1383 return E_NOTIMPL;
1384 }
1385
1386 static HRESULT WINAPI folder_get_IsRootFolder(IFolder *iface, VARIANT_BOOL *isroot)
1387 {
1388 struct folder *This = impl_from_IFolder(iface);
1389 FIXME("(%p)->(%p): stub\n", This, isroot);
1390 return E_NOTIMPL;
1391 }
1392
1393 static HRESULT WINAPI folder_get_Size(IFolder *iface, VARIANT *size)
1394 {
1395 struct folder *This = impl_from_IFolder(iface);
1396 FIXME("(%p)->(%p): stub\n", This, size);
1397 return E_NOTIMPL;
1398 }
1399
1400 static HRESULT WINAPI folder_get_SubFolders(IFolder *iface, IFolderCollection **folders)
1401 {
1402 struct folder *This = impl_from_IFolder(iface);
1403
1404 TRACE("(%p)->(%p)\n", This, folders);
1405
1406 if(!folders)
1407 return E_POINTER;
1408
1409 return create_foldercoll(This->path, folders);
1410 }
1411
1412 static HRESULT WINAPI folder_get_Files(IFolder *iface, IFileCollection **files)
1413 {
1414 struct folder *This = impl_from_IFolder(iface);
1415
1416 TRACE("(%p)->(%p)\n", This, files);
1417
1418 if(!files)
1419 return E_POINTER;
1420
1421 return create_filecoll(This->path, files);
1422 }
1423
1424 static HRESULT WINAPI folder_CreateTextFile(IFolder *iface, BSTR filename, VARIANT_BOOL overwrite,
1425 VARIANT_BOOL unicode, ITextStream **stream)
1426 {
1427 struct folder *This = impl_from_IFolder(iface);
1428 FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream);
1429 return E_NOTIMPL;
1430 }
1431
1432 static const IFolderVtbl foldervtbl = {
1433 folder_QueryInterface,
1434 folder_AddRef,
1435 folder_Release,
1436 folder_GetTypeInfoCount,
1437 folder_GetTypeInfo,
1438 folder_GetIDsOfNames,
1439 folder_Invoke,
1440 folder_get_Path,
1441 folder_get_Name,
1442 folder_put_Name,
1443 folder_get_ShortPath,
1444 folder_get_ShortName,
1445 folder_get_Drive,
1446 folder_get_ParentFolder,
1447 folder_get_Attributes,
1448 folder_put_Attributes,
1449 folder_get_DateCreated,
1450 folder_get_DateLastModified,
1451 folder_get_DateLastAccessed,
1452 folder_get_Type,
1453 folder_Delete,
1454 folder_Copy,
1455 folder_Move,
1456 folder_get_IsRootFolder,
1457 folder_get_Size,
1458 folder_get_SubFolders,
1459 folder_get_Files,
1460 folder_CreateTextFile
1461 };
1462
1463 HRESULT create_folder(const WCHAR *path, IFolder **folder)
1464 {
1465 struct folder *This;
1466
1467 *folder = NULL;
1468
1469 TRACE("%s\n", debugstr_w(path));
1470
1471 This = heap_alloc(sizeof(struct folder));
1472 if (!This) return E_OUTOFMEMORY;
1473
1474 This->IFolder_iface.lpVtbl = &foldervtbl;
1475 This->ref = 1;
1476 This->path = SysAllocString(path);
1477 if (!This->path)
1478 {
1479 heap_free(This);
1480 return E_OUTOFMEMORY;
1481 }
1482
1483 *folder = &This->IFolder_iface;
1484
1485 return S_OK;
1486 }
1487
1488 static HRESULT WINAPI file_QueryInterface(IFile *iface, REFIID riid, void **obj)
1489 {
1490 struct file *This = impl_from_IFile(iface);
1491
1492 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
1493
1494 if (IsEqualIID(riid, &IID_IFile) ||
1495 IsEqualIID(riid, &IID_IDispatch) ||
1496 IsEqualIID(riid, &IID_IUnknown))
1497 {
1498 *obj = iface;
1499 IFile_AddRef(iface);
1500 return S_OK;
1501 }
1502
1503 *obj = NULL;
1504 return E_NOINTERFACE;
1505 }
1506
1507 static ULONG WINAPI file_AddRef(IFile *iface)
1508 {
1509 struct file *This = impl_from_IFile(iface);
1510 LONG ref = InterlockedIncrement(&This->ref);
1511
1512 TRACE("(%p) ref=%d\n", This, ref);
1513
1514 return ref;
1515 }
1516
1517 static ULONG WINAPI file_Release(IFile *iface)
1518 {
1519 struct file *This = impl_from_IFile(iface);
1520 LONG ref = InterlockedDecrement(&This->ref);
1521
1522 TRACE("(%p) ref=%d\n", This, ref);
1523
1524 if(!ref)
1525 {
1526 heap_free(This->path);
1527 heap_free(This);
1528 }
1529
1530 return ref;
1531 }
1532
1533 static HRESULT WINAPI file_GetTypeInfoCount(IFile *iface, UINT *pctinfo)
1534 {
1535 struct file *This = impl_from_IFile(iface);
1536
1537 TRACE("(%p)->(%p)\n", This, pctinfo);
1538
1539 *pctinfo = 1;
1540 return S_OK;
1541 }
1542
1543 static HRESULT WINAPI file_GetTypeInfo(IFile *iface,
1544 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1545 {
1546 struct file *This = impl_from_IFile(iface);
1547
1548 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1549
1550 return get_typeinfo(IFile_tid, ppTInfo);
1551 }
1552
1553 static HRESULT WINAPI file_GetIDsOfNames(IFile *iface, REFIID riid,
1554 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1555 {
1556 struct file *This = impl_from_IFile(iface);
1557 ITypeInfo *typeinfo;
1558 HRESULT hr;
1559
1560 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
1561 rgszNames, cNames, lcid, rgDispId);
1562
1563 hr = get_typeinfo(IFile_tid, &typeinfo);
1564 if(SUCCEEDED(hr)) {
1565 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1566 ITypeInfo_Release(typeinfo);
1567 }
1568 return hr;
1569 }
1570
1571 static HRESULT WINAPI file_Invoke(IFile *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1572 {
1573 struct file *This = impl_from_IFile(iface);
1574 ITypeInfo *typeinfo;
1575 HRESULT hr;
1576
1577 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1578 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1579
1580 hr = get_typeinfo(IFile_tid, &typeinfo);
1581 if(SUCCEEDED(hr))
1582 {
1583 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1584 pDispParams, pVarResult, pExcepInfo, puArgErr);
1585 ITypeInfo_Release(typeinfo);
1586 }
1587 return hr;
1588 }
1589
1590 static HRESULT WINAPI file_get_Path(IFile *iface, BSTR *pbstrPath)
1591 {
1592 struct file *This = impl_from_IFile(iface);
1593 FIXME("(%p)->(%p)\n", This, pbstrPath);
1594 return E_NOTIMPL;
1595 }
1596
1597 static HRESULT WINAPI file_get_Name(IFile *iface, BSTR *name)
1598 {
1599 struct file *This = impl_from_IFile(iface);
1600 WCHAR *ptr;
1601
1602 TRACE("(%p)->(%p)\n", This, name);
1603
1604 if(!name)
1605 return E_POINTER;
1606
1607 *name = NULL;
1608
1609 ptr = strrchrW(This->path, '\\');
1610 if (ptr)
1611 {
1612 *name = SysAllocString(ptr+1);
1613 TRACE("%s\n", debugstr_w(*name));
1614 if (!*name) return E_OUTOFMEMORY;
1615 }
1616 else
1617 return E_FAIL;
1618
1619 return S_OK;
1620 }
1621
1622 static HRESULT WINAPI file_put_Name(IFile *iface, BSTR pbstrName)
1623 {
1624 struct file *This = impl_from_IFile(iface);
1625 FIXME("(%p)->(%s)\n", This, debugstr_w(pbstrName));
1626 return E_NOTIMPL;
1627 }
1628
1629 static HRESULT WINAPI file_get_ShortPath(IFile *iface, BSTR *pbstrPath)
1630 {
1631 struct file *This = impl_from_IFile(iface);
1632 FIXME("(%p)->(%p)\n", This, pbstrPath);
1633 return E_NOTIMPL;
1634 }
1635
1636 static HRESULT WINAPI file_get_ShortName(IFile *iface, BSTR *pbstrName)
1637 {
1638 struct file *This = impl_from_IFile(iface);
1639 FIXME("(%p)->(%p)\n", This, pbstrName);
1640 return E_NOTIMPL;
1641 }
1642
1643 static HRESULT WINAPI file_get_Drive(IFile *iface, IDrive **ppdrive)
1644 {
1645 struct file *This = impl_from_IFile(iface);
1646 FIXME("(%p)->(%p)\n", This, ppdrive);
1647 return E_NOTIMPL;
1648 }
1649
1650 static HRESULT WINAPI file_get_ParentFolder(IFile *iface, IFolder **ppfolder)
1651 {
1652 struct file *This = impl_from_IFile(iface);
1653 FIXME("(%p)->(%p)\n", This, ppfolder);
1654 return E_NOTIMPL;
1655 }
1656
1657 static HRESULT WINAPI file_get_Attributes(IFile *iface, FileAttribute *pfa)
1658 {
1659 struct file *This = impl_from_IFile(iface);
1660 DWORD fa;
1661
1662 TRACE("(%p)->(%p)\n", This, pfa);
1663
1664 if(!pfa)
1665 return E_POINTER;
1666
1667 fa = GetFileAttributesW(This->path);
1668 if(fa == INVALID_FILE_ATTRIBUTES)
1669 return create_error(GetLastError());
1670
1671 *pfa = fa & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
1672 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_ARCHIVE |
1673 FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_COMPRESSED);
1674 return S_OK;
1675 }
1676
1677 static HRESULT WINAPI file_put_Attributes(IFile *iface, FileAttribute pfa)
1678 {
1679 struct file *This = impl_from_IFile(iface);
1680 FIXME("(%p)->(%x)\n", This, pfa);
1681 return E_NOTIMPL;
1682 }
1683
1684 static HRESULT WINAPI file_get_DateCreated(IFile *iface, DATE *pdate)
1685 {
1686 struct file *This = impl_from_IFile(iface);
1687 FIXME("(%p)->(%p)\n", This, pdate);
1688 return E_NOTIMPL;
1689 }
1690
1691 static HRESULT WINAPI file_get_DateLastModified(IFile *iface, DATE *pdate)
1692 {
1693 struct file *This = impl_from_IFile(iface);
1694 FIXME("(%p)->(%p)\n", This, pdate);
1695 return E_NOTIMPL;
1696 }
1697
1698 static HRESULT WINAPI file_get_DateLastAccessed(IFile *iface, DATE *pdate)
1699 {
1700 struct file *This = impl_from_IFile(iface);
1701 FIXME("(%p)->(%p)\n", This, pdate);
1702 return E_NOTIMPL;
1703 }
1704
1705 static HRESULT WINAPI file_get_Size(IFile *iface, VARIANT *pvarSize)
1706 {
1707 struct file *This = impl_from_IFile(iface);
1708 WIN32_FIND_DATAW fd;
1709 HANDLE f;
1710
1711 TRACE("(%p)->(%p)\n", This, pvarSize);
1712
1713 if(!pvarSize)
1714 return E_POINTER;
1715
1716 f = FindFirstFileW(This->path, &fd);
1717 if(f == INVALID_HANDLE_VALUE)
1718 return create_error(GetLastError());
1719 FindClose(f);
1720
1721 if(fd.nFileSizeHigh || fd.nFileSizeLow>INT_MAX) {
1722 V_VT(pvarSize) = VT_R8;
1723 V_R8(pvarSize) = ((ULONGLONG)fd.nFileSizeHigh<<32) + fd.nFileSizeLow;
1724 }else {
1725 V_VT(pvarSize) = VT_I4;
1726 V_I4(pvarSize) = fd.nFileSizeLow;
1727 }
1728 return S_OK;
1729 }
1730
1731 static HRESULT WINAPI file_get_Type(IFile *iface, BSTR *pbstrType)
1732 {
1733 struct file *This = impl_from_IFile(iface);
1734 FIXME("(%p)->(%p)\n", This, pbstrType);
1735 return E_NOTIMPL;
1736 }
1737
1738 static HRESULT WINAPI file_Delete(IFile *iface, VARIANT_BOOL Force)
1739 {
1740 struct file *This = impl_from_IFile(iface);
1741 FIXME("(%p)->(%x)\n", This, Force);
1742 return E_NOTIMPL;
1743 }
1744
1745 static HRESULT WINAPI file_Copy(IFile *iface, BSTR Destination, VARIANT_BOOL OverWriteFiles)
1746 {
1747 struct file *This = impl_from_IFile(iface);
1748 FIXME("(%p)->(%s %x)\n", This, debugstr_w(Destination), OverWriteFiles);
1749 return E_NOTIMPL;
1750 }
1751
1752 static HRESULT WINAPI file_Move(IFile *iface, BSTR Destination)
1753 {
1754 struct file *This = impl_from_IFile(iface);
1755 FIXME("(%p)->(%s)\n", This, debugstr_w(Destination));
1756 return E_NOTIMPL;
1757 }
1758
1759 static HRESULT WINAPI file_OpenAsTextStream(IFile *iface, IOMode IOMode, Tristate Format, ITextStream **ppts)
1760 {
1761 struct file *This = impl_from_IFile(iface);
1762 FIXME("(%p)->(%x %x %p)\n", This, IOMode, Format, ppts);
1763 return E_NOTIMPL;
1764 }
1765
1766 static const IFileVtbl file_vtbl = {
1767 file_QueryInterface,
1768 file_AddRef,
1769 file_Release,
1770 file_GetTypeInfoCount,
1771 file_GetTypeInfo,
1772 file_GetIDsOfNames,
1773 file_Invoke,
1774 file_get_Path,
1775 file_get_Name,
1776 file_put_Name,
1777 file_get_ShortPath,
1778 file_get_ShortName,
1779 file_get_Drive,
1780 file_get_ParentFolder,
1781 file_get_Attributes,
1782 file_put_Attributes,
1783 file_get_DateCreated,
1784 file_get_DateLastModified,
1785 file_get_DateLastAccessed,
1786 file_get_Size,
1787 file_get_Type,
1788 file_Delete,
1789 file_Copy,
1790 file_Move,
1791 file_OpenAsTextStream
1792 };
1793
1794 static HRESULT create_file(BSTR path, IFile **file)
1795 {
1796 struct file *f;
1797 DWORD len, attrs;
1798
1799 *file = NULL;
1800
1801 f = heap_alloc(sizeof(struct file));
1802 if(!f)
1803 return E_OUTOFMEMORY;
1804
1805 f->IFile_iface.lpVtbl = &file_vtbl;
1806 f->ref = 1;
1807
1808 len = GetFullPathNameW(path, 0, NULL, NULL);
1809 if(!len) {
1810 heap_free(f);
1811 return E_FAIL;
1812 }
1813
1814 f->path = heap_alloc(len*sizeof(WCHAR));
1815 if(!f->path) {
1816 heap_free(f);
1817 return E_OUTOFMEMORY;
1818 }
1819
1820 if(!GetFullPathNameW(path, len, f->path, NULL)) {
1821 heap_free(f->path);
1822 heap_free(f);
1823 return E_FAIL;
1824 }
1825
1826 if(path[len-1]=='/' || path[len-1]=='\\')
1827 path[len-1] = 0;
1828
1829 attrs = GetFileAttributesW(f->path);
1830 if(attrs==INVALID_FILE_ATTRIBUTES ||
1831 (attrs&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))) {
1832 heap_free(f->path);
1833 heap_free(f);
1834 return create_error(GetLastError());
1835 }
1836
1837 *file = &f->IFile_iface;
1838 return S_OK;
1839 }
1840
1841 static HRESULT WINAPI filesys_QueryInterface(IFileSystem3 *iface, REFIID riid, void **ppvObject)
1842 {
1843 TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
1844
1845 if ( IsEqualGUID( riid, &IID_IFileSystem3 ) ||
1846 IsEqualGUID( riid, &IID_IFileSystem ) ||
1847 IsEqualGUID( riid, &IID_IDispatch ) ||
1848 IsEqualGUID( riid, &IID_IUnknown ) )
1849 {
1850 *ppvObject = iface;
1851 }
1852 else if ( IsEqualGUID( riid, &IID_IDispatchEx ))
1853 {
1854 TRACE("Interface IDispatchEx not supported - returning NULL\n");
1855 *ppvObject = NULL;
1856 return E_NOINTERFACE;
1857 }
1858 else if ( IsEqualGUID( riid, &IID_IObjectWithSite ))
1859 {
1860 TRACE("Interface IObjectWithSite not supported - returning NULL\n");
1861 *ppvObject = NULL;
1862 return E_NOINTERFACE;
1863 }
1864 else
1865 {
1866 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
1867 return E_NOINTERFACE;
1868 }
1869
1870 IFileSystem3_AddRef(iface);
1871
1872 return S_OK;
1873 }
1874
1875 static ULONG WINAPI filesys_AddRef(IFileSystem3 *iface)
1876 {
1877 TRACE("%p\n", iface);
1878
1879 return 2;
1880 }
1881
1882 static ULONG WINAPI filesys_Release(IFileSystem3 *iface)
1883 {
1884 TRACE("%p\n", iface);
1885
1886 return 1;
1887 }
1888
1889 static HRESULT WINAPI filesys_GetTypeInfoCount(IFileSystem3 *iface, UINT *pctinfo)
1890 {
1891 TRACE("(%p)->(%p)\n", iface, pctinfo);
1892
1893 *pctinfo = 1;
1894 return S_OK;
1895 }
1896
1897 static HRESULT WINAPI filesys_GetTypeInfo(IFileSystem3 *iface, UINT iTInfo,
1898 LCID lcid, ITypeInfo **ppTInfo)
1899 {
1900 TRACE("(%p)->(%u %u %p)\n", iface, iTInfo, lcid, ppTInfo);
1901 return get_typeinfo(IFileSystem3_tid, ppTInfo);
1902 }
1903
1904 static HRESULT WINAPI filesys_GetIDsOfNames(IFileSystem3 *iface, REFIID riid,
1905 LPOLESTR *rgszNames, UINT cNames,
1906 LCID lcid, DISPID *rgDispId)
1907 {
1908 ITypeInfo *typeinfo;
1909 HRESULT hr;
1910
1911 TRACE("(%p)->(%s %p %u %u %p)\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1912
1913 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
1914 if(SUCCEEDED(hr))
1915 {
1916 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1917 ITypeInfo_Release(typeinfo);
1918 }
1919
1920 return hr;
1921 }
1922
1923 static HRESULT WINAPI filesys_Invoke(IFileSystem3 *iface, DISPID dispIdMember,
1924 REFIID riid, LCID lcid, WORD wFlags,
1925 DISPPARAMS *pDispParams, VARIANT *pVarResult,
1926 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1927 {
1928 ITypeInfo *typeinfo;
1929 HRESULT hr;
1930
1931 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", iface, dispIdMember, debugstr_guid(riid),
1932 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1933
1934 hr = get_typeinfo(IFileSystem3_tid, &typeinfo);
1935 if(SUCCEEDED(hr))
1936 {
1937 hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags,
1938 pDispParams, pVarResult, pExcepInfo, puArgErr);
1939 ITypeInfo_Release(typeinfo);
1940 }
1941
1942 return hr;
1943 }
1944
1945 static HRESULT WINAPI filesys_get_Drives(IFileSystem3 *iface, IDriveCollection **ppdrives)
1946 {
1947 FIXME("%p %p\n", iface, ppdrives);
1948
1949 return E_NOTIMPL;
1950 }
1951
1952 static HRESULT WINAPI filesys_BuildPath(IFileSystem3 *iface, BSTR Path,
1953 BSTR Name, BSTR *Result)
1954 {
1955 BSTR ret;
1956
1957 TRACE("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), Result);
1958
1959 if (!Result) return E_POINTER;
1960
1961 if (Path && Name)
1962 {
1963 int path_len = SysStringLen(Path), name_len = SysStringLen(Name);
1964
1965 /* if both parts have backslashes strip one from Path */
1966 if (Path[path_len-1] == '\\' && Name[0] == '\\')
1967 {
1968 path_len -= 1;
1969
1970 ret = SysAllocStringLen(NULL, path_len + name_len);
1971 if (ret)
1972 {
1973 strcpyW(ret, Path);
1974 ret[path_len] = 0;
1975 strcatW(ret, Name);
1976 }
1977 }
1978 else if (Path[path_len-1] != '\\' && Name[0] != '\\')
1979 {
1980 ret = SysAllocStringLen(NULL, path_len + name_len + 1);
1981 if (ret)
1982 {
1983 strcpyW(ret, Path);
1984 if (Path[path_len-1] != ':')
1985 strcatW(ret, bsW);
1986 strcatW(ret, Name);
1987 }
1988 }
1989 else
1990 {
1991 ret = SysAllocStringLen(NULL, path_len + name_len);
1992 if (ret)
1993 {
1994 strcpyW(ret, Path);
1995 strcatW(ret, Name);
1996 }
1997 }
1998 }
1999 else if (Path || Name)
2000 ret = SysAllocString(Path ? Path : Name);
2001 else
2002 ret = SysAllocStringLen(NULL, 0);
2003
2004 if (!ret) return E_OUTOFMEMORY;
2005 *Result = ret;
2006
2007 return S_OK;
2008 }
2009
2010 static HRESULT WINAPI filesys_GetDriveName(IFileSystem3 *iface, BSTR Path,
2011 BSTR *pbstrResult)
2012 {
2013 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2014
2015 return E_NOTIMPL;
2016 }
2017
2018 static inline DWORD get_parent_folder_name(const WCHAR *path, DWORD len)
2019 {
2020 int i;
2021
2022 if(!path)
2023 return 0;
2024
2025 for(i=len-1; i>=0; i--)
2026 if(path[i]!='/' && path[i]!='\\')
2027 break;
2028
2029 for(; i>=0; i--)
2030 if(path[i]=='/' || path[i]=='\\')
2031 break;
2032
2033 for(; i>=0; i--)
2034 if(path[i]!='/' && path[i]!='\\')
2035 break;
2036
2037 if(i < 0)
2038 return 0;
2039
2040 if(path[i]==':' && i==1)
2041 i++;
2042 return i+1;
2043 }
2044
2045 static HRESULT WINAPI filesys_GetParentFolderName(IFileSystem3 *iface, BSTR Path,
2046 BSTR *pbstrResult)
2047 {
2048 DWORD len;
2049
2050 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2051
2052 if(!pbstrResult)
2053 return E_POINTER;
2054
2055 len = get_parent_folder_name(Path, SysStringLen(Path));
2056 if(!len) {
2057 *pbstrResult = NULL;
2058 return S_OK;
2059 }
2060
2061 *pbstrResult = SysAllocStringLen(Path, len);
2062 if(!*pbstrResult)
2063 return E_OUTOFMEMORY;
2064 return S_OK;
2065 }
2066
2067 static HRESULT WINAPI filesys_GetFileName(IFileSystem3 *iface, BSTR Path,
2068 BSTR *pbstrResult)
2069 {
2070 int i, end;
2071
2072 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2073
2074 if(!pbstrResult)
2075 return E_POINTER;
2076
2077 if(!Path) {
2078 *pbstrResult = NULL;
2079 return S_OK;
2080 }
2081
2082 for(end=strlenW(Path)-1; end>=0; end--)
2083 if(Path[end]!='/' && Path[end]!='\\')
2084 break;
2085
2086 for(i=end; i>=0; i--)
2087 if(Path[i]=='/' || Path[i]=='\\')
2088 break;
2089 i++;
2090
2091 if(i>end || (i==0 && end==1 && Path[1]==':')) {
2092 *pbstrResult = NULL;
2093 return S_OK;
2094 }
2095
2096 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
2097 if(!*pbstrResult)
2098 return E_OUTOFMEMORY;
2099 return S_OK;
2100 }
2101
2102 static HRESULT WINAPI filesys_GetBaseName(IFileSystem3 *iface, BSTR Path,
2103 BSTR *pbstrResult)
2104 {
2105 int i, end;
2106
2107 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2108
2109 if(!pbstrResult)
2110 return E_POINTER;
2111
2112 if(!Path) {
2113 *pbstrResult = NULL;
2114 return S_OK;
2115 }
2116
2117 for(end=strlenW(Path)-1; end>=0; end--)
2118 if(Path[end]!='/' && Path[end]!='\\')
2119 break;
2120
2121 for(i=end; i>=0; i--) {
2122 if(Path[i]=='.' && Path[end+1]!='.')
2123 end = i-1;
2124 if(Path[i]=='/' || Path[i]=='\\')
2125 break;
2126 }
2127 i++;
2128
2129 if((i>end && Path[end+1]!='.') || (i==0 && end==1 && Path[1]==':')) {
2130 *pbstrResult = NULL;
2131 return S_OK;
2132 }
2133
2134 *pbstrResult = SysAllocStringLen(Path+i, end-i+1);
2135 if(!*pbstrResult)
2136 return E_OUTOFMEMORY;
2137 return S_OK;
2138 }
2139
2140 static HRESULT WINAPI filesys_GetExtensionName(IFileSystem3 *iface, BSTR Path,
2141 BSTR *pbstrResult)
2142 {
2143 FIXME("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2144
2145 return E_NOTIMPL;
2146 }
2147
2148 static HRESULT WINAPI filesys_GetAbsolutePathName(IFileSystem3 *iface, BSTR Path,
2149 BSTR *pbstrResult)
2150 {
2151 static const WCHAR cur_path[] = {'.',0};
2152
2153 WCHAR buf[MAX_PATH], ch;
2154 const WCHAR *path;
2155 DWORD i, beg, len, exp_len;
2156 WIN32_FIND_DATAW fdata;
2157 HANDLE fh;
2158
2159 TRACE("%p %s %p\n", iface, debugstr_w(Path), pbstrResult);
2160
2161 if(!pbstrResult)
2162 return E_POINTER;
2163
2164 if(!Path)
2165 path = cur_path;
2166 else
2167 path = Path;
2168
2169 len = GetFullPathNameW(path, MAX_PATH, buf, NULL);
2170 if(!len)
2171 return E_FAIL;
2172
2173 buf[0] = toupperW(buf[0]);
2174 if(len>3 && buf[len-1] == '\\')
2175 buf[--len] = 0;
2176
2177 for(beg=3, i=3; i<=len; i++) {
2178 if(buf[i]!='\\' && buf[i])
2179 continue;
2180
2181 ch = buf[i];
2182 buf[i] = 0;
2183 fh = FindFirstFileW(buf, &fdata);
2184 if(fh == INVALID_HANDLE_VALUE)
2185 break;
2186
2187 exp_len = strlenW(fdata.cFileName);
2188 if(exp_len == i-beg)
2189 memcpy(buf+beg, fdata.cFileName, exp_len*sizeof(WCHAR));
2190 FindClose(fh);
2191 buf[i] = ch;
2192 beg = i+1;
2193 }
2194
2195 *pbstrResult = SysAllocString(buf);
2196 if(!*pbstrResult)
2197 return E_OUTOFMEMORY;
2198 return S_OK;
2199 }
2200
2201 static HRESULT WINAPI filesys_GetTempName(IFileSystem3 *iface, BSTR *pbstrResult)
2202 {
2203 static const WCHAR fmt[] = {'r','a','d','%','0','5','X','.','t','x','t',0};
2204
2205 DWORD random;
2206
2207 TRACE("%p %p\n", iface, pbstrResult);
2208
2209 if(!pbstrResult)
2210 return E_POINTER;
2211
2212 *pbstrResult = SysAllocStringLen(NULL, 12);
2213 if(!*pbstrResult)
2214 return E_OUTOFMEMORY;
2215
2216 if(!RtlGenRandom(&random, sizeof(random)))
2217 return E_FAIL;
2218 sprintfW(*pbstrResult, fmt, random & 0xfffff);
2219 return S_OK;
2220 }
2221
2222 static HRESULT WINAPI filesys_DriveExists(IFileSystem3 *iface, BSTR DriveSpec,
2223 VARIANT_BOOL *pfExists)
2224 {
2225 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), pfExists);
2226
2227 return E_NOTIMPL;
2228 }
2229
2230 static HRESULT WINAPI filesys_FileExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
2231 {
2232 DWORD attrs;
2233 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
2234
2235 if (!ret) return E_POINTER;
2236
2237 attrs = GetFileAttributesW(path);
2238 *ret = attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
2239 return S_OK;
2240 }
2241
2242 static HRESULT WINAPI filesys_FolderExists(IFileSystem3 *iface, BSTR path, VARIANT_BOOL *ret)
2243 {
2244 DWORD attrs;
2245 TRACE("%p %s %p\n", iface, debugstr_w(path), ret);
2246
2247 if (!ret) return E_POINTER;
2248
2249 attrs = GetFileAttributesW(path);
2250 *ret = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) ? VARIANT_TRUE : VARIANT_FALSE;
2251
2252 return S_OK;
2253 }
2254
2255 static HRESULT WINAPI filesys_GetDrive(IFileSystem3 *iface, BSTR DriveSpec,
2256 IDrive **ppdrive)
2257 {
2258 FIXME("%p %s %p\n", iface, debugstr_w(DriveSpec), ppdrive);
2259
2260 return E_NOTIMPL;
2261 }
2262
2263 static HRESULT WINAPI filesys_GetFile(IFileSystem3 *iface, BSTR FilePath,
2264 IFile **ppfile)
2265 {
2266 TRACE("%p %s %p\n", iface, debugstr_w(FilePath), ppfile);
2267
2268 if(!ppfile)
2269 return E_POINTER;
2270 if(!FilePath)
2271 return E_INVALIDARG;
2272
2273 return create_file(FilePath, ppfile);
2274 }
2275
2276 static HRESULT WINAPI filesys_GetFolder(IFileSystem3 *iface, BSTR FolderPath,
2277 IFolder **folder)
2278 {
2279 DWORD attrs;
2280
2281 TRACE("%p %s %p\n", iface, debugstr_w(FolderPath), folder);
2282
2283 if(!folder)
2284 return E_POINTER;
2285
2286 *folder = NULL;
2287 if(!FolderPath)
2288 return E_INVALIDARG;
2289
2290 attrs = GetFileAttributesW(FolderPath);
2291 if((attrs == INVALID_FILE_ATTRIBUTES) || !(attrs & FILE_ATTRIBUTE_DIRECTORY))
2292 return CTL_E_PATHNOTFOUND;
2293
2294 return create_folder(FolderPath, folder);
2295 }
2296
2297 static HRESULT WINAPI filesys_GetSpecialFolder(IFileSystem3 *iface,
2298 SpecialFolderConst SpecialFolder,
2299 IFolder **ppfolder)
2300 {
2301 FIXME("%p %d %p\n", iface, SpecialFolder, ppfolder);
2302
2303 return E_NOTIMPL;
2304 }
2305
2306 static inline HRESULT delete_file(const WCHAR *file, DWORD file_len, VARIANT_BOOL force)
2307 {
2308 WCHAR path[MAX_PATH];
2309 DWORD len, name_len;
2310 WIN32_FIND_DATAW ffd;
2311 HANDLE f;
2312
2313 f = FindFirstFileW(file, &ffd);
2314 if(f == INVALID_HANDLE_VALUE)
2315 return create_error(GetLastError());
2316
2317 len = get_parent_folder_name(file, file_len);
2318 if(len+1 >= MAX_PATH) {
2319 FindClose(f);
2320 return E_FAIL;
2321 }
2322 if(len) {
2323 memcpy(path, file, len*sizeof(WCHAR));
2324 path[len++] = '\\';
2325 }
2326
2327 do {
2328 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
2329 continue;
2330
2331 name_len = strlenW(ffd.cFileName);
2332 if(len+name_len+1 >= MAX_PATH) {
2333 FindClose(f);
2334 return E_FAIL;
2335 }
2336 memcpy(path+len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
2337
2338 TRACE("deleting %s\n", debugstr_w(path));
2339
2340 if(!DeleteFileW(path)) {
2341 if(!force || !SetFileAttributesW(path, FILE_ATTRIBUTE_NORMAL)
2342 || !DeleteFileW(path)) {
2343 FindClose(f);
2344 return create_error(GetLastError());
2345 }
2346 }
2347 } while(FindNextFileW(f, &ffd));
2348 FindClose(f);
2349
2350 return S_OK;
2351 }
2352
2353 static HRESULT WINAPI filesys_DeleteFile(IFileSystem3 *iface, BSTR FileSpec,
2354 VARIANT_BOOL Force)
2355 {
2356 TRACE("%p %s %d\n", iface, debugstr_w(FileSpec), Force);
2357
2358 if(!FileSpec)
2359 return E_POINTER;
2360
2361 return delete_file(FileSpec, SysStringLen(FileSpec), Force);
2362 }
2363
2364 static HRESULT delete_folder(const WCHAR *folder, DWORD folder_len, VARIANT_BOOL force)
2365 {
2366 WCHAR path[MAX_PATH];
2367 DWORD len, name_len;
2368 WIN32_FIND_DATAW ffd;
2369 HANDLE f;
2370 HRESULT hr;
2371
2372 f = FindFirstFileW(folder, &ffd);
2373 if(f == INVALID_HANDLE_VALUE)
2374 return create_error(GetLastError());
2375
2376 len = get_parent_folder_name(folder, folder_len);
2377 if(len+1 >= MAX_PATH) {
2378 FindClose(f);
2379 return E_FAIL;
2380 }
2381 if(len) {
2382 memcpy(path, folder, len*sizeof(WCHAR));
2383 path[len++] = '\\';
2384 }
2385
2386 do {
2387 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
2388 continue;
2389 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
2390 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
2391 continue;
2392
2393 name_len = strlenW(ffd.cFileName);
2394 if(len+name_len+3 >= MAX_PATH) {
2395 FindClose(f);
2396 return E_FAIL;
2397 }
2398 memcpy(path+len, ffd.cFileName, name_len*sizeof(WCHAR));
2399 path[len+name_len] = '\\';
2400 path[len+name_len+1] = '*';
2401 path[len+name_len+2] = 0;
2402
2403 hr = delete_file(path, len+name_len+2, force);
2404 if(FAILED(hr)) {
2405 FindClose(f);
2406 return hr;
2407 }
2408
2409 hr = delete_folder(path, len+name_len+2, force);
2410 if(FAILED(hr)) {
2411 FindClose(f);
2412 return hr;
2413 }
2414
2415 path[len+name_len] = 0;
2416 TRACE("deleting %s\n", debugstr_w(path));
2417
2418 if(!RemoveDirectoryW(path)) {
2419 FindClose(f);
2420 return create_error(GetLastError());
2421 }
2422 } while(FindNextFileW(f, &ffd));
2423 FindClose(f);
2424
2425 return S_OK;
2426 }
2427
2428 static HRESULT WINAPI filesys_DeleteFolder(IFileSystem3 *iface, BSTR FolderSpec,
2429 VARIANT_BOOL Force)
2430 {
2431 TRACE("%p %s %d\n", iface, debugstr_w(FolderSpec), Force);
2432
2433 if(!FolderSpec)
2434 return E_POINTER;
2435
2436 return delete_folder(FolderSpec, SysStringLen(FolderSpec), Force);
2437 }
2438
2439 static HRESULT WINAPI filesys_MoveFile(IFileSystem3 *iface, BSTR Source,
2440 BSTR Destination)
2441 {
2442 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
2443
2444 return E_NOTIMPL;
2445 }
2446
2447 static HRESULT WINAPI filesys_MoveFolder(IFileSystem3 *iface,BSTR Source,
2448 BSTR Destination)
2449 {
2450 FIXME("%p %s %s\n", iface, debugstr_w(Source), debugstr_w(Destination));
2451
2452 return E_NOTIMPL;
2453 }
2454
2455 static inline HRESULT copy_file(const WCHAR *source, DWORD source_len,
2456 const WCHAR *destination, DWORD destination_len, VARIANT_BOOL overwrite)
2457 {
2458 DWORD attrs;
2459 WCHAR src_path[MAX_PATH], dst_path[MAX_PATH];
2460 DWORD src_len, dst_len, name_len;
2461 WIN32_FIND_DATAW ffd;
2462 HANDLE f;
2463 HRESULT hr;
2464
2465 if(!source[0] || !destination[0])
2466 return E_INVALIDARG;
2467
2468 attrs = GetFileAttributesW(destination);
2469 if(attrs==INVALID_FILE_ATTRIBUTES || !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
2470 attrs = GetFileAttributesW(source);
2471 if(attrs == INVALID_FILE_ATTRIBUTES)
2472 return create_error(GetLastError());
2473 else if(attrs & FILE_ATTRIBUTE_DIRECTORY)
2474 return CTL_E_FILENOTFOUND;
2475
2476 if(!CopyFileW(source, destination, !overwrite))
2477 return create_error(GetLastError());
2478 return S_OK;
2479 }
2480
2481 f = FindFirstFileW(source, &ffd);
2482 if(f == INVALID_HANDLE_VALUE)
2483 return CTL_E_FILENOTFOUND;
2484
2485 src_len = get_parent_folder_name(source, source_len);
2486 if(src_len+1 >= MAX_PATH)
2487 return E_FAIL;
2488 if(src_len) {
2489 memcpy(src_path, source, src_len*sizeof(WCHAR));
2490 src_path[src_len++] = '\\';
2491 }
2492
2493 dst_len = destination_len;
2494 if(dst_len+1 >= MAX_PATH) {
2495 FindClose(f);
2496 return E_FAIL;
2497 }
2498 memcpy(dst_path, destination, dst_len*sizeof(WCHAR));
2499 if(dst_path[dst_len-1]!= '\\' && dst_path[dst_len-1]!='/')
2500 dst_path[dst_len++] = '\\';
2501
2502 hr = CTL_E_FILENOTFOUND;
2503 do {
2504 if(ffd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_DEVICE))
2505 continue;
2506
2507 name_len = strlenW(ffd.cFileName);
2508 if(src_len+name_len+1>=MAX_PATH || dst_len+name_len+1>=MAX_PATH) {
2509 FindClose(f);
2510 return E_FAIL;
2511 }
2512 memcpy(src_path+src_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
2513 memcpy(dst_path+dst_len, ffd.cFileName, (name_len+1)*sizeof(WCHAR));
2514
2515 TRACE("copying %s to %s\n", debugstr_w(src_path), debugstr_w(dst_path));
2516
2517 if(!CopyFileW(src_path, dst_path, !overwrite)) {
2518 FindClose(f);
2519 return create_error(GetLastError());
2520 }else {
2521 hr = S_OK;
2522 }
2523 } while(FindNextFileW(f, &ffd));
2524 FindClose(f);
2525
2526 return hr;
2527 }
2528
2529 static HRESULT WINAPI filesys_CopyFile(IFileSystem3 *iface, BSTR Source,
2530 BSTR Destination, VARIANT_BOOL OverWriteFiles)
2531 {
2532 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
2533
2534 if(!Source || !Destination)
2535 return E_POINTER;
2536
2537 return copy_file(Source, SysStringLen(Source), Destination,
2538 SysStringLen(Destination), OverWriteFiles);
2539 }
2540
2541 static HRESULT copy_folder(const WCHAR *source, DWORD source_len, const WCHAR *destination,
2542 DWORD destination_len, VARIANT_BOOL overwrite)
2543 {
2544 DWORD tmp, src_len, dst_len, name_len;
2545 WCHAR src[MAX_PATH], dst[MAX_PATH];
2546 WIN32_FIND_DATAW ffd;
2547 HANDLE f;
2548 HRESULT hr;
2549 BOOL copied = FALSE;
2550
2551 if(!source[0] || !destination[0])
2552 return E_INVALIDARG;
2553
2554 dst_len = destination_len;
2555 if(dst_len+1 >= MAX_PATH)
2556 return E_FAIL;
2557 memcpy(dst, destination, (dst_len+1)*sizeof(WCHAR));
2558
2559 if(dst[dst_len-1]!='\\' && dst[dst_len-1]!='/' &&
2560 (tmp = GetFileAttributesW(source))!=INVALID_FILE_ATTRIBUTES &&
2561 tmp&FILE_ATTRIBUTE_DIRECTORY) {
2562 if(!CreateDirectoryW(dst, NULL)) {
2563 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
2564 tmp = GetFileAttributesW(dst);
2565 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY))
2566 return CTL_E_FILEALREADYEXISTS;
2567 }else {
2568 return create_error(GetLastError());
2569 }
2570 }
2571 copied = TRUE;
2572
2573 src_len = source_len;
2574 if(src_len+2 >= MAX_PATH)
2575 return E_FAIL;
2576 memcpy(src, source, src_len*sizeof(WCHAR));
2577 src[src_len++] = '\\';
2578 src[src_len] = '*';
2579 src[src_len+1] = 0;
2580
2581 hr = copy_file(src, src_len+1, dst, dst_len, overwrite);
2582 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND)
2583 return create_error(GetLastError());
2584
2585 f = FindFirstFileW(src, &ffd);
2586 }else {
2587 src_len = get_parent_folder_name(source, source_len);
2588 if(src_len+2 >= MAX_PATH)
2589 return E_FAIL;
2590 memcpy(src, source, src_len*sizeof(WCHAR));
2591 if(src_len)
2592 src[src_len++] = '\\';
2593
2594 f = FindFirstFileW(source, &ffd);
2595 }
2596 if(f == INVALID_HANDLE_VALUE)
2597 return CTL_E_PATHNOTFOUND;
2598
2599 dst[dst_len++] = '\\';
2600 dst[dst_len] = 0;
2601
2602 do {
2603 if(!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
2604 continue;
2605 if(ffd.cFileName[0]=='.' && (ffd.cFileName[1]==0 ||
2606 (ffd.cFileName[1]=='.' && ffd.cFileName[2]==0)))
2607 continue;
2608
2609 name_len = strlenW(ffd.cFileName);
2610 if(dst_len+name_len>=MAX_PATH || src_len+name_len+2>=MAX_PATH) {
2611 FindClose(f);
2612 return E_FAIL;
2613 }
2614 memcpy(dst+dst_len, ffd.cFileName, name_len*sizeof(WCHAR));
2615 dst[dst_len+name_len] = 0;
2616 memcpy(src+src_len, ffd.cFileName, name_len*sizeof(WCHAR));
2617 src[src_len+name_len] = '\\';
2618 src[src_len+name_len+1] = '*';
2619 src[src_len+name_len+2] = 0;
2620
2621 TRACE("copying %s to %s\n", debugstr_w(src), debugstr_w(dst));
2622
2623 if(!CreateDirectoryW(dst, NULL)) {
2624 if(overwrite && GetLastError()==ERROR_ALREADY_EXISTS) {
2625 tmp = GetFileAttributesW(dst);
2626 if(tmp==INVALID_FILE_ATTRIBUTES || !(tmp&FILE_ATTRIBUTE_DIRECTORY)) {
2627 FindClose(f);
2628 return CTL_E_FILEALREADYEXISTS;
2629 }
2630 }else {
2631 FindClose(f);
2632 return create_error(GetLastError());
2633 }
2634 return create_error(GetLastError());
2635 }
2636 copied = TRUE;
2637
2638 hr = copy_file(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
2639 if(FAILED(hr) && hr!=CTL_E_FILENOTFOUND) {
2640 FindClose(f);
2641 return hr;
2642 }
2643
2644 hr = copy_folder(src, src_len+name_len+2, dst, dst_len+name_len, overwrite);
2645 if(FAILED(hr) && hr!=CTL_E_PATHNOTFOUND) {
2646 FindClose(f);
2647 return hr;
2648 }
2649 } while(FindNextFileW(f, &ffd));
2650 FindClose(f);
2651
2652 return copied ? S_OK : CTL_E_PATHNOTFOUND;
2653 }
2654
2655 static HRESULT WINAPI filesys_CopyFolder(IFileSystem3 *iface, BSTR Source,
2656 BSTR Destination, VARIANT_BOOL OverWriteFiles)
2657 {
2658 TRACE("%p %s %s %d\n", iface, debugstr_w(Source), debugstr_w(Destination), OverWriteFiles);
2659
2660 if(!Source || !Destination)
2661 return E_POINTER;
2662
2663 return copy_folder(Source, SysStringLen(Source), Destination,
2664 SysStringLen(Destination), OverWriteFiles);
2665 }
2666
2667 static HRESULT WINAPI filesys_CreateFolder(IFileSystem3 *iface, BSTR path,
2668 IFolder **folder)
2669 {
2670 BOOL ret;
2671
2672 TRACE("(%p)->(%s %p)\n", iface, debugstr_w(path), folder);
2673
2674 ret = CreateDirectoryW(path, NULL);
2675 if (!ret)
2676 {
2677 *folder = NULL;
2678 if (GetLastError() == ERROR_ALREADY_EXISTS) return CTL_E_FILEALREADYEXISTS;
2679 return HRESULT_FROM_WIN32(GetLastError());
2680 }
2681
2682 return create_folder(path, folder);
2683 }
2684
2685 static HRESULT WINAPI filesys_CreateTextFile(IFileSystem3 *iface, BSTR FileName,
2686 VARIANT_BOOL Overwrite, VARIANT_BOOL Unicode,
2687 ITextStream **ppts)
2688 {
2689 FIXME("%p %s %d %d %p\n", iface, debugstr_w(FileName), Overwrite, Unicode, ppts);
2690
2691 return E_NOTIMPL;
2692 }
2693
2694 static HRESULT WINAPI filesys_OpenTextFile(IFileSystem3 *iface, BSTR filename,
2695 IOMode mode, VARIANT_BOOL create,
2696 Tristate format, ITextStream **stream)
2697 {
2698 FIXME("(%p)->(%s %d %d %d %p)\n", iface, debugstr_w(filename), mode, create, format, stream);
2699 return create_textstream(mode, stream);
2700 }
2701
2702 static HRESULT WINAPI filesys_GetStandardStream(IFileSystem3 *iface,
2703 StandardStreamTypes StandardStreamType,
2704 VARIANT_BOOL Unicode,
2705 ITextStream **ppts)
2706 {
2707 FIXME("%p %d %d %p\n", iface, StandardStreamType, Unicode, ppts);
2708
2709 return E_NOTIMPL;
2710 }
2711
2712 static void get_versionstring(VS_FIXEDFILEINFO *info, WCHAR *ver)
2713 {
2714 static const WCHAR fmtW[] = {'%','d','.','%','d','.','%','d','.','%','d',0};
2715 DWORDLONG version;
2716 WORD a, b, c, d;
2717
2718 version = (((DWORDLONG)info->dwFileVersionMS) << 32) + info->dwFileVersionLS;
2719 a = (WORD)( version >> 48);
2720 b = (WORD)((version >> 32) & 0xffff);
2721 c = (WORD)((version >> 16) & 0xffff);
2722 d = (WORD)( version & 0xffff);
2723
2724 sprintfW(ver, fmtW, a, b, c, d);
2725 }
2726
2727 static HRESULT WINAPI filesys_GetFileVersion(IFileSystem3 *iface, BSTR name, BSTR *version)
2728 {
2729 static const WCHAR rootW[] = {'\\',0};
2730 VS_FIXEDFILEINFO *info;
2731 WCHAR ver[30];
2732 void *ptr;
2733 DWORD len;
2734 BOOL ret;
2735
2736 TRACE("%p %s %p\n", iface, debugstr_w(name), version);
2737
2738 len = GetFileVersionInfoSizeW(name, NULL);
2739 if (!len)
2740 return HRESULT_FROM_WIN32(GetLastError());
2741
2742 ptr = heap_alloc(len);
2743 if (!GetFileVersionInfoW(name, 0, len, ptr))
2744 {
2745 heap_free(ptr);
2746 return HRESULT_FROM_WIN32(GetLastError());
2747 }
2748
2749 ret = VerQueryValueW(ptr, rootW, (void**)&info, &len);
2750 heap_free(ptr);
2751 if (!ret)
2752 return HRESULT_FROM_WIN32(GetLastError());
2753
2754 get_versionstring(info, ver);
2755 *version = SysAllocString(ver);
2756 TRACE("version=%s\n", debugstr_w(ver));
2757
2758 return S_OK;
2759 }
2760
2761 static const struct IFileSystem3Vtbl filesys_vtbl =
2762 {
2763 filesys_QueryInterface,
2764 filesys_AddRef,
2765 filesys_Release,
2766 filesys_GetTypeInfoCount,
2767 filesys_GetTypeInfo,
2768 filesys_GetIDsOfNames,
2769 filesys_Invoke,
2770 filesys_get_Drives,
2771 filesys_BuildPath,
2772 filesys_GetDriveName,
2773 filesys_GetParentFolderName,
2774 filesys_GetFileName,
2775 filesys_GetBaseName,
2776 filesys_GetExtensionName,
2777 filesys_GetAbsolutePathName,
2778 filesys_GetTempName,
2779 filesys_DriveExists,
2780 filesys_FileExists,
2781 filesys_FolderExists,
2782 filesys_GetDrive,
2783 filesys_GetFile,
2784 filesys_GetFolder,
2785 filesys_GetSpecialFolder,
2786 filesys_DeleteFile,
2787 filesys_DeleteFolder,
2788 filesys_MoveFile,
2789 filesys_MoveFolder,
2790 filesys_CopyFile,
2791 filesys_CopyFolder,
2792 filesys_CreateFolder,
2793 filesys_CreateTextFile,
2794 filesys_OpenTextFile,
2795 filesys_GetStandardStream,
2796 filesys_GetFileVersion
2797 };
2798
2799 static IFileSystem3 filesystem = { &filesys_vtbl };
2800
2801 HRESULT WINAPI FileSystem_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2802 {
2803 TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
2804
2805 return IFileSystem3_QueryInterface(&filesystem, riid, ppv);
2806 }
Maarten's multimedia branch