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

Last change on this file since 6706 was 6650, checked in by bird, 24 years ago

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