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

Last change on this file since 6502 was 5661, checked in by sandervl, 24 years ago

DT: update
File size: 24.4 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// need break at error before change sourcepointer
260 while(!nlpFileOp.fAnyOperationsAborted && (pFrom+=lenFrom+1)[0]) {
261
262 if (!withFileName && Multi && (pTo[lenTo+1]=='\0')) {
263// Win Bug ?
264 Multi = FALSE;
265 } /* endif */
266
267 if (Multi) pTo += lenTo + 1;
268 if(!pTo[0]) {
269 nlpFileOp.fAnyOperationsAborted=TRUE;
270 where = 213;
271 break;
272 }
273
274 TRACE(" From='%s' To='%s'\n", pFrom, pTo);
275
276// fix for more then one source for one target
277 pToFile[0] = '\0';
278 nlpFileOp.pTo = pTo;
279
280 lenFrom=strlen(pFrom);
281 strcpy(pTempFrom,pFrom);
282 FromAttr = GetFileAttributesA(pTempFrom);
283
284 if (Multi) {
285 lenTo = strlen(pTo);
286// single targetdir !Multi
287 Multi = (Multi && (lpFileOp->fFlags & FOF_MULTIDESTFILES));
288// multi target, each one for one source. ? last target + more than one source (all source files an one dir as target)
289
290 ToSingle = ((pTo[lenTo+1]=='\0') || !Multi);
291
292 strcpy(pTempTo,pTo);
293 PathRemoveBackslashA(pTempTo);
294 ToWithoutBackSlash = (strlen(pTempTo)==lenTo);
295 ToAttr = GetFileAttributesA(pTempTo);
296
297 BothDir = (Multi &&
298 ToWithoutBackSlash &&
299 (-1 != (FromAttr | ToAttr)) &&
300 (ToAttr & FromAttr & FILE_ATTRIBUTE_DIRECTORY));
301
302 withFileName = (!BothDir &&
303 (ToWithoutBackSlash || !ToSingle) &&
304 (ToAttr == -1 || !(ToAttr & FILE_ATTRIBUTE_DIRECTORY)));
305
306 if (withFileName) {
307// Target must not be an directory
308 PathRemoveFileSpecA(pTempTo);
309 ToAttr = GetFileAttributesA(pTempTo);
310 }
311 if ((ToAttr == -1) ||
312 !(ToAttr & FILE_ATTRIBUTE_DIRECTORY) ||
313 (!withFileName && !ToSingle) ) {
314 nlpFileOp.fAnyOperationsAborted=TRUE;
315 where = 201;
316 break;
317 }
318 lenTempTo = strlen(pTempTo);
319 withFileName = (((lenTempTo + 1) < lenTo) || (PathIsRootA(pTo) && lenTempTo < lenTo));
320 PathAddBackslashA(pTempTo);
321 }
322
323 if (FromAttr == -1 || BothDir) {
324// is Source an existing directory\*.* ?
325 if (FromAttr == -1) {
326 PathRemoveFileSpecA(pTempFrom);
327 FromAttr = GetFileAttributesA(pTempFrom);
328 }
329
330 PathAddBackslashA(pTempFrom);
331 lenTempFrom = strlen(pTempFrom);
332 pFromFile=&pTempFrom[lenTempFrom];
333
334 if (FromAttr == -1 ||
335 ((lenTempFrom==lenFrom) && !PathIsRootA(pFrom)) ||
336 !(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ||
337 !((0==strcmp(&pFrom[lenTempFrom],"*.*")) || BothDir)) {
338 retCode=0x402;
339 nlpFileOp.fAnyOperationsAborted=TRUE;
340 where = 202;
341 break;
342 }
343
344 strcpy(pFromFile, "*.*");
345 hFind = FindFirstFileA(pTempFrom, &wfd);
346 if (INVALID_HANDLE_VALUE == hFind) {
347 nlpFileOp.fAnyOperationsAborted=TRUE;
348 retCode=0x79;
349 where = 203;
350 break;
351 }
352
353 nlpFileOp.pFrom = pTempFrom;
354// single copy never with FOF_MULTIDESTFILES, I can use lpFileOp->pTo as nlpFileOp.pTo,
355// I need no different targetarea for the name
356 nlpFileOp.fFlags = (nlpFileOp.fFlags & (-1 - (FOF_MULTIDESTFILES)));
357
358 TRACE(__FUNCTION__" Copy between Subdir %s -> %s'\n", nlpFileOp.pFrom, nlpFileOp.pTo);
359
360 do {
361 TRACE(__FUNCTION__" find '%s'\n", wfd.cFileName);
362 if (0==strcmp(wfd.cFileName,".")) continue;
363 if (0==strcmp(wfd.cFileName,"..")) continue;
364 if ((nlpFileOp.fFlags & FOF_FILESONLY) && (FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)) {
365 continue;
366 } /* endif */
367
368 strcpy(pFromFile,wfd.cFileName);
369 pTempFrom[strlen(pTempFrom)+1]='\0';
370
371 TempretCode = SHFileOperationA (&nlpFileOp);
372
373 if (nlpFileOp.fAnyOperationsAborted) {where = 204;break;}
374
375 } while(FindNextFileA(hFind, &wfd));
376
377 FindClose(hFind);
378 if (nlpFileOp.fAnyOperationsAborted) {where = 205;break;}
379 continue;
380 }
381
382 lenTempTo = strlen(pTempTo);
383 pToFile = &pTempTo[lenTempTo];
384// Check Source
385 strcpy(pToFile,pTempFrom);
386 PathRemoveBackslashA(pToFile);
387 if (strlen(pToFile)<lenFrom) {
388 nlpFileOp.fAnyOperationsAborted=TRUE;
389 retCode=0x402;
390 where = 206;
391 break;
392 } /* endif */
393
394// target name in target or from source
395 pFromFile = NULL;
396 if (withFileName) {
397 if ((pFrom[lenFrom+1]=='\0') || (Multi && !(pTo[lenTo+1]=='\0'))) {
398 pFromFile = pTo;
399 } /* endif */
400 } else {
401// Multi Target
402 if (!Multi || !(pFrom[lenFrom+1]=='\0') ||
403// only target+\, target without \ has 0x402
404 (Multi && (FromAttr & ToAttr & FILE_ATTRIBUTE_DIRECTORY))) {
405 pFromFile = pTempFrom;
406 }
407 } /* endif */
408
409 if (!pFromFile) {
410 nlpFileOp.fAnyOperationsAborted=TRUE;
411 where = 207;
412 break;
413 } /* endif */
414
415// move isolated target filename
416 strcpy(pToFile,pFromFile);
417 PathRemoveFileSpecA(pToFile);
418 PathAddBackslashA(pToFile);
419
420 strcpy(pToFile,&pFromFile[strlen(pToFile)]);
421 ToAttr = GetFileAttributesA(pTempTo);
422
423 if (FromAttr == -1) {
424 FIXME(__FUNCTION__" FO_COPY with Source %s not implementiert ,stub\n",pTempFrom);
425 nlpFileOp.fAnyOperationsAborted=TRUE;
426 where = 208;
427 break;
428 }
429 if (FromAttr & FILE_ATTRIBUTE_DIRECTORY) {
430 if (ToAttr == -1) {
431// Try to create an new Directory and enter in it
432 TRACE(" Creating Directory '%s'\n", pTempTo);
433 SHCreateDirectory(NULL,pTempTo);
434 ToAttr = GetFileAttributesA(pTempTo);
435 if (ToAttr == -1) {
436 nlpFileOp.fAnyOperationsAborted=TRUE;
437 retCode=0x10003;
438 where = 209;
439 break;
440 }
441
442 lenTempTo = strlen(pTempTo);
443
444 PathAddBackslashA(pTempFrom);
445 strcat(pTempFrom, "*.*");
446 pTempFrom[strlen(pTempFrom)+1]='\0';
447 nlpFileOp.pFrom = pTempFrom;
448
449 pTempTo[lenTempTo+1]='\0';
450 nlpFileOp.pTo = pTempTo;
451
452 TRACE(__FUNCTION__" Entering Directory '%s'\n", nlpFileOp.pTo);
453 TempretCode = SHFileOperationA (&nlpFileOp);
454
455 if (nlpFileOp.fAnyOperationsAborted) {break;}
456 continue;
457
458 } else {
459 FIXME(__FUNCTION__" FO_COPY unexpected with %s -> %s ? ,stub\n",pTempFrom,pTo);
460 nlpFileOp.fAnyOperationsAborted=TRUE;
461 where = 210;
462 retCode=0x77;
463 break;
464
465 }
466
467 }
468
469 if (!(ToAttr == -1) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
470 nlpFileOp.fAnyOperationsAborted=TRUE;
471 where = 211;
472 break;
473 }
474 if (0==strcmp(pTempFrom, pTempTo)) {
475 nlpFileOp.fAnyOperationsAborted=TRUE;
476 retCode = 0x71;
477 where = 212;
478 break;
479 }
480// first try to copy
481 if (CopyFileA(pTempFrom, pTempTo, not_overwrite)) continue;
482
483 if (not_overwrite) {
484 if (SHELL_ConfirmDialog (ASK_OVERWRITE_FILE, pTempTo))
485// second try to copy after confirm
486 if (CopyFileA(pTempFrom, pTempTo, FALSE)) continue;
487 } /* endif */
488
489 nlpFileOp.fAnyOperationsAborted=TRUE;
490 where = 215;
491 }
492 break;
493#else
494 while(1) {
495 if(!pFrom[0]) break;
496 if(!pTo[0]) break;
497 TRACE(" From='%s' To='%s'\n", pFrom, pTo);
498
499 pTempTo = HeapAlloc(GetProcessHeap(), 0, strlen(pTo)+1);
500 if (pTempTo)
501 {
502 strcpy( pTempTo, pTo );
503 PathRemoveFileSpecA(pTempTo);
504 TRACE(" Creating Directory '%s'\n", pTempTo);
505 SHCreateDirectory(NULL,pTempTo);
506 HeapFree(GetProcessHeap(), 0, pTempTo);
507 }
508 CopyFileA(pFrom, pTo, FALSE);
509
510 pFrom += strlen(pFrom) + 1;
511 pTo += strlen(pTo) + 1;
512 }
513 TRACE("Setting AnyOpsAborted=FALSE\n");
514 lpFileOp->fAnyOperationsAborted=FALSE;
515 return 0;
516#endif
517
518 case FO_DELETE:
519 TRACE("File Delete:\n");
520#ifdef __WIN32OS2__
521// need break at error before change sourcepointer
522 while(!nlpFileOp.fAnyOperationsAborted && (pFrom+=lenFrom+1)[0]) {
523 lenFrom=strlen(pFrom);
524 FromAttr = GetFileAttributesA(pFrom);
525 if (!(FromAttr & FILE_ATTRIBUTE_DIRECTORY)) {
526 TRACE(" File='%s'\n", pFrom);
527 if (DeleteFileA(pFrom)) continue;
528 nlpFileOp.fAnyOperationsAborted=TRUE;
529// retCode = 0x71;
530 where = 301;
531 break;
532 }
533 if (!(pTempFrom)) pTempFrom = HeapAlloc(GetProcessHeap(), 0, MAX_PATH+2);
534 strcpy(pTempFrom,pFrom);
535 PathRemoveBackslashA(pTempFrom);
536 FromAttr = GetFileAttributesA(pTempFrom);
537 if (!(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ) {
538 nlpFileOp.fAnyOperationsAborted=TRUE;
539// retCode = 0x71;
540 where = 302;
541 break;
542 }
543// is Source an existing directory\*.* ?
544 if (FromAttr == -1) {
545 PathRemoveFileSpecA(pTempFrom);
546 FromAttr = GetFileAttributesA(pTempFrom);
547 }
548
549 PathAddBackslashA(pTempFrom);
550 lenTempFrom = strlen(pTempFrom);
551 pFromFile=&pTempFrom[lenTempFrom];
552
553 if (FromAttr == -1 ||
554 ((lenTempFrom==lenFrom) && !PathIsRootA(pFrom)) ||
555 !(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ||
556 !(('\0'==pFrom[lenTempFrom]) || (0==strcmp(&pFrom[lenTempFrom],"*.*"))) ) {
557 retCode=0x402;
558 nlpFileOp.fAnyOperationsAborted=TRUE;
559 where = 303;
560 break;
561 }
562 strcpy(pFromFile, "*.*");
563 lenTempFrom = strlen(pTempFrom);
564 if (lenFrom < lenTempFrom) {
565// Source is without \*.*
566 pTempFrom[lenTempFrom+1]='\0';
567 nlpFileOp.pFrom = pTempFrom;
568
569 TRACE(__FUNCTION__" Entering Directory '%s'\n", nlpFileOp.pFrom);
570 TempretCode = SHFileOperationA (&nlpFileOp);
571
572 if (nlpFileOp.fAnyOperationsAborted) {break;}
573// Call SHELL_DeleteDirectoryA ?
574 if (RemoveDirectoryA(pFrom)) continue;
575 nlpFileOp.fAnyOperationsAborted=TRUE;
576 where = 304;
577 break;
578 }
579 hFind = FindFirstFileA(pTempFrom, &wfd);
580 if (INVALID_HANDLE_VALUE == hFind) {
581 nlpFileOp.fAnyOperationsAborted=TRUE;
582 retCode=0x79;
583 where = 303;
584 break;
585 }
586
587 nlpFileOp.pFrom = pTempFrom;
588// single copy never with FOF_MULTIDESTFILES, I can use lpFileOp->pTo as nlpFileOp.pTo,
589// I need no different targetarea for the name
590 nlpFileOp.fFlags = (nlpFileOp.fFlags & (-1 - (FOF_MULTIDESTFILES)));
591
592 TRACE(__FUNCTION__" Delete in Subdir %s'\n", nlpFileOp.pFrom);
593
594 do {
595 TRACE(__FUNCTION__" find '%s'\n", wfd.cFileName);
596 if (0==strcmp(wfd.cFileName,".")) continue;
597 if (0==strcmp(wfd.cFileName,"..")) continue;
598 if ((nlpFileOp.fFlags & FOF_FILESONLY) && (FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)) {
599 continue;
600 } /* endif */
601
602 strcpy(pFromFile,wfd.cFileName);
603 pTempFrom[strlen(pTempFrom)+1]='\0';
604
605 TempretCode = SHFileOperationA (&nlpFileOp);
606
607 if (nlpFileOp.fAnyOperationsAborted) {where = 304;break;}
608
609 } while(FindNextFileA(hFind, &wfd));
610
611 FindClose(hFind);
612 if (nlpFileOp.fAnyOperationsAborted) {where = 305;break;}
613 continue;
614 }
615 break;
616 case FO_MOVE:
617 TRACE("File\\Tree Move: simply (Copy/Delete)\n");
618 nlpFileOp.wFunc = FO_COPY;
619// not delete at error from copy
620 TempretCode = SHFileOperationA (&nlpFileOp);
621
622 if (nlpFileOp.fAnyOperationsAborted) {
623 if (TempretCode == 0x75) {
624// not all, the most
625 TempretCode = 0xD7;
626 retCode = 0xD7;
627 } /* endif */
628 break;
629 }
630
631 nlpFileOp.wFunc = FO_DELETE;
632
633 TempretCode = SHFileOperationA (&nlpFileOp);
634
635 case 0:
636 break;
637#else
638 while(1) {
639 if(!pFrom[0]) break;
640 TRACE(" File='%s'\n", pFrom);
641 DeleteFileA(pFrom);
642 pFrom += strlen(pFrom) + 1;
643 }
644 TRACE("Setting AnyOpsAborted=FALSE\n");
645 lpFileOp->fAnyOperationsAborted=FALSE;
646 return 0;
647#endif
648
649 default:
650#ifdef __WIN32OS2__
651 FIXME(__FUNCTION__" Unhandled shell file operation %d stub\n", lpFileOp->wFunc);
652#else
653 FIXME("Unhandled shell file operation %d\n", lpFileOp->wFunc);
654 }
655#endif
656 return 1;
657
658#ifdef __WIN32OS2__
659 }
660 if (pTempFrom) HeapFree(GetProcessHeap(), 0, pTempFrom);
661
662 if (nlpFileOp.fAnyOperationsAborted) {
663 lpFileOp->fAnyOperationsAborted=TRUE;
664 if (TempretCode > retCode) {
665 retCode = TempretCode;
666 } /* endif */
667 }
668 if (lpFileOp->fAnyOperationsAborted==TRUE) {
669 if (FO_DELETE == lpFileOp->wFunc) {
670 TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE ret=0x%x, at=%i with %s\n",retCode,where,pFrom);
671 } else {
672 TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE ret=0x%x, at=%i with %s -> %s\n",retCode,where,pFrom,pTo);
673 }
674 return retCode;
675 } /* endif */
676 TRACE(__FUNCTION__" Setting AnyOpsAborted=FALSE\n");
677 return 0;
678
679#endif
680}
681
682/*************************************************************************
683 * SHFileOperationW [SHELL32.244]
684 *
685 * NOTES
686 * exported by name
687 */
688DWORD WINAPI SHFileOperationW (LPSHFILEOPSTRUCTW lpFileOp)
689{
690#ifdef __WIN32OS2__
691 FIXME(__FUNCTION__"(%p) ,stub\n", lpFileOp);
692#else
693 FIXME("(%p):stub.\n", lpFileOp);
694#endif
695 return 1;
696}
697
698/*************************************************************************
699 * SHFileOperation [SHELL32.242]
700 *
701 */
702DWORD WINAPI SHFileOperationAW(LPVOID lpFileOp)
703{
704 if (SHELL_OsIsUnicode())
705 return SHFileOperationW(lpFileOp);
706 return SHFileOperationA(lpFileOp);
707}
708
709/*************************************************************************
710 * SheGetDirW [SHELL32.281]
711 *
712 */
713HRESULT WINAPI SheGetDirW(LPWSTR u, LPWSTR v)
714#ifdef __WIN32OS2__
715{ FIXME(__FUNCTION__"(%p, %p) ,stub\n",u,v);
716#else
717{ FIXME("%p %p stub\n",u,v);
718#endif
719 return 0;
720}
721
722/*************************************************************************
723 * SheChangeDirW [SHELL32.274]
724 *
725 */
726HRESULT WINAPI SheChangeDirW(LPWSTR u)
727#ifdef __WIN32OS2__
728{ FIXME(__FUNCTION__"(%s),stub\n",debugstr_w(u));
729#else
730{ FIXME("(%s),stub\n",debugstr_w(u));
731#endif
732 return 0;
733}
734
735/*************************************************************************
736 * IsNetDrive [SHELL32.66]
737 */
738BOOL WINAPI IsNetDrive(DWORD drive)
739{
740 char root[4];
741 strcpy(root, "A:\\");
742 root[0] += drive;
743 return (GetDriveTypeA(root) == DRIVE_REMOTE);
744}
745
746
Note: See TracBrowser for help on using the repository browser.