Changeset 5636 for trunk/src


Ignore:
Timestamp:
Apr 29, 2001, 6:23:03 PM (24 years ago)
Author:
sandervl
Message:

DT: SHFileOperationA updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shlfileop.c

    r5623 r5636  
    198198        DWORD FromAttr;
    199199        DWORD ToAttr;
     200        LPSTR pTempFrom;
    200201        LPSTR pTempTo = NULL;
    201         LPSTR pTempFrom;
    202         LPSTR pNextFrom;
    203         LPSTR pNextTo;
     202        LPSTR pFromFile;
    204203        LPSTR pToFile;
    205204
    206205        FILEOP_FLAGS OFl = ((FILEOP_FLAGS)lpFileOp->fFlags & 0x7ff);
    207206        BOOL Multi = TRUE;
    208         BOOL withFileName = FALSE;
     207        BOOL withFileName;
    209208        BOOL not_overwrite;
    210         BOOL toSingle;
    211         BOOL StarStar;
    212         BOOL copyOk;
     209        BOOL ToSingle;
     210        BOOL BothDir;
     211        BOOL ToWithoutBackSlash;
    213212        long lenFrom = -1;
    214213        long lenTo   = -1;
     214        long lenTempFrom;
    215215        long lenTempTo;
    216216        long retCode = 0x75;
    217217        long TempretCode = 0;
    218         long lenNextFrom;
    219         long lenNextTo;
     218        long where       = 0;
    220219        SHFILEOPSTRUCTA nlpFileOp = *(lpFileOp);
    221         HANDLE  hFind;
     220        HANDLE hFind;
    222221        WIN32_FIND_DATAA wfd;
    223222
    … …  
    234233                TRACE("File Copy:\n");
    235234#ifdef __WIN32OS2__
    236             pTempTo = HeapAlloc(GetProcessHeap(), 0, 4 * MAX_PATH+4);
    237             pNextFrom = &pTempTo[2*MAX_PATH+2];
    238             pNextTo = &pNextFrom[MAX_PATH+1];
     235            pTempTo = HeapAlloc(GetProcessHeap(), 0, 3 * MAX_PATH+6);
     236            pTempFrom = &pTempTo[2*MAX_PATH+2];
    239237/*
    240238 * FOF_MULTIDESTFILES, FOF_NOCONFIRMATION, FOF_FILESONLY                                are     implemented
    … …  
    246244            if (OFl) {
    247245                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);
     246                    FIXME(__FUNCTION__" FO_COPY with this fFlags not implemented:%x ,stub\n",lpFileOp->fFlags);
    249247                    lpFileOp->fAnyOperationsAborted=TRUE;
    250248                } else {
    251249// not FOF_SILENT, not FOF_SIMPLEPROGRESS, not FOF_NOCONFIRMMKDIR
    252                     FIXME(__FUNCTION__" FO_COPY with this lpFileOp->fFlags not full implemented:0x%2x ,stub\n",lpFileOp->fFlags);
     250                    FIXME(__FUNCTION__" FO_COPY with this lpFileOp->fFlags not full implemented:0x%x ,stub\n",lpFileOp->fFlags);
    253251                } /* endif */             
    254252            } /* endif */
    … …  
    267265
    268266                if (Multi) pTo += lenTo + 1;
    269                 if(!pTo[0]) break;
     267                if(!pTo[0]) {
     268                        nlpFileOp.fAnyOperationsAborted=TRUE;
     269                        where = 13;
     270                        break;
     271                }
    270272
    271273                TRACE("   From='%s' To='%s'\n", pFrom, pTo);
    … …  
    275277
    276278                lenFrom=strlen(pFrom);
    277                 strcpy(pNextFrom,pFrom);
    278                 FromAttr = GetFileAttributesA(pNextFrom);
    279                 StarStar = FALSE;
     279                strcpy(pTempFrom,pFrom);
     280                FromAttr = GetFileAttributesA(pTempFrom);
    280281
    281282                if (Multi) {
    … …  
    285286//  multi target, each one for one source. ? last target + more than one source (all source files an one dir as target)
    286287
    287                     toSingle = ((pTo[lenTo+1]=='\0') || !Multi);
    288                     withFileName = FALSE;
     288                    ToSingle = ((pTo[lenTo+1]=='\0') || !Multi);
    289289
    290290                    strcpy(pTempTo,pTo);
    291291                    PathRemoveBackslashA(pTempTo);
     292                    ToWithoutBackSlash = (strlen(pTempTo)==lenTo);
    292293                    ToAttr = GetFileAttributesA(pTempTo);
    293                     if (ToAttr == -1 || !(ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
    294                         withFileName = ((lenTo == strlen(pTempTo)) || !toSingle);
    295                         if (withFileName) {
     294
     295                    BothDir = (Multi                       &&
     296                               ToWithoutBackSlash          &&
     297                               (-1 != (FromAttr | ToAttr)) &&
     298                               (ToAttr & FromAttr & FILE_ATTRIBUTE_DIRECTORY));
     299
     300                    withFileName = (!BothDir                      &&
     301                                (ToWithoutBackSlash || !ToSingle) &&
     302                                (ToAttr == -1 || !(ToAttr & FILE_ATTRIBUTE_DIRECTORY)));
     303
     304                    if (withFileName) {
    296305// Target must not be an directory
    297                             PathRemoveFileSpecA(pTempTo);
    298                             ToAttr = GetFileAttributesA(pTempTo);
    299                         }
     306                        PathRemoveFileSpecA(pTempTo);
     307                        ToAttr = GetFileAttributesA(pTempTo);
    300308                    }
    301                     if (ToAttr == -1) {
     309                    if ((ToAttr == -1) ||
     310                        !(ToAttr & FILE_ATTRIBUTE_DIRECTORY) ||
     311                        (!withFileName && !ToSingle) ) {
    302312                        nlpFileOp.fAnyOperationsAborted=TRUE;
     313                        where = 1;
    303314                        break;
    304315                    }
    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                     }
    311316                    lenTempTo = strlen(pTempTo);
    312317                    withFileName = (((lenTempTo + 1) <  lenTo) || (PathIsRootA(pTo) && lenTempTo < lenTo));
    313318                    PathAddBackslashA(pTempTo);
    314                     StarStar = (Multi && !withFileName &&
    315                         (ToAttr & FILE_ATTRIBUTE_DIRECTORY) &&
    316                         (FromAttr != -1) &&
    317                         (FromAttr & FILE_ATTRIBUTE_DIRECTORY) &&
    318                         (0!=strcmp(pTempTo,pTo)));
    319319                }
    320320
    321                 if (FromAttr == -1 || StarStar) {
     321                if (FromAttr == -1 || BothDir) {
    322322// is Source an existing directory\*.* ?
    323323                    if (FromAttr == -1) {
    324                         PathRemoveFileSpecA(pNextFrom);
    325                         FromAttr = GetFileAttributesA(pNextFrom);
     324                        PathRemoveFileSpecA(pTempFrom);
     325                        FromAttr = GetFileAttributesA(pTempFrom);
    326326                    }
    327                     PathAddBackslashA(pNextFrom);
    328                     lenNextFrom = strlen(pNextFrom);
    329                     pToFile=&pNextFrom[lenNextFrom];
     327
     328                    PathAddBackslashA(pTempFrom);
     329                    lenTempFrom = strlen(pTempFrom);
     330                    pFromFile=&pTempFrom[lenTempFrom];
    330331                       
    331332                    if (FromAttr == -1 ||
    332                        ((0==strcmp(pNextFrom,pFrom)) && !PathIsRootA(pFrom)) ||
     333                       ((lenTempFrom==lenFrom) && !PathIsRootA(pFrom)) ||
    333334                      !(FromAttr & FILE_ATTRIBUTE_DIRECTORY) ||
    334                       !((0==strcmp(&pFrom[lenNextFrom],"*.*")) || StarStar)) {
     335                      !((0==strcmp(&pFrom[lenTempFrom],"*.*")) || BothDir)) {
    335336                        retCode=0x402;
    336337                        nlpFileOp.fAnyOperationsAborted=TRUE;
     338                        where = 2;
    337339                        break;
    338340                    }
    339341
    340                     strcpy(pToFile, "*.*");
    341                     hFind = FindFirstFileA(pNextFrom, &wfd);
     342                    strcpy(pFromFile, "*.*");
     343                    hFind = FindFirstFileA(pTempFrom, &wfd);
    342344                    if (INVALID_HANDLE_VALUE == hFind) {
    343345                        nlpFileOp.fAnyOperationsAborted=TRUE;
    344346                        retCode=0x79;
     347                        where = 3;
    345348                        break;
    346349                    }
    347                     nlpFileOp.pFrom = pNextFrom;
    348                     strcpy(pNextTo,pTo);
    349                     pNextTo[strlen(pNextTo)+1]='\0';
     350
     351                    nlpFileOp.pFrom  = pTempFrom;
     352// single copy never with FOF_MULTIDESTFILES, I can use lpFileOp->pTo as nlpFileOp.pTo,
     353// I need no different targetarea for the name
    350354                    nlpFileOp.fFlags = (nlpFileOp.fFlags & (-1 - (FOF_MULTIDESTFILES)));
    351355
    … …  
    360364                        } /* endif */
    361365
    362                         strcpy(pToFile,wfd.cFileName);
    363                         pNextFrom[strlen(pNextFrom)+1]='\0';
     366                        strcpy(pFromFile,wfd.cFileName);
     367                        pTempFrom[strlen(pTempFrom)+1]='\0';
    364368
    365369                        TempretCode = SHFileOperationA (&nlpFileOp);
    366370
    367                         if (nlpFileOp.fAnyOperationsAborted) {/*retCode=0x179;*/break;}
     371                        if (nlpFileOp.fAnyOperationsAborted) {where = 4;break;}
    368372
    369373                    } while(FindNextFileA(hFind, &wfd));
    370374
    371375                    FindClose(hFind);
    372                     if (nlpFileOp.fAnyOperationsAborted) break;
     376                    if (nlpFileOp.fAnyOperationsAborted) {where = 5;break;}
    373377                    continue;
    374378                }
    … …  
    378382                pToFile = &pTempTo[lenTempTo];
    379383// Check Source
    380                 strcpy(pToFile,pNextFrom);
     384                strcpy(pToFile,pTempFrom);
    381385                PathRemoveBackslashA(pToFile);
    382386                if (strlen(pToFile)<lenFrom) {
    383387                    nlpFileOp.fAnyOperationsAborted=TRUE;
    384388                    retCode=0x402;
     389                    where = 6;
    385390                    break;
    386391                } /* endif */
    387392
    388393// target name in target or from source
    389                 pTempFrom = NULL;
     394                pFromFile = NULL;
    390395                if (withFileName) {
    391396                    if ((pFrom[lenFrom+1]=='\0') || (Multi && !(pTo[lenTo+1]=='\0'))) {
    392                         pTempFrom = pTo;
     397                        pFromFile = pTo;
    393398                    } /* endif */
    394399                } else {
    … …  
    396401                    if (!Multi || !(pFrom[lenFrom+1]=='\0') ||
    397402// only target+\, target without \ has 0x402
    398                         (Multi && (FromAttr & FILE_ATTRIBUTE_DIRECTORY) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY))) {
    399                         pTempFrom = pNextFrom;
     403                        (Multi && (FromAttr & ToAttr & FILE_ATTRIBUTE_DIRECTORY))) {
     404                        pFromFile = pTempFrom;
    400405                    }
    401406                } /* endif */
    402407
    403                 if (!pTempFrom) {
     408                if (!pFromFile) {
    404409                    nlpFileOp.fAnyOperationsAborted=TRUE;
     410                    where = 7;
    405411                    break;
    406412                } /* endif */
    407413
    408414// move isolated target filename
    409                 strcpy(pToFile,pTempFrom);
     415                strcpy(pToFile,pFromFile);
    410416                PathRemoveFileSpecA(pToFile);
    411417                PathAddBackslashA(pToFile);
    412418
    413                 strcpy(pToFile,&pTempFrom[strlen(pToFile)]);
     419                strcpy(pToFile,&pFromFile[strlen(pToFile)]);
    414420                ToAttr = GetFileAttributesA(pTempTo);
    415421
    416422
    417423                if (FromAttr == -1) {
    418                     FIXME(__FUNCTION__" FO_COPY with Source %s not implementiert ,stub\n",pNextFrom);
     424                    FIXME(__FUNCTION__" FO_COPY with Source %s not implementiert ,stub\n",pTempFrom);
    419425                    nlpFileOp.fAnyOperationsAborted=TRUE;
    420                     retCode=0x76;
     426                    where = 8;
    421427                    break;
    422428                }
    … …  
    430436                            nlpFileOp.fAnyOperationsAborted=TRUE;
    431437                            retCode=0x10003;
     438                            where = 9;
    432439                            break;
    433440                        }
    … …  
    435442                        lenTempTo = strlen(pTempTo);
    436443
    437                         PathAddBackslashA(pNextFrom);
    438                         strcat(pNextFrom, "*.*");
    439                         pNextFrom[strlen(pNextFrom)+1]='\0';
    440                         nlpFileOp.pFrom = pNextFrom;
     444                        PathAddBackslashA(pTempFrom);
     445                        strcat(pTempFrom, "*.*");
     446                        pTempFrom[strlen(pTempFrom)+1]='\0';
     447                        nlpFileOp.pFrom = pTempFrom;
    441448
    442449                        pTempTo[lenTempTo+1]='\0';
    … …  
    450457
    451458                    } 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 */
     459                        FIXME(__FUNCTION__" FO_COPY unexpected with %s -> %s ? ,stub\n",pTempFrom,pTo);
     460                        nlpFileOp.fAnyOperationsAborted=TRUE;
     461                        where = 10;
     462                        retCode=0x77;
     463                        break;
    467464
    468465                    }
    … …  
    472469                if (!(ToAttr == -1) && (ToAttr & FILE_ATTRIBUTE_DIRECTORY)) {
    473470                    nlpFileOp.fAnyOperationsAborted=TRUE;
     471                    where = 11;
     472                    break;
     473                }
     474                if (0==strcmp(pTempFrom, pTempTo)) {
     475                    nlpFileOp.fAnyOperationsAborted=TRUE;
     476                    retCode = 0x71;
     477                    where = 12;
    474478                    break;
    475479                }
    476480// first try to copy
    477                 if (CopyFileA(pNextFrom, pTempTo, not_overwrite)) continue;
     481                if (CopyFileA(pTempFrom, pTempTo, not_overwrite)) continue;
    478482
    479483                if (not_overwrite) {
    480484                    if (SHELL_ConfirmDialog (ASK_OVERWRITE_FILE, pTempTo))
    481485// second try to copy after confirm
    482                         if (CopyFileA(pNextFrom, pTempTo, FALSE)) continue;
     486                        if (CopyFileA(pTempFrom, pTempTo, FALSE)) continue;
    483487                } /* endif */
    484488
    … …  
    495499            }
    496500            if (lpFileOp->fAnyOperationsAborted==TRUE) {
    497                 TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE\n");
     501                TRACE(__FUNCTION__" Setting AnyOpsAborted=TRUE ret=0x%x, at=%i with %s -> %s\n",retCode,where,pFrom,pTo);
    498502                return retCode;
    499503            } /* endif */
    … …  
    596600        return (GetDriveTypeA(root) == DRIVE_REMOTE);
    597601}
     602
Note: See TracChangeset for help on using the changeset viewer.