source: trunk/src/shell32/shlfileop.c@ 5655

Last change on this file since 5655 was 5654, checked in by sandervl, 24 years ago

DT: SHFileOperation update (FO_MOVE)
File size: 24.3 KB
Line 
1/*
2 * SHFileOperation
3 */
4#ifdef __WIN32OS2__
5#define ICOM_CINTERFACE 1
6#include <odin.h>
7#endif
8#include <string.h>
9#include "debugtools.h"
10#include "shellapi.h"
11#include "shlwapi.h"
12
13#include "shlobj.h"
14#include "shresdef.h"
15#include "shell32_main.h"
16#include "wine/undocshell.h"
17#include "shlwapi.h"
18
19DEFAULT_DEBUG_CHANNEL(shell);
20
21
22#ifdef __WIN32OS2__
23BOOL SHELL_ConfirmDialog (int nKindOfDialog, LPCSTR szDir)
24{
25 char szCaption[255], szText[255], szBuffer[MAX_PATH + 256];
26 UINT caption_resource_id, text_resource_id;
27
28 switch(nKindOfDialog) {
29
30 case ASK_DELETE_FILE:
31 caption_resource_id = IDS_DELETEITEM_CAPTION;
32 text_resource_id = IDS_DELETEITEM_TEXT;
33 break;
34 case ASK_DELETE_FOLDER:
35 caption_resource_id = IDS_DELETEFOLDER_CAPTION;
36 text_resource_id = IDS_DELETEITEM_TEXT;
37 break;
38 case ASK_DELETE_MULTIPLE_ITEM:
39 caption_resource_id = IDS_DELETEITEM_CAPTION;
40 text_resource_id = IDS_DELETEMULTIPLE_TEXT;
41 break;
42 case ASK_OVERWRITE_FILE:
43 caption_resource_id = IDS_OVERWRITEFILE_CAPTION;
44 text_resource_id = IDS_OVERWRITEFILE_TEXT;
45 break;
46 default:
47 FIXME(__FUNCTION__" Unhandled nKindOfDialog %d stub\n", nKindOfDialog);
48 return FALSE;
49 }
50
51 LoadStringA(shell32_hInstance, caption_resource_id, szCaption, sizeof(szCaption));
52 LoadStringA(shell32_hInstance, text_resource_id, szText, sizeof(szText));
53#else
54BOOL SHELL_WarnItemDelete (int nKindOfDialog, LPCSTR szDir)
55{
56 char szCaption[255], szText[255], szBuffer[MAX_PATH + 256];
57
58 if(nKindOfDialog == ASK_DELETE_FILE)
59 {
60 LoadStringA(shell32_hInstance, IDS_DELETEITEM_TEXT, szText,
61 sizeof(szText));
62 LoadStringA(shell32_hInstance, IDS_DELETEITEM_CAPTION,
63 szCaption, sizeof(szCaption));
64 }
65 else if(nKindOfDialog == ASK_DELETE_FOLDER)
66 {
67 LoadStringA(shell32_hInstance, IDS_DELETEITEM_TEXT, szText,
68 sizeof(szText));
69 LoadStringA(shell32_hInstance, IDS_DELETEFOLDER_CAPTION,
70 szCaption, sizeof(szCaption));
71 }
72 else if(nKindOfDialog == ASK_DELETE_MULTIPLE_ITEM)
73 {
74 LoadStringA(shell32_hInstance, IDS_DELETEMULTIPLE_TEXT, szText,
75 sizeof(szText));
76 LoadStringA(shell32_hInstance, IDS_DELETEITEM_CAPTION,
77 szCaption, sizeof(szCaption));
78 }
79 else {
80 FIXME("Called without a valid nKindOfDialog specified!");
81 LoadStringA(shell32_hInstance, IDS_DELETEITEM_TEXT, szText,
82 sizeof(szText));
83 LoadStringA(shell32_hInstance, IDS_DELETEITEM_CAPTION,
84 szCaption, sizeof(szCaption));
85 }
86#endif
87 FormatMessageA(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
88 szText, 0, 0, szBuffer, sizeof(szBuffer), (va_list*)&szDir);
89
90 return (IDOK == MessageBoxA(GetActiveWindow(), szBuffer, szCaption, MB_OKCANCEL | MB_ICONEXCLAMATION));
91}
92
93/**************************************************************************
94 * SHELL_DeleteDirectoryA()
95 *
96 * like rm -r
97 */
98
99BOOL SHELL_DeleteDirectoryA(LPCSTR pszDir, BOOL bShowUI)
100{
101 BOOL ret = FALSE;
102 HANDLE hFind;
103 WIN32_FIND_DATAA wfd;
104 char szTemp[MAX_PATH];
105
106 strcpy(szTemp, pszDir);
107 PathAddBackslashA(szTemp);
108 strcat(szTemp, "*.*");
109
110 if (bShowUI && !SHELL_WarnItemDelete(ASK_DELETE_FOLDER, pszDir))
111 return FALSE;
112
113 if(INVALID_HANDLE_VALUE != (hFind = FindFirstFileA(szTemp, &wfd)))
114 {
115 do
116 {
117 if(strcasecmp(wfd.cFileName, ".") && strcasecmp(wfd.cFileName, ".."))
118 {
119 strcpy(szTemp, pszDir);
120 PathAddBackslashA(szTemp);
121 strcat(szTemp, wfd.cFileName);
122
123 if(FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)
124 SHELL_DeleteDirectoryA(szTemp, FALSE);
125 else
126 DeleteFileA(szTemp);
127 }
128 } while(FindNextFileA(hFind, &wfd));
129
130 FindClose(hFind);
131 ret = RemoveDirectoryA(pszDir);
132 }
133
134 return ret;
135}
136
137/**************************************************************************
138 * SHELL_DeleteFileA()
139 */
140
141BOOL SHELL_DeleteFileA(LPCSTR pszFile, BOOL bShowUI)
142{
143 if (bShowUI && !SHELL_WarnItemDelete(ASK_DELETE_FILE, pszFile))
144 return FALSE;
145
146 return DeleteFileA(pszFile);
147}
148
149/*************************************************************************
150 * SHCreateDirectory [SHELL32.165]
151 *
152 * NOTES
153 * exported by ordinal
154 * not sure about LPSECURITY_ATTRIBUTES
155 */
156DWORD WINAPI SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,LPCSTR path)
157{
158 DWORD ret;
159 TRACE("(%p,%s)\n",sec,path);
160 if ((ret = CreateDirectoryA(path,sec)))
161 {
162 SHChangeNotifyA(SHCNE_MKDIR, SHCNF_PATHA, path, NULL);
163 }
164 return ret;
165}
166
167/************************************************************************
168 * Win32DeleteFile [SHELL32.164]
169 *
170 * Deletes a file. Also triggers a change notify if one exists.
171 *
172 * FIXME:
173 * Verified on Win98 / IE 5 (SHELL32 4.72, March 1999 build) to be
174 * ANSI. Is this Unicode on NT?
175 *
176 */
177
178BOOL WINAPI Win32DeleteFile(LPSTR fName)
179{
180 TRACE("%p(%s)\n", fName, fName);
181
182 DeleteFileA(fName);
183 SHChangeNotifyA(SHCNE_DELETE, SHCNF_PATHA, fName, NULL);
184 return TRUE;
185}
186
187/*************************************************************************
188 * SHFileOperationA [SHELL32.243]
189 *
190 * NOTES
191 * exported by name
192 */
193DWORD WINAPI SHFileOperationA (LPSHFILEOPSTRUCTA lpFileOp)
194{
195 LPSTR pFrom = (LPSTR)lpFileOp->pFrom;
196 LPSTR pTo = (LPSTR)lpFileOp->pTo;
197#ifdef __WIN32OS2__
198 DWORD FromAttr;
199 DWORD ToAttr;
200 LPSTR pTempFrom = NULL;
201 LPSTR pTempTo;
202 LPSTR pFromFile;
203 LPSTR pToFile;
204
205 FILEOP_FLAGS OFl = ((FILEOP_FLAGS)lpFileOp->fFlags & 0x7ff);
206 BOOL Multi = TRUE;
207 BOOL withFileName;
208 BOOL not_overwrite;
209 BOOL ToSingle;
210 BOOL BothDir;
211 BOOL ToWithoutBackSlash;
212 long lenFrom = -1;
213 long lenTo = -1;
214 long lenTempFrom;
215 long lenTempTo;
216 long retCode = 0x75;
217 long TempretCode = 0;
218 long where = 0;
219 SHFILEOPSTRUCTA nlpFileOp = *(lpFileOp);
220 HANDLE hFind;
221 WIN32_FIND_DATAA wfd;
222
223/* default no error
224*/
225 lpFileOp->fAnyOperationsAborted=FALSE;
226 nlpFileOp.fAnyOperationsAborted=FALSE;
227#else
228 LPSTR pTempTo;
229#endif
230
231 switch(lpFileOp->wFunc) {
232 case FO_COPY:
233 TRACE("File Copy:\n");
234#ifdef __WIN32OS2__
235 pTempFrom = HeapAlloc(GetProcessHeap(), 0, 3 * MAX_PATH+6);
236 pTempTo = &pTempFrom[MAX_PATH+4];
237/*
238 * FOF_MULTIDESTFILES, FOF_NOCONFIRMATION, FOF_FILESONLY are implemented
239 * FOF_CONFIRMMOUSE, FOF_SILENT, FOF_NOCONFIRMMKDIR, FOF_SIMPLEPROGRESS are not implemented and ignored
240 * if any other flag set, an error occurs
241 */
242 OFl = (OFl & (-1 - (FOF_MULTIDESTFILES | FOF_FILESONLY)));
243 OFl = (OFl ^ (FOF_SILENT | FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR));
244 if (OFl) {
245 if (OFl & (-1 - (FOF_CONFIRMMOUSE | FOF_SILENT | FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR))) {
246 FIXME(__FUNCTION__" FO_COPY with this fFlags not implemented:%x ,stub\n",lpFileOp->fFlags);
247 lpFileOp->fAnyOperationsAborted=TRUE;
248 } else {
249// not FOF_SILENT, not FOF_SIMPLEPROGRESS, not FOF_NOCONFIRMMKDIR
250 FIXME(__FUNCTION__" FO_COPY with this lpFileOp->fFlags not full implemented:0x%x ,stub\n",lpFileOp->fFlags);
251 } /* endif */
252 } /* endif */
253
254 not_overwrite = (!(lpFileOp->fFlags & FOF_NOCONFIRMATION));
255
256// fix for more then one source for one target
257 pToFile = pTempTo;
258
259 while((pFrom+=lenFrom+1)[0] && !nlpFileOp.fAnyOperationsAborted) {
260
261 if (!withFileName && Multi && (pTo[lenTo+1]=='\0')) {
262// Win Bug ?
263 Multi = FALSE;
264 } /* endif */
265
266 if (Multi) pTo += lenTo + 1;
267 if(!pTo[0]) {
268 nlpFileOp.fAnyOperationsAborted=TRUE;
269 where = 213;
270 break;
271 }
272
273 TRACE(" From='%s' To='%s'\n", pFrom, pTo);
274
275// fix for more then one source for one target
276 pToFile[0] = '\0';
277 nlpFileOp.pTo = pTo;
278
279 lenFrom=strlen(pFrom);
280 strcpy(pTempFrom,pFrom);
281 FromAttr = GetFileAttributesA(pTempFrom);
282
283 if (Multi) {
284 lenTo = strlen(pTo);
285// single targetdir !Multi
286 Multi = (Multi && (lpFileOp->fFlags & FOF_MULTIDESTFILES));
287// multi target, each one for one source. ? last target + more than one source (all source files an one dir as target)
288
289 ToSingle = ((pTo[lenTo+1]=='\0') || !Multi);
290
291 strcpy(pTempTo,pTo);
292 PathRemoveBackslashA(pTempTo);
293 ToWithoutBackSlash = (strlen(pTempTo)==lenTo);
294 ToAttr = GetFileAttributesA(pTempTo);
295
296 BothDir = (Multi &&
297 ToWithoutBackSlash &&
298 (-1 != (FromAttr | ToAttr)) &&
299 (ToAttr & FromAttr & FILE_ATTRIBUTE_DIRECTORY));
300
301 withFileName = (!BothDir &&
302 (ToWithoutBackSlash || !ToSingle) &&
303 (ToAttr == -1 || !(ToAttr & FILE_ATTRIBUTE_DIRECTORY)));
304
305 if (withFileName) {
306// Target must not be an directory
307 PathRemoveFileSpecA(pTempTo);
308 ToAttr = GetFileAttributesA(pTempTo);
309 }
310 if ((ToAttr == -1) ||
311 !(ToAttr & FILE_ATTRIBUTE_DIRECTORY) ||
312 (!withFileName && !ToSingle) ) {
313 nlpFileOp.fAnyOperationsAborted=TRUE;
314 where = 201;
315 break;
316 }
317 lenTempTo = strlen(pTempTo);
318 withFileName = (((lenTempTo + 1) < lenTo) || (PathIsRootA(pTo) && lenTempTo < lenTo));
319 PathAddBackslashA(pTempTo);
320 }
321
322 if (FromAttr == -1 || BothDir) {
323// is Source an existing directory\*.* ?
324 if (FromAttr == -1) {
325 PathRemoveFileSpecA(pTempFrom);
326 FromAttr = GetFileAttributesA(pTempFrom);
327 }
328
329 PathAddBackslashA(pTempFrom);
330 lenTempFrom = strlen(pTempFrom);
331 pFromFile=&pTempFrom[lenTempFrom];
332
333 if (FromAttr == -1 ||
334 ((lenTempFrom==lenFrom) && !PathIsRootA(pFrom)) ||
335 !(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ||
336 !((0==strcmp(&pFrom[lenTempFrom],"*.*")) || BothDir)) {
337 retCode=0x402;
338 nlpFileOp.fAnyOperationsAborted=TRUE;
339 where = 202;
340 break;
341 }
342
343 strcpy(pFromFile, "*.*");
344 hFind = FindFirstFileA(pTempFrom, &wfd);
345 if (INVALID_HANDLE_VALUE == hFind) {
346 nlpFileOp.fAnyOperationsAborted=TRUE;
347 retCode=0x79;
348 where = 203;
349 break;
350 }
351
352 nlpFileOp.pFrom = pTempFrom;
353// single copy never with FOF_MULTIDESTFILES, I can use lpFileOp->pTo as nlpFileOp.pTo,
354// I need no different targetarea for the name
355 nlpFileOp.fFlags = (nlpFileOp.fFlags & (-1 - (FOF_MULTIDESTFILES)));
356
357 TRACE(__FUNCTION__" Copy between Subdir %s -> %s'\n", nlpFileOp.pFrom, nlpFileOp.pTo);
358
359 do {
360 TRACE(__FUNCTION__" find '%s'\n", wfd.cFileName);
361 if (0==strcmp(wfd.cFileName,".")) continue;
362 if (0==strcmp(wfd.cFileName,"..")) continue;
363 if ((nlpFileOp.fFlags & FOF_FILESONLY) && (FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)) {
364 continue;
365 } /* endif */
366
367 strcpy(pFromFile,wfd.cFileName);
368 pTempFrom[strlen(pTempFrom)+1]='\0';
369
370 TempretCode = SHFileOperationA (&nlpFileOp);
371
372 if (nlpFileOp.fAnyOperationsAborted) {where = 204;break;}
373
374 } while(FindNextFileA(hFind, &wfd));
375
376 FindClose(hFind);
377 if (nlpFileOp.fAnyOperationsAborted) {where = 205;break;}
378 continue;
379 }
380
381 lenTempTo = strlen(pTempTo);
382 pToFile = &pTempTo[lenTempTo];
383// Check Source
384 strcpy(pToFile,pTempFrom);
385 PathRemoveBackslashA(pToFile);
386 if (strlen(pToFile)<lenFrom) {
387 nlpFileOp.fAnyOperationsAborted=TRUE;
388 retCode=0x402;
389 where = 206;
390 break;
391 } /* endif */
392
393// target name in target or from source
394 pFromFile = NULL;
395 if (withFileName) {
396 if ((pFrom[lenFrom+1]=='\0') || (Multi && !(pTo[lenTo+1]=='\0'))) {
397 pFromFile = pTo;
398 } /* endif */
399 } else {
400// Multi Target
401 if (!Multi || !(pFrom[lenFrom+1]=='\0') ||
402// only target+\, target without \ has 0x402
403 (Multi && (FromAttr & ToAttr & FILE_ATTRIBUTE_DIRECTORY))) {
404 pFromFile = pTempFrom;
405 }
406 } /* endif */
407
408 if (!pFromFile) {
409 nlpFileOp.fAnyOperationsAborted=TRUE;
410 where = 207;
411 break;
412 } /* endif */
413
414// move isolated target filename
415 strcpy(pToFile,pFromFile);
416 PathRemoveFileSpecA(pToFile);
417 PathAddBackslashA(pToFile);
418
419 strcpy(pToFile,&pFromFile[strlen(pToFile)]);
420 ToAttr = GetFileAttributesA(pTempTo);
421
422 if (FromAttr == -1) {
423 FIXME(__FUNCTION__" FO_COPY with Source %s not implementiert ,stub\n",pTempFrom);
424 nlpFileOp.fAnyOperationsAborted=TRUE;
425 where = 208;
426 break;
427 }
428 if (FromAttr & FILE_ATTRIBUTE_DIRECTORY) {
429 if (ToAttr == -1) {
430// Try to create an new Directory and enter in it
431 TRACE(" Creating Directory '%s'\n", pTempTo);
432 SHCreateDirectory(NULL,pTempTo);
433 ToAttr = GetFileAttributesA(pTempTo);
434 if (ToAttr == -1) {
435 nlpFileOp.fAnyOperationsAborted=TRUE;
436 retCode=0x10003;
437 where = 209;
438 break;
439 }
440
441 lenTempTo = strlen(pTempTo);
442
443 PathAddBackslashA(pTempFrom);
444 strcat(pTempFrom, "*.*");
445 pTempFrom[strlen(pTempFrom)+1]='\0';
446 nlpFileOp.pFrom = pTempFrom;
447
448 pTempTo[lenTempTo+1]='\0';
449 nlpFileOp.pTo = pTempTo;
450
451 TRACE(__FUNCTION__" Entering Directory '%s'\n", nlpFileOp.pTo);
452 TempretCode = SHFileOperationA (&nlpFileOp);
453
454 if (nlpFileOp.fAnyOperationsAborted) {break;}
455 continue;
456
457 } else {
458 FIXME(__FUNCTION__" FO_COPY unexpected with %s -> %s ? ,stub\n",pTempFrom,pTo);
459 nlpFileOp.fAnyOperationsAborted=TRUE;
460 where = 210;
461 retCode=0x77;
462 break;
463
464 }
465
466 }
467
468 if (!(ToAttr == -1) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
469 nlpFileOp.fAnyOperationsAborted=TRUE;
470 where = 211;
471 break;
472 }
473 if (0==strcmp(pTempFrom, pTempTo)) {
474 nlpFileOp.fAnyOperationsAborted=TRUE;
475 retCode = 0x71;
476 where = 212;
477 break;
478 }
479// first try to copy
480 if (CopyFileA(pTempFrom, pTempTo, not_overwrite)) continue;
481
482 if (not_overwrite) {
483 if (SHELL_ConfirmDialog (ASK_OVERWRITE_FILE, pTempTo))
484// second try to copy after confirm
485 if (CopyFileA(pTempFrom, pTempTo, FALSE)) continue;
486 } /* endif */
487
488 nlpFileOp.fAnyOperationsAborted=TRUE;
489 where = 215;
490 }
491 break;
492#else
493 while(1) {
494 if(!pFrom[0]) break;
495 if(!pTo[0]) break;
496 TRACE(" From='%s' To='%s'\n", pFrom, pTo);
497
498 pTempTo = HeapAlloc(GetProcessHeap(), 0, strlen(pTo)+1);
499 if (pTempTo)
500 {
501 strcpy( pTempTo, pTo );
502 PathRemoveFileSpecA(pTempTo);
503 TRACE(" Creating Directory '%s'\n", pTempTo);
504 SHCreateDirectory(NULL,pTempTo);
505 HeapFree(GetProcessHeap(), 0, pTempTo);
506 }
507 CopyFileA(pFrom, pTo, FALSE);
508
509 pFrom += strlen(pFrom) + 1;
510 pTo += strlen(pTo) + 1;
511 }
512 TRACE("Setting AnyOpsAborted=FALSE\n");
513 lpFileOp->fAnyOperationsAborted=FALSE;
514 return 0;
515#endif
516
517 case FO_DELETE:
518 TRACE("File Delete:\n");
519#ifdef __WIN32OS2__
520 while((pFrom+=lenFrom+1)[0] && !nlpFileOp.fAnyOperationsAborted) {
521 lenFrom=strlen(pFrom);
522 FromAttr = GetFileAttributesA(pFrom);
523 if (!(FromAttr & FILE_ATTRIBUTE_DIRECTORY)) {
524 TRACE(" File='%s'\n", pFrom);
525 if (DeleteFileA(pFrom)) continue;
526 nlpFileOp.fAnyOperationsAborted=TRUE;
527// retCode = 0x71;
528 where = 301;
529 break;
530 }
531 if (!(pTempFrom)) pTempFrom = HeapAlloc(GetProcessHeap(), 0, MAX_PATH+2);
532 strcpy(pTempFrom,pFrom);
533 PathRemoveBackslashA(pTempFrom);
534 FromAttr = GetFileAttributesA(pTempFrom);
535 if (!(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ) {
536 nlpFileOp.fAnyOperationsAborted=TRUE;
537// retCode = 0x71;
538 where = 302;
539 break;
540 }
541// is Source an existing directory\*.* ?
542 if (FromAttr == -1) {
543 PathRemoveFileSpecA(pTempFrom);
544 FromAttr = GetFileAttributesA(pTempFrom);
545 }
546
547 PathAddBackslashA(pTempFrom);
548 lenTempFrom = strlen(pTempFrom);
549 pFromFile=&pTempFrom[lenTempFrom];
550
551 if (FromAttr == -1 ||
552 ((lenTempFrom==lenFrom) && !PathIsRootA(pFrom)) ||
553 !(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ||
554 !(('\0'==pFrom[lenTempFrom]) || (0==strcmp(&pFrom[lenTempFrom],"*.*"))) ) {
555 retCode=0x402;
556 nlpFileOp.fAnyOperationsAborted=TRUE;
557 where = 303;
558 break;
559 }
560 strcpy(pFromFile, "*.*");
561 lenTempFrom = strlen(pTempFrom);
562 if (lenFrom < lenTempFrom) {
563// Source is without \*.*
564 pTempFrom[lenTempFrom+1]='\0';
565 nlpFileOp.pFrom = pTempFrom;
566
567 TRACE(__FUNCTION__" Entering Directory '%s'\n", nlpFileOp.pFrom);
568 TempretCode = SHFileOperationA (&nlpFileOp);
569
570 if (nlpFileOp.fAnyOperationsAborted) {break;}
571// Call SHELL_DeleteDirectoryA ?
572 if (RemoveDirectoryA(pFrom)) continue;
573 nlpFileOp.fAnyOperationsAborted=TRUE;
574 where = 304;
575 break;
576 }
577 hFind = FindFirstFileA(pTempFrom, &wfd);
578 if (INVALID_HANDLE_VALUE == hFind) {
579 nlpFileOp.fAnyOperationsAborted=TRUE;
580 retCode=0x79;
581 where = 303;
582 break;
583 }
584
585 nlpFileOp.pFrom = pTempFrom;
586// single copy never with FOF_MULTIDESTFILES, I can use lpFileOp->pTo as nlpFileOp.pTo,
587// I need no different targetarea for the name
588 nlpFileOp.fFlags = (nlpFileOp.fFlags & (-1 - (FOF_MULTIDESTFILES)));
589
590 TRACE(__FUNCTION__" Delete in Subdir %s'\n", nlpFileOp.pFrom);
591
592 do {
593 TRACE(__FUNCTION__" find '%s'\n", wfd.cFileName);
594 if (0==strcmp(wfd.cFileName,".")) continue;
595 if (0==strcmp(wfd.cFileName,"..")) continue;
596 if ((nlpFileOp.fFlags & FOF_FILESONLY) && (FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)) {
597 continue;
598 } /* endif */
599
600 strcpy(pFromFile,wfd.cFileName);
601 pTempFrom[strlen(pTempFrom)+1]='\0';
602
603 TempretCode = SHFileOperationA (&nlpFileOp);
604
605 if (nlpFileOp.fAnyOperationsAborted) {where = 304;break;}
606
607 } while(FindNextFileA(hFind, &wfd));
608
609 FindClose(hFind);
610 if (nlpFileOp.fAnyOperationsAborted) {where = 305;break;}
611 continue;
612 }
613 break;
614 case FO_MOVE:
615 TRACE("File\\Tree Move: simply (Copy/Delete)\n");
616 nlpFileOp.wFunc = FO_COPY;
617// not delete at error from copy
618 TempretCode = SHFileOperationA (&nlpFileOp);
619
620 if (nlpFileOp.fAnyOperationsAborted) {
621 if (TempretCode == 0x75) {
622// not all, the most
623 TempretCode = 0xD7;
624 retCode = 0xD7;
625 } /* endif */
626 break;
627 }
628
629 nlpFileOp.wFunc = FO_DELETE;
630
631 TempretCode = SHFileOperationA (&nlpFileOp);
632
633 case 0:
634 break;
635#else
636 while(1) {
637 if(!pFrom[0]) break;
638 TRACE(" File='%s'\n", pFrom);
639 DeleteFileA(pFrom);
640 pFrom += strlen(pFrom) + 1;
641 }
642 TRACE("Setting AnyOpsAborted=FALSE\n");
643 lpFileOp->fAnyOperationsAborted=FALSE;
644 return 0;
645#endif
646
647 default:
648#ifdef __WIN32OS2__
649 FIXME(__FUNCTION__" Unhandled shell file operation %d stub\n", lpFileOp->wFunc);
650#else
651 FIXME("Unhandled shell file operation %d\n", lpFileOp->wFunc);
652#endif
653 return 1;
654 }
655
656#ifdef __WIN32OS2__
657 if (pTempFrom) HeapFree(GetProcessHeap(), 0, pTempFrom);
658
659 if (nlpFileOp.fAnyOperationsAborted) {
660 lpFileOp->fAnyOperationsAborted=TRUE;
661 if (TempretCode > retCode) {
662 retCode = TempretCode;
663 } /* endif */
664 }
665 if (lpFileOp->fAnyOperationsAborted==TRUE) {
666 if (FO_DELETE == lpFileOp->wFunc) {
667 TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE ret=0x%x, at=%i with %s\n",retCode,where,pFrom);
668 } else {
669 TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE ret=0x%x, at=%i with %s -> %s\n",retCode,where,pFrom,pTo);
670 }
671 return retCode;
672 } /* endif */
673 TRACE(__FUNCTION__" Setting AnyOpsAborted=FALSE\n");
674 return 0;
675
676#endif
677}
678
679/*************************************************************************
680 * SHFileOperationW [SHELL32.244]
681 *
682 * NOTES
683 * exported by name
684 */
685DWORD WINAPI SHFileOperationW (LPSHFILEOPSTRUCTW lpFileOp)
686{
687#ifdef __WIN32OS2__
688 FIXME(__FUNCTION__"(%p) ,stub\n", lpFileOp);
689#else
690 FIXME("(%p):stub.\n", lpFileOp);
691#endif
692 return 1;
693}
694
695/*************************************************************************
696 * SHFileOperation [SHELL32.242]
697 *
698 */
699DWORD WINAPI SHFileOperationAW(LPVOID lpFileOp)
700{
701 if (SHELL_OsIsUnicode())
702 return SHFileOperationW(lpFileOp);
703 return SHFileOperationA(lpFileOp);
704}
705
706/*************************************************************************
707 * SheGetDirW [SHELL32.281]
708 *
709 */
710HRESULT WINAPI SheGetDirW(LPWSTR u, LPWSTR v)
711#ifdef __WIN32OS2__
712{ FIXME(__FUNCTION__"(%p, %p) ,stub\n",u,v);
713#else
714{ FIXME("%p %p stub\n",u,v);
715#endif
716 return 0;
717}
718
719/*************************************************************************
720 * SheChangeDirW [SHELL32.274]
721 *
722 */
723HRESULT WINAPI SheChangeDirW(LPWSTR u)
724#ifdef __WIN32OS2__
725{ FIXME(__FUNCTION__"(%s),stub\n",debugstr_w(u));
726#else
727{ FIXME("(%s),stub\n",debugstr_w(u));
728#endif
729 return 0;
730}
731
732/*************************************************************************
733 * IsNetDrive [SHELL32.66]
734 */
735BOOL WINAPI IsNetDrive(DWORD drive)
736{
737 char root[4];
738 strcpy(root, "A:\\");
739 root[0] += drive;
740 return (GetDriveTypeA(root) == DRIVE_REMOTE);
741}
742
Note: See TracBrowser for help on using the repository browser.