Changeset 5623 for trunk/src


Ignore:
Timestamp:
Apr 28, 2001, 6:14:33 PM (24 years ago)
Author:
sandervl
Message:

SHFileOperationA updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shlfileop.c

    r5576 r5623  
    185185}
    186186
    187 #ifdef __WIN32OS2__
    188 /************************************************************************
    189  *      Creation from dir for SHFileOperation (FO_COPY)
    190  *
    191  */
    192 
    193 LPSTR DirForFileOperationA (LPSTR pTo, DWORD *dwAttr, LPSHFILEOPSTRUCTA lpFileOp, BOOL toSingle)
    194 {
    195 
    196         LPSTR pTempTo = NULL;
    197         long lenTo;
    198         BOOL withFileName = FALSE;
    199         if(pTo[0]) {
    200                 lenTo = strlen(pTo);
    201                 pTempTo = HeapAlloc(GetProcessHeap(), 0, lenTo + MAX_PATH);
    202 
    203         }
    204         *dwAttr = -1;
    205         if (pTempTo) {
    206                 strcpy(pTempTo,pTo);
    207                 PathRemoveBackslashA(pTempTo);
    208                 *dwAttr = GetFileAttributesA(pTempTo);
    209                 if (*(dwAttr) == -1 || !(*(dwAttr) & FILE_ATTRIBUTE_DIRECTORY)) {
    210                         withFileName = ((lenTo == strlen(pTempTo)) || !toSingle);
    211                         if (withFileName) {
    212 // Target must not be an directory
    213                                 PathRemoveFileSpecA(pTempTo);
    214                                 *(dwAttr) = GetFileAttributesA(pTempTo);
    215                         }
    216                 }
    217                 if ((*(dwAttr) == -1) ||
    218                   ( !(*(dwAttr) & FILE_ATTRIBUTE_DIRECTORY) || (!withFileName && !toSingle) )) {
    219 // !toSingle == !(&pTo[strlen(pTo)+1]=="\0") redundant ?
    220                         if (!withFileName && !toSingle) {
    221                                 FIXME(__FUNCTION__" FO_COPY tagetdir and FOF_MULTIDESTFILES not implemented ? ,stub\n");
    222                         };
    223 // never Create directory at this time
    224                                 HeapFree(GetProcessHeap(), 0, pTempTo);
    225                                 pTempTo = NULL;
    226 //                      }
    227                 }
    228         }
    229         if (!pTempTo) lpFileOp->fAnyOperationsAborted=TRUE;
    230         return pTempTo;
    231 }
    232 #endif
    233 
    234187/*************************************************************************
    235188 * SHFileOperationA                             [SHELL32.243]
    … …  
    243196        LPSTR pTo = (LPSTR)lpFileOp->pTo;
    244197#ifdef __WIN32OS2__
    245         DWORD ToAttr;
    246         DWORD FromAttr;
    247         LPSTR pToFile;
    248         LPSTR pTempTo = NULL;
    249         LPSTR pTempFrom;
    250 
    251         FILEOP_FLAGS OFl = ((FILEOP_FLAGS)lpFileOp->fFlags & 0x7ff);
    252         BOOL Multi = (lpFileOp->fFlags & FOF_MULTIDESTFILES);
    253         BOOL withFileName = FALSE;
    254         BOOL not_overwrite;
    255         BOOL copyOk;
    256         long lenTo;
     198        DWORD FromAttr;
     199        DWORD ToAttr;
     200        LPSTR pTempTo = NULL;
     201        LPSTR pTempFrom;
     202        LPSTR pNextFrom;
     203        LPSTR pNextTo;
     204        LPSTR pToFile;
     205
     206        FILEOP_FLAGS OFl = ((FILEOP_FLAGS)lpFileOp->fFlags & 0x7ff);
     207        BOOL Multi = TRUE;
     208        BOOL withFileName = FALSE;
     209        BOOL not_overwrite;
     210        BOOL toSingle;
     211        BOOL StarStar;
     212        BOOL copyOk;
     213        long lenFrom = -1;
     214        long lenTo   = -1;
     215        long lenTempTo;
     216        long retCode = 0x75;
     217        long TempretCode = 0;
     218        long lenNextFrom;
     219        long lenNextTo;
     220        SHFILEOPSTRUCTA nlpFileOp = *(lpFileOp);
     221        HANDLE  hFind;
     222        WIN32_FIND_DATAA wfd;
     223
    257224/* default no error
    258225*/
    259226        lpFileOp->fAnyOperationsAborted=FALSE;
     227        nlpFileOp.fAnyOperationsAborted=FALSE;
    260228#else
    261229        LPSTR pTempTo;
    … …  
    266234                TRACE("File Copy:\n");
    267235#ifdef __WIN32OS2__
     236            pTempTo = HeapAlloc(GetProcessHeap(), 0, 4 * MAX_PATH+4);
     237            pNextFrom = &pTempTo[2*MAX_PATH+2];
     238            pNextTo = &pNextFrom[MAX_PATH+1];
    268239/*
    269  * FOF_MULTIDESTFILES, FOF_NOCONFIRMATION                               are     implemented
     240 * FOF_MULTIDESTFILES, FOF_NOCONFIRMATION, FOF_FILESONLY                                are     implemented
    270241 * FOF_CONFIRMMOUSE, FOF_SILENT, FOF_NOCONFIRMMKDIR, FOF_SIMPLEPROGRESS are not implemented and ignored
    271242 * if any other flag set, an error occurs
    272243 */ 
    273                 OFl = (OFl & (-1 - (FOF_MULTIDESTFILES)));
    274                 OFl = (OFl ^ (FOF_SILENT | FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR));
    275                 if (OFl) {
    276                         if (OFl & (-1 - (FOF_CONFIRMMOUSE | FOF_SILENT | FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR))) {
    277                                 FIXME(__FUNCTION__" FO_COPY with this fFlags not implemented:%2x ,stub\n",lpFileOp->fFlags);
    278                                 lpFileOp->fAnyOperationsAborted=TRUE;
    279                         } else {
     244            OFl = (OFl & (-1 - (FOF_MULTIDESTFILES | FOF_FILESONLY)));
     245            OFl = (OFl ^ (FOF_SILENT | FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR));
     246            if (OFl) {
     247                if (OFl & (-1 - (FOF_CONFIRMMOUSE | FOF_SILENT | FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOCONFIRMMKDIR))) {
     248                    FIXME(__FUNCTION__" FO_COPY with this fFlags not implemented:%2x ,stub\n",lpFileOp->fFlags);
     249                    lpFileOp->fAnyOperationsAborted=TRUE;
     250                } else {
    280251// not FOF_SILENT, not FOF_SIMPLEPROGRESS, not FOF_NOCONFIRMMKDIR
    281                                 FIXME(__FUNCTION__" FO_COPY with this fFlags not full implemented:%2x ,stub\n",lpFileOp->fFlags);
    282                         } /* endif */             
    283                 } /* endif */
    284 
    285                 not_overwrite = (!(lpFileOp->fFlags & FOF_NOCONFIRMATION));
    286                 while(!Multi && !lpFileOp->fAnyOperationsAborted) {
    287 // single targetdir
    288                         pTempTo = DirForFileOperationA(pTo, &ToAttr, lpFileOp, TRUE);
    289 
    290                         if (!pTempTo) break;
    291 
    292                         lenTo = strlen(pTempTo);
    293                         withFileName = (((lenTo + 1) <  strlen(pTo)) || (PathIsRootA(pTo) && lenTo < strlen(pTo)));
    294                         PathAddBackslashA(pTempTo);
    295                         break;
    296                 }
    297                 if (!lpFileOp->fAnyOperationsAborted) {
    298                         TRACE("File Copy:\n");
    299 #ifdef __WIN32OS2__
    300                   while(pFrom[0]) {
    301 #endif
    302                                 if(!pTo[0]) break;
    303 
    304                                 TRACE("   From='%s' To='%s'\n", pFrom, pTo);
    305 
    306                                 if (Multi) {
    307 // multi target, each one for one source. ? last
    308                                         pTempTo = DirForFileOperationA(pTo, &ToAttr, lpFileOp, FALSE);
    309                                         if (pTempTo) {
    310 
    311                                                 lenTo = strlen(pTempTo);
    312                                                 withFileName = (((lenTo + 1) <  strlen(pTo)) || (PathIsRootA(pTo) && lenTo < strlen(pTo)));
    313                                                 PathAddBackslashA(pTempTo);
    314                                         }
    315                                 }
    316                                 if (pTempTo) {
    317                                         lenTo = strlen(pTempTo);
    318                                         pToFile = &pTempTo[lenTo];
     252                    FIXME(__FUNCTION__" FO_COPY with this lpFileOp->fFlags not full implemented:0x%2x ,stub\n",lpFileOp->fFlags);
     253                } /* endif */             
     254            } /* endif */
     255
     256            not_overwrite = (!(lpFileOp->fFlags & FOF_NOCONFIRMATION));
     257
     258// fix for more then one source for one target
     259            pToFile = pTempTo;
     260
     261            while((pFrom+=lenFrom+1)[0] && !nlpFileOp.fAnyOperationsAborted) {
     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]) break;
     270
     271                TRACE("   From='%s' To='%s'\n", pFrom, pTo);
     272
     273// fix for more then one source for one target
     274                pToFile[0] = '\0';
     275
     276                lenFrom=strlen(pFrom);
     277                strcpy(pNextFrom,pFrom);
     278                FromAttr = GetFileAttributesA(pNextFrom);
     279                StarStar = FALSE;
     280
     281                if (Multi) {
     282                    lenTo = strlen(pTo);
     283//  single targetdir !Multi
     284                    Multi = (Multi && (lpFileOp->fFlags & FOF_MULTIDESTFILES));
     285//  multi target, each one for one source. ? last target + more than one source (all source files an one dir as target)
     286
     287                    toSingle = ((pTo[lenTo+1]=='\0') || !Multi);
     288                    withFileName = FALSE;
     289
     290                    strcpy(pTempTo,pTo);
     291                    PathRemoveBackslashA(pTempTo);
     292                    ToAttr = GetFileAttributesA(pTempTo);
     293                    if (ToAttr == -1 || !(ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
     294                        withFileName = ((lenTo == strlen(pTempTo)) || !toSingle);
     295                        if (withFileName) {
     296// Target must not be an directory
     297                            PathRemoveFileSpecA(pTempTo);
     298                            ToAttr = GetFileAttributesA(pTempTo);
     299                        }
     300                    }
     301                    if (ToAttr == -1) {
     302                        nlpFileOp.fAnyOperationsAborted=TRUE;
     303                        break;
     304                    }
     305                    if  (!(ToAttr & FILE_ATTRIBUTE_DIRECTORY) || (!withFileName && !toSingle) ) {
     306// never Create directory at this time
     307                        nlpFileOp.fAnyOperationsAborted=TRUE;
     308                        /* retCode=0x279; */
     309                        break;
     310                    }
     311                    lenTempTo = strlen(pTempTo);
     312                    withFileName = (((lenTempTo + 1) <  lenTo) || (PathIsRootA(pTo) && lenTempTo < lenTo));
     313                    PathAddBackslashA(pTempTo);
     314                    StarStar = (Multi && !withFileName &&
     315                        (ToAttr & FILE_ATTRIBUTE_DIRECTORY) &&
     316                        (FromAttr != -1) &&
     317                        (FromAttr & FILE_ATTRIBUTE_DIRECTORY) &&
     318                        (0!=strcmp(pTempTo,pTo)));
     319                }
     320
     321                if (FromAttr == -1 || StarStar) {
     322// is Source an existing directory\*.* ?
     323                    if (FromAttr == -1) {
     324                        PathRemoveFileSpecA(pNextFrom);
     325                        FromAttr = GetFileAttributesA(pNextFrom);
     326                    }
     327                    PathAddBackslashA(pNextFrom);
     328                    lenNextFrom = strlen(pNextFrom);
     329                    pToFile=&pNextFrom[lenNextFrom];
     330                       
     331                    if (FromAttr == -1 ||
     332                       ((0==strcmp(pNextFrom,pFrom)) && !PathIsRootA(pFrom)) ||
     333                      !(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ||
     334                      !((0==strcmp(&pFrom[lenNextFrom],"*.*")) || StarStar)) {
     335                        retCode=0x402;
     336                        nlpFileOp.fAnyOperationsAborted=TRUE;
     337                        break;
     338                    }
     339
     340                    strcpy(pToFile, "*.*");
     341                    hFind = FindFirstFileA(pNextFrom, &wfd);
     342                    if (INVALID_HANDLE_VALUE == hFind) {
     343                        nlpFileOp.fAnyOperationsAborted=TRUE;
     344                        retCode=0x79;
     345                        break;
     346                    }
     347                    nlpFileOp.pFrom = pNextFrom;
     348                    strcpy(pNextTo,pTo);
     349                    pNextTo[strlen(pNextTo)+1]='\0';
     350                    nlpFileOp.fFlags = (nlpFileOp.fFlags & (-1 - (FOF_MULTIDESTFILES)));
     351
     352                    TRACE(__FUNCTION__"   Copy between Subdir %s -> %s'\n", nlpFileOp.pFrom, nlpFileOp.pTo);
     353
     354                    do {
     355                        TRACE(__FUNCTION__"   find '%s'\n", wfd.cFileName);
     356                        if (0==strcmp(wfd.cFileName,".")) continue;
     357                        if (0==strcmp(wfd.cFileName,"..")) continue;
     358                        if ((nlpFileOp.fFlags & FOF_FILESONLY) && (FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)) {
     359                            continue;
     360                        } /* endif */
     361
     362                        strcpy(pToFile,wfd.cFileName);
     363                        pNextFrom[strlen(pNextFrom)+1]='\0';
     364
     365                        TempretCode = SHFileOperationA (&nlpFileOp);
     366
     367                        if (nlpFileOp.fAnyOperationsAborted) {/*retCode=0x179;*/break;}
     368
     369                    } while(FindNextFileA(hFind, &wfd));
     370
     371                    FindClose(hFind);
     372                    if (nlpFileOp.fAnyOperationsAborted) break;
     373                    continue;
     374                }
     375
     376
     377                lenTempTo = strlen(pTempTo);
     378                pToFile = &pTempTo[lenTempTo];
     379// Check Source
     380                strcpy(pToFile,pNextFrom);
     381                PathRemoveBackslashA(pToFile);
     382                if (strlen(pToFile)<lenFrom) {
     383                    nlpFileOp.fAnyOperationsAborted=TRUE;
     384                    retCode=0x402;
     385                    break;
     386                } /* endif */
     387
    319388// target name in target or from source
    320                                         if (withFileName) {
    321                                            if ((pFrom[strlen(pFrom)+1]=='\0') ||
    322                                                (Multi && !(pTo[strlen(pTo)+1]=='\0'))) {
    323                                                 pTempFrom = pTo;
    324                                            } else {
    325 // more then one source for one targetfile
    326                                                 lpFileOp->fAnyOperationsAborted=TRUE;
    327                                                 break;
    328                                            } /* endif */
    329                                         } else {
    330                                                 pTempFrom = pFrom;
    331                                         } /* endif */
    332 // isolate target filename
    333                                         strcpy(pToFile,pTempFrom);
    334                                         PathRemoveFileSpecA(pToFile);
    335                                         PathAddBackslashA(pToFile);
    336                                         lenTo = strlen(pToFile);
    337 
    338                                         strcpy(pToFile,&pTempFrom[lenTo]);
    339                                         FromAttr = GetFileAttributesA(pFrom);
    340                                         if (FromAttr & FILE_ATTRIBUTE_DIRECTORY) {
    341                                            if (!(FromAttr == -1)) {
    342                                                 FIXME(__FUNCTION__" FO_COPY only with sourcedir not implemented ,stub\n");
    343                                            };
    344                                            lpFileOp->fAnyOperationsAborted=TRUE;
    345                                            break;
    346                                         }
    347                                         ToAttr = GetFileAttributesA(pTempTo);
    348                                         if (!(ToAttr == -1) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
    349                                            lpFileOp->fAnyOperationsAborted=TRUE;
    350                                            break;
    351                                         }
     389                pTempFrom = NULL;
     390                if (withFileName) {
     391                    if ((pFrom[lenFrom+1]=='\0') || (Multi && !(pTo[lenTo+1]=='\0'))) {
     392                        pTempFrom = pTo;
     393                    } /* endif */
     394                } else {
     395// Multi Target
     396                    if (!Multi || !(pFrom[lenFrom+1]=='\0') ||
     397// only target+\, target without \ has 0x402
     398                        (Multi && (FromAttr & FILE_ATTRIBUTE_DIRECTORY) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY))) {
     399                        pTempFrom = pNextFrom;
     400                    }
     401                } /* endif */
     402
     403                if (!pTempFrom) {
     404                    nlpFileOp.fAnyOperationsAborted=TRUE;
     405                    break;
     406                } /* endif */
     407
     408// move isolated target filename
     409                strcpy(pToFile,pTempFrom);
     410                PathRemoveFileSpecA(pToFile);
     411                PathAddBackslashA(pToFile);
     412
     413                strcpy(pToFile,&pTempFrom[strlen(pToFile)]);
     414                ToAttr = GetFileAttributesA(pTempTo);
     415
     416
     417                if (FromAttr == -1) {
     418                    FIXME(__FUNCTION__" FO_COPY with Source %s not implementiert ,stub\n",pNextFrom);
     419                    nlpFileOp.fAnyOperationsAborted=TRUE;
     420                    retCode=0x76;
     421                    break;
     422                }
     423                if (FromAttr & FILE_ATTRIBUTE_DIRECTORY) {
     424                    if (ToAttr == -1) {
     425// Try to create an new Directory and enter in it
     426                        TRACE("   Creating Directory '%s'\n", pTempTo);
     427                        SHCreateDirectory(NULL,pTempTo);
     428                        ToAttr = GetFileAttributesA(pTempTo);
     429                        if (ToAttr == -1) {
     430                            nlpFileOp.fAnyOperationsAborted=TRUE;
     431                            retCode=0x10003;
     432                            break;
     433                        }
     434
     435                        lenTempTo = strlen(pTempTo);
     436
     437                        PathAddBackslashA(pNextFrom);
     438                        strcat(pNextFrom, "*.*");
     439                        pNextFrom[strlen(pNextFrom)+1]='\0';
     440                        nlpFileOp.pFrom = pNextFrom;
     441
     442                        pTempTo[lenTempTo+1]='\0';
     443                        nlpFileOp.pTo = pTempTo;
     444
     445                        TRACE(__FUNCTION__"   Entering Directory '%s'\n", nlpFileOp.pTo);
     446                        TempretCode = SHFileOperationA (&nlpFileOp);
     447
     448                        if (nlpFileOp.fAnyOperationsAborted) {break;}
     449                        continue;
     450
     451                    } else {
     452                        if (!(ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
     453                            FIXME(__FUNCTION__" FO_COPY only with %s -> %t ? ,stub\n",pNextFrom,pTo);
     454                            nlpFileOp.fAnyOperationsAborted=TRUE;
     455                            retCode=0x77;
     456                            break;
     457                        }
     458                        if (strlen(pToFile)==0) {
     459                            nlpFileOp.fAnyOperationsAborted=TRUE;
     460                            retCode=0x78;
     461                            break;
     462                        } else {
     463                            nlpFileOp.fAnyOperationsAborted=TRUE;
     464                            retCode=0x80;
     465                            break;
     466                        } /* endif */
     467
     468                    }
     469
     470                }
     471
     472                if (!(ToAttr == -1) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
     473                    nlpFileOp.fAnyOperationsAborted=TRUE;
     474                    break;
     475                }
    352476// first try to copy
    353                                         copyOk = CopyFileA(pFrom, pTempTo, not_overwrite);
    354 
    355                                         if (!copyOk && not_overwrite) {
    356                                                 if (SHELL_ConfirmDialog (ASK_OVERWRITE_FILE, pTempTo))
     477                if (CopyFileA(pNextFrom, pTempTo, not_overwrite)) continue;
     478
     479                if (not_overwrite) {
     480                    if (SHELL_ConfirmDialog (ASK_OVERWRITE_FILE, pTempTo))
    357481// second try to copy after confirm
    358                                                         copyOk = CopyFileA(pFrom, pTempTo, FALSE);
    359                                         } /* endif */
    360                                         if (!copyOk) lpFileOp->fAnyOperationsAborted=TRUE;
    361 // fix for mor then one source for one target
    362                                         pToFile[0] = '\0';
    363 
    364                                         if (!withFileName && Multi && (pTo[strlen(pTo)+1]=='\0')) {
    365 // Win Bug ?
    366                                                 Multi = FALSE;
    367                                         } /* endif */
    368                                         if (Multi) HeapFree(GetProcessHeap(), 0, pTempTo);
    369                                 }                               
    370 
    371                                 pFrom += strlen(pFrom) + 1;
    372                                
    373                                 if (Multi) pTo += strlen(pTo) + 1;
    374 
    375                         }
    376                 } /* endif */
    377                 if (!Multi && pTempTo) HeapFree(GetProcessHeap(), 0, pTempTo);
    378 
    379                 if (lpFileOp->fAnyOperationsAborted==TRUE) {
    380                         TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE\n");
    381                         return 0x75l;
    382                 } else {
    383                       TRACE(__FUNCTION__" Setting AnyOpsAborted=FALSE\n");
     482                        if (CopyFileA(pNextFrom, pTempTo, FALSE)) continue;
    384483                } /* endif */
    385                 return 0;
     484
     485                nlpFileOp.fAnyOperationsAborted=TRUE;
     486            }
     487
     488            if (pTempTo) HeapFree(GetProcessHeap(), 0, pTempTo);
     489
     490            if (nlpFileOp.fAnyOperationsAborted) {
     491                lpFileOp->fAnyOperationsAborted=TRUE;
     492                if (TempretCode > retCode) {
     493                    retCode = TempretCode;
     494                } /* endif */
     495            }
     496            if (lpFileOp->fAnyOperationsAborted==TRUE) {
     497                TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE\n");
     498                return retCode;
     499            } /* endif */
     500
     501            TRACE(__FUNCTION__" Setting AnyOpsAborted=FALSE\n");
     502            return 0;
    386503#else
    387504                while(1) {
Note: See TracChangeset for help on using the changeset viewer.