Changeset 1131 for trunk/dll/worker.c


Ignore:
Timestamp:
Aug 30, 2008, 2:19:21 AM (17 years ago)
Author:
Gregg Young
Message:

Some additional toolbar enhancements and fixes (tickets 273, 274, 275)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/worker.c

    r1116 r1131  
    553553              case IDM_MOVE:
    554554              case IDM_COPY:
    555               case IDM_RENAME:
    556                 if (!*wk->li->targetpath && (wk->li->type == IDM_MOVE ||
    557                                              wk->li->type == IDM_COPY ||
    558                                              wk->li->type == IDM_WPSMOVE ||
    559                                              wk->li->type == IDM_WPSCOPY)) {
    560 
    561                   APIRET rc = 1;
    562 
    563                   usedtarget = FALSE;
    564                   if (hwndMain) {
    565                     if (!*targetdir)
    566                       TopWindowName(hwndMain,
    567                                     wk->hwndFrame, wk->li->targetpath);
    568                     else {
    569                       strcpy(wk->li->targetpath, targetdir);
    570                       usedtarget = TRUE;
    571                     }
    572                   }
    573                   if (!*wk->li->targetpath)
    574                     strcpy(wk->li->targetpath, wk->directory);
    575                   if (!*wk->li->targetpath) {
    576                     strcpy(wk->li->targetpath, wk->li->list[0]);
    577                     p = strrchr(wk->li->targetpath, '\\');
    578                     if (p) {
    579                       if (*(p - 1) == ':')
    580                         p++;
    581                       *p = 0;
    582                     }
    583                   }
    584                   MakeValidDir(wk->li->targetpath);
    585                   if (fConfirmTarget ||
    586                       (!*targetdir && strcmp(realappname, "FM/4"))) {
    587                   RetryPath:
    588                     usedtarget = FALSE;
    589                     if (wk->li->type == IDM_MOVE ||
    590                         wk->li->type == IDM_WPSMOVE) {
    591                       rc = WinDlgBox(HWND_DESKTOP,
    592                                      wk->hwndFrame,
    593                                      WalkMoveDlgProc,
    594                                      FM3ModHandle,
    595                                      WALK_FRAME, MPFROMP(wk->li->targetpath));
    596                     }
    597                     else if (wk->li->type == IDM_COPY ||
    598                              wk->li->type == IDM_WPSCOPY) {
    599                       rc = WinDlgBox(HWND_DESKTOP,
    600                                      wk->hwndFrame,
    601                                      WalkCopyDlgProc,
    602                                      FM3ModHandle,
    603                                      WALK_FRAME, MPFROMP(wk->li->targetpath));
    604                     }
    605                     else
    606                       rc = WinDlgBox(HWND_DESKTOP,
    607                                      wk->hwndFrame,
    608                                      WalkDlgProc,
    609                                      FM3ModHandle,
    610                                      WALK_FRAME, MPFROMP(wk->li->targetpath));
    611                   }
    612                   if (!rc || !*wk->li->targetpath)
    613                     goto Abort;
    614                   if (driveflags[toupper(*wk->li->targetpath) - 'A'] &
    615                       DRIVE_NOTWRITEABLE) {
    616                     saymsg(MB_CANCEL,
    617                            wk->hwndFrame,
    618                            GetPString(IDS_ERRORTEXT),
    619                            "%s", GetPString(IDS_NOTWRITENOTARGETTEXT));
    620                     goto RetryPath;
    621                   }
    622                 }
    623               Retry:
    624                 {
    625                   CHAR newname[CCHMAXPATH], *moving, *move, *moved;
    626                   APIRET rc;
    627                   INT type;
    628                   FILESTATUS4L fs4;
    629                   BOOL isnewer, existed;
    630 
    631                   type = (wk->li->type == IDM_RENAME) ? MOVE :
    632                     (wk->li->type == IDM_MOVE) ? MOVE :
    633                     (wk->li->type == IDM_WPSMOVE) ? WPSMOVE :
    634                     (wk->li->type == IDM_WPSCOPY) ? WPSCOPY : COPY;
    635                   moving = (wk->li->type == IDM_RENAME) ?
    636                     GetPString(IDS_RENAMINGTEXT) :
    637                     (wk->li->type == IDM_MOVE ||
    638                      wk->li->type == IDM_WPSMOVE) ?
    639                     GetPString(IDS_MOVINGTEXT) : GetPString(IDS_COPYINGTEXT);
    640                   move = (wk->li->type == IDM_RENAME) ?
    641                     GetPString(IDS_RENAMETEXT) :
    642                     (wk->li->type == IDM_MOVE ||
    643                      wk->li->type == IDM_WPSMOVE) ?
    644                     GetPString(IDS_MOVETEXT) : GetPString(IDS_COPYTEXT);
    645                   moved = (wk->li->type == IDM_RENAME) ?
    646                     GetPString(IDS_RENAMEDTEXT) :
    647                     (wk->li->type == IDM_MOVE ||
    648                      wk->li->type == IDM_WPSMOVE) ?
    649                     GetPString(IDS_MOVEDTEXT) : GetPString(IDS_COPIEDTEXT);
    650                   if (*wk->li->targetpath) {
    651                     strcpy(newname, wk->li->targetpath);
    652                     if (newname[strlen(newname) - 1] != '\\')
    653                       strcat(newname, "\\");
    654                     if (plen)
    655                       p = wk->li->list[x] + plen;
    656                     else {
    657                       p = strrchr(wk->li->list[x], '\\');
    658                       if (p)
    659                         p++;
    660                       else
    661                         p = wk->li->list[x];
    662                     }
    663                     strcat(newname, p);
    664                   }
    665                   else
    666                     strcpy(newname, wk->li->list[x]);
    667                   if ((wildcarding || wk->li->type == IDM_RENAME) &&
    668                       *wildname) {
    669 
    670                     CHAR testname[CCHMAXPATH];
    671 
    672                     strcpy(testname, wildname);
    673                     if (AdjustWildcardName(newname, testname))
    674                       strcpy(newname, testname);
    675                   }
    676                   existed = (IsFile(newname) != -1);
    677                   isnewer = IsNewer(wk->li->list[x], newname);
    678                   /*
    679                      {
    680                      char temp[CCHMAXPATH * 3];
    681                      sprintf(temp,"Target: %s\rSource: %s\rOverold: %lu\rOvernew: %lu\rIsNewer: %lu\rExisted: %lu",newname,wk->li->list[x],overold,overnew,isnewer,existed);
    682                      saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,temp);
    683                      }
    684                    */
    685                   if (existed && wk->li->type != IDM_RENAME && dontask) {
    686                     if (!overold && !overnew)
    687                       break;
    688                     if (!overold && !isnewer)
    689                       break;
    690                     if (!overnew && isnewer)
    691                       break;
    692                   }
    693                   if ((wk->li->type == IDM_RENAME &&
    694                        (!dontask || !*wildname)) ||
    695                       (!dontask && existed) ||
    696                       (!dontask && wildcarding) ||
    697                       (IsFile(newname) == 0 && IsFile(wk->li->list[x]) > 0)) {
    698 
    699                     MOVEIT mv;
    700 
    701                     memset(&mv, 0, sizeof(MOVEIT));
    702                     mv.rename = (wk->li->type == IDM_RENAME);
    703                     mv.source = wk->li->list[x];
    704                     strcpy(mv.target, newname);
    705                     rc = WinDlgBox(HWND_DESKTOP,
    706                                    wk->hwndFrame,
    707                                    RenameProc,
    708                                    FM3ModHandle, REN_FRAME, (PVOID) & mv);
    709                     if (!rc)
    710                       goto Abort;
    711                     DosSleep(1);
    712                     if (mv.skip || !*mv.target)
    713                       break;
    714                     if (mv.dontask)
    715                       dontask = TRUE;
    716                     if (mv.overold)
    717                       overold = TRUE;
    718                     if (mv.overnew)
    719                       overnew = TRUE;
    720                     if (wildcarding || wk->li->type == IDM_RENAME) {
    721                       p = strrchr(mv.target, '\\');
    722                       if (p && (strchr(p, '*') || strchr(p, '?'))) {
    723                         strcpy(wildname, mv.target);
    724                         AdjustWildcardName(wk->li->list[x], mv.target);
    725                       }
    726                       else
    727                         *wildname = 0;
    728                     }
    729                     strcpy(newname, mv.target);
    730                     existed = (IsFile(newname) != -1);
    731                     isnewer = IsNewer(wk->li->list[x], newname);
    732                     if (!mv.overwrite) {
    733                       if (existed && wk->li->type != IDM_RENAME && dontask) {
    734                         if (!overold && !overnew)
    735                           break;
    736                         if (!overold && !isnewer)
    737                           break;
    738                         if (!overnew && isnewer)
    739                           break;
    740                       }
    741                     }
    742                   }
    743                   if (!strcmp(wk->li->list[x], newname) ||
    744                       (wk->li->type == IDM_COPY &&
    745                        !stricmp(wk->li->list[x], newname)))
    746                     break;
    747                   sprintf(message,
    748                           " %s \"%s\" %s\"%s\"%s",
    749                           moving,
    750                           wk->li->list[x],
    751                           GetPString(IDS_TOTEXT),
    752                           newname,
    753                           (usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
    754                           NullStr);
    755                   AddNote(message);
    756                   if (plen) {
    757                     /* make directory/ies, if required */
    758 
    759                     CHAR dirpart[CCHMAXPATH];
    760 
    761                     strcpy(dirpart, newname);
    762                     p = strrchr(dirpart, '\\');
    763                     if (p) {
    764                       *p = 0;
    765                       if (p > dirpart + 3)
    766                         MassMkdir((hwndMain) ? hwndMain : wk->hwndCnr,
    767                                   dirpart);
    768                     }
    769                   }
    770                   if (fRealIdle)
    771                     priority_idle();
    772                   rc = docopyf(type, wk->li->list[x], "%s", newname);
    773                   priority_normal();
    774                   if (rc) {
    775                     if ((rc == ERROR_DISK_FULL ||
    776                          rc == ERROR_HANDLE_DISK_FULL) &&
    777                         isalpha(*newname) &&
    778                         (driveflags[toupper(*newname) - 'A'] &
    779                          DRIVE_REMOVABLE)
    780                         && !(driveflags[toupper(*newname) - 'A'] &
    781                              DRIVE_NOTWRITEABLE)
    782                         && toupper(*newname) != toupper(*wk->li->list[x])
    783                         && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZEL,
    784                                              &fs4, sizeof(fs4))
    785                         && !(fs4.attrFile & FILE_DIRECTORY)) {
    786 
    787                       FSALLOCATE fsa;
    788                       ULONGLONG ullFreeBytes;
    789                       CHAR *ptr;
    790                       INT cntr;
    791 
    792                       Notify(GetPString(IDS_FITTINGTEXT));
    793                       DosError(FERR_DISABLEHARDERR);
    794                       if (!DosQueryFSInfo(toupper(*newname) - '@',
    795                                           FSIL_ALLOC,
    796                                           &fsa, sizeof(FSALLOCATE))) {
    797                         // Assume large file support
    798                         ullFreeBytes = (ULONGLONG) fsa.cUnitAvail * fsa.cSectorUnit *
    799                           fsa.cbSector;
    800                         if (ullFreeBytes) {
    801                           // Find item that will fit in available space
    802                           for (cntr = x + 1; wk->li->list[cntr]; cntr++) {
    803                             DosError(FERR_DISABLEHARDERR);
    804                             if (!DosQueryPathInfo(wk->li->list[cntr],
    805                                                   FIL_QUERYEASIZEL,
    806                                                   &fs4,
    807                                                   sizeof(fs4)) &&
    808                                 !(fs4.attrFile & FILE_DIRECTORY) &&
    809                                 // fixme to use CBLIST_TO_EASIZE?
    810                                 fs4.cbFile + fs4.cbList <= ullFreeBytes) {
    811                               // Swap with failing item
    812                               ptr = wk->li->list[x];
    813                               wk->li->list[x] = wk->li->list[cntr];
    814                               wk->li->list[cntr] = ptr;
    815                               goto Retry;
    816                             }
    817                           }
    818                           Notify(GetPString(IDS_COULDNTFITTEXT));
    819                         }
    820                       }
    821                       rc = saymsg(MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION,
    822                                   wk->hwndFrame,
    823                                   GetPString(IDS_DISKFULLTEXT),
    824                                   "%s", GetPString(IDS_ANOTHERDISKTEXT));
    825                       if (rc == MBID_RETRY)
    826                         goto Retry;
    827                       if (rc == MBID_ABORT)
    828                         goto Abort;
    829                     }
    830                     else {
    831                       if (LogFileHandle)
    832                         fprintf(LogFileHandle,
    833                                 GetPString(IDS_LOGTOFAILEDTEXT),
    834                                 move, wk->li->list[x], newname, rc);
    835                       rc = Dos_Error(MB_ENTERCANCEL,
    836                                      rc,
    837                                      wk->hwndFrame,
    838                                      pszSrcFile,
    839                                      __LINE__,
    840                                      "%s %s \"%s\" %s\"%s\" %s.",
    841                                      move,
    842                                      GetPString(IDS_OFTEXT),
    843                                      wk->li->list[x],
    844                                      GetPString(IDS_TOTEXT),
    845                                      newname, GetPString(IDS_FAILEDTEXT));
    846                       if (rc == MBID_CANCEL)
    847                         goto Abort;
    848                     }
    849                   }
    850                   else {
    851                     if (LogFileHandle)
    852                       fprintf(LogFileHandle,
    853                               "%s \"%s\" %s\"%s\"\n",
    854                               moved,
    855                               wk->li->list[x],
    856                               GetPString(IDS_TOTEXT), newname);
    857                     if (fSyncUpdates ||
    858                         AddToList(wk->li->list[x],
    859                                   &files, &numfiles, &numalloc))
    860                       Broadcast(hab2,
    861                                 wk->hwndCnr,
    862                                 UM_UPDATERECORD,
    863                                 MPFROMP(wk->li->list[x]), MPVOID);
    864                     if (fSyncUpdates ||
    865                         AddToList(newname, &files, &numfiles, &numalloc))
    866                       Broadcast(hab2,
    867                                 wk->hwndCnr,
    868                                 UM_UPDATERECORD, MPFROMP(newname), MPVOID);
    869                   }
    870                 }
    871                 break;
     555              case IDM_RENAME:
     556                {
     557
     558                  INT iCounter = 0;
     559
     560                  if (!*wk->li->targetpath && (wk->li->type == IDM_MOVE ||
     561                                               wk->li->type == IDM_COPY ||
     562                                               wk->li->type == IDM_WPSMOVE ||
     563                                               wk->li->type == IDM_WPSCOPY)) {
     564
     565                    APIRET rc = 1;
     566
     567                    usedtarget = FALSE;
     568                    if (hwndMain) {
     569                      if (!*targetdir)
     570                        TopWindowName(hwndMain,
     571                                      wk->hwndFrame, wk->li->targetpath);
     572                      else {
     573                        strcpy(wk->li->targetpath, targetdir);
     574                        usedtarget = TRUE;
     575                      }
     576                    }
     577                    if (!*wk->li->targetpath)
     578                      strcpy(wk->li->targetpath, wk->directory);
     579                    if (!*wk->li->targetpath) {
     580                      strcpy(wk->li->targetpath, wk->li->list[0]);
     581                      p = strrchr(wk->li->targetpath, '\\');
     582                      if (p) {
     583                        if (*(p - 1) == ':')
     584                          p++;
     585                        *p = 0;
     586                      }
     587                    }
     588                    MakeValidDir(wk->li->targetpath);
     589                    if (fConfirmTarget ||
     590                        (!*targetdir && strcmp(realappname, "FM/4"))) {
     591                    RetryPath:
     592                      usedtarget = FALSE;
     593                      if (wk->li->type == IDM_MOVE ||
     594                          wk->li->type == IDM_WPSMOVE) {
     595                        rc = WinDlgBox(HWND_DESKTOP,
     596                                       wk->hwndFrame,
     597                                       WalkMoveDlgProc,
     598                                       FM3ModHandle,
     599                                       WALK_FRAME, MPFROMP(wk->li->targetpath));
     600                      }
     601                      else if (wk->li->type == IDM_COPY ||
     602                               wk->li->type == IDM_WPSCOPY) {
     603                        rc = WinDlgBox(HWND_DESKTOP,
     604                                       wk->hwndFrame,
     605                                       WalkCopyDlgProc,
     606                                       FM3ModHandle,
     607                                       WALK_FRAME, MPFROMP(wk->li->targetpath));
     608                      }
     609                      else
     610                        rc = WinDlgBox(HWND_DESKTOP,
     611                                       wk->hwndFrame,
     612                                       WalkDlgProc,
     613                                       FM3ModHandle,
     614                                       WALK_FRAME, MPFROMP(wk->li->targetpath));
     615                    }
     616                    if (!rc || !*wk->li->targetpath)
     617                      goto Abort;
     618                    if (driveflags[toupper(*wk->li->targetpath) - 'A'] &
     619                        DRIVE_NOTWRITEABLE) {
     620                      saymsg(MB_CANCEL,
     621                             wk->hwndFrame,
     622                             GetPString(IDS_ERRORTEXT),
     623                             "%s", GetPString(IDS_NOTWRITENOTARGETTEXT));
     624                      goto RetryPath;
     625                    }
     626                  }
     627                Retry:
     628                  {
     629                    CHAR newname[CCHMAXPATH], *moving, *move, *moved;
     630                    APIRET rc;
     631                    INT type;
     632                    FILESTATUS4L fs4;
     633                    BOOL isnewer, existed;
     634
     635                    type = (wk->li->type == IDM_RENAME) ? MOVE :
     636                      (wk->li->type == IDM_MOVE) ? MOVE :
     637                      (wk->li->type == IDM_WPSMOVE) ? WPSMOVE :
     638                      (wk->li->type == IDM_WPSCOPY) ? WPSCOPY : COPY;
     639                    moving = (wk->li->type == IDM_RENAME) ?
     640                      GetPString(IDS_RENAMINGTEXT) :
     641                      (wk->li->type == IDM_MOVE ||
     642                       wk->li->type == IDM_WPSMOVE) ?
     643                      GetPString(IDS_MOVINGTEXT) : GetPString(IDS_COPYINGTEXT);
     644                    move = (wk->li->type == IDM_RENAME) ?
     645                      GetPString(IDS_RENAMETEXT) :
     646                      (wk->li->type == IDM_MOVE ||
     647                       wk->li->type == IDM_WPSMOVE) ?
     648                      GetPString(IDS_MOVETEXT) : GetPString(IDS_COPYTEXT);
     649                    moved = (wk->li->type == IDM_RENAME) ?
     650                      GetPString(IDS_RENAMEDTEXT) :
     651                      (wk->li->type == IDM_MOVE ||
     652                       wk->li->type == IDM_WPSMOVE) ?
     653                      GetPString(IDS_MOVEDTEXT) : GetPString(IDS_COPIEDTEXT);
     654                    if (*wk->li->targetpath) {
     655                      strcpy(newname, wk->li->targetpath);
     656                      if (newname[strlen(newname) - 1] != '\\')
     657                        strcat(newname, "\\");
     658                      if (plen)
     659                        p = wk->li->list[x] + plen;
     660                      else {
     661                        p = strrchr(wk->li->list[x], '\\');
     662                        if (p)
     663                          p++;
     664                        else
     665                          p = wk->li->list[x];
     666                      }
     667                      strcat(newname, p);
     668                    }
     669                    else
     670                      strcpy(newname, wk->li->list[x]);
     671                    if ((wildcarding || wk->li->type == IDM_RENAME) &&
     672                        *wildname) {
     673
     674                      CHAR testname[CCHMAXPATH];
     675
     676                      strcpy(testname, wildname);
     677                      if (AdjustWildcardName(newname, testname))
     678                        strcpy(newname, testname);
     679                    }
     680                    existed = (IsFile(newname) != -1);
     681                    isnewer = IsNewer(wk->li->list[x], newname);
     682                    /*
     683                       {
     684                       char temp[CCHMAXPATH * 3];
     685                       sprintf(temp,"Target: %s\rSource: %s\rOverold: %lu\rOvernew: %lu\rIsNewer: %lu\rExisted: %lu",newname,wk->li->list[x],overold,overnew,isnewer,existed);
     686                       saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,temp);
     687                       }
     688                     */
     689                    if (existed && wk->li->type != IDM_RENAME && dontask) {
     690                      if (!overold && !overnew)
     691                        break;
     692                      if (!overold && !isnewer)
     693                        break;
     694                      if (!overnew && isnewer)
     695                        break;
     696                    }
     697                    if ((wk->li->type == IDM_RENAME &&
     698                         (!dontask || !*wildname)) ||
     699                        (!dontask && existed) ||
     700                        (!dontask && wildcarding) ||
     701                        (IsFile(newname) == 0 && IsFile(wk->li->list[x]) > 0)) {
     702
     703                      MOVEIT mv;
     704
     705                      memset(&mv, 0, sizeof(MOVEIT));
     706                      mv.rename = (wk->li->type == IDM_RENAME);
     707                      mv.source = wk->li->list[x];
     708                      strcpy(mv.target, newname);
     709                      rc = WinDlgBox(HWND_DESKTOP,
     710                                     wk->hwndFrame,
     711                                     RenameProc,
     712                                     FM3ModHandle, REN_FRAME, (PVOID) & mv);
     713                      if (!rc)
     714                        goto Abort;
     715                      DosSleep(1);
     716                      if (mv.skip || !*mv.target)
     717                        break;
     718                      if (mv.dontask)
     719                        dontask = TRUE;
     720                      if (mv.overold)
     721                        overold = TRUE;
     722                      if (mv.overnew)
     723                        overnew = TRUE;
     724                      if (wildcarding || wk->li->type == IDM_RENAME) {
     725                        p = strrchr(mv.target, '\\');
     726                        if (p && (strchr(p, '*') || strchr(p, '?'))) {
     727                          strcpy(wildname, mv.target);
     728                          AdjustWildcardName(wk->li->list[x], mv.target);
     729                        }
     730                        else
     731                          *wildname = 0;
     732                      }
     733                      strcpy(newname, mv.target);
     734                      existed = (IsFile(newname) != -1);
     735                      isnewer = IsNewer(wk->li->list[x], newname);
     736                      if (!mv.overwrite) {
     737                        if (existed && wk->li->type != IDM_RENAME && dontask) {
     738                          if (!overold && !overnew)
     739                            break;
     740                          if (!overold && !isnewer)
     741                            break;
     742                          if (!overnew && isnewer)
     743                            break;
     744                        }
     745                      }
     746                    }
     747                    if (!strcmp(wk->li->list[x], newname) ||
     748                        (wk->li->type == IDM_COPY &&
     749                         !stricmp(wk->li->list[x], newname)))
     750                      break;
     751                    sprintf(message,
     752                            " %s \"%s\" %s\"%s\"%s",
     753                            moving,
     754                            wk->li->list[x],
     755                            GetPString(IDS_TOTEXT),
     756                            newname,
     757                            (usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
     758                            NullStr);
     759                    AddNote(message);
     760                    if (plen) {
     761                      /* make directory/ies, if required */
     762
     763                      CHAR dirpart[CCHMAXPATH];
     764
     765                      strcpy(dirpart, newname);
     766                      p = strrchr(dirpart, '\\');
     767                      if (p) {
     768                        *p = 0;
     769                        if (p > dirpart + 3)
     770                          MassMkdir((hwndMain) ? hwndMain : wk->hwndCnr,
     771                                    dirpart);
     772                      }
     773                    }
     774                    if (fRealIdle)
     775                      priority_idle();
     776                    rc = docopyf(type, wk->li->list[x], "%s", newname);
     777                    priority_normal();
     778                    if (rc) {
     779                      if ((rc == ERROR_DISK_FULL ||
     780                           rc == ERROR_HANDLE_DISK_FULL) &&
     781                          isalpha(*newname) &&
     782                          (driveflags[toupper(*newname) - 'A'] &
     783                           DRIVE_REMOVABLE)
     784                          && !(driveflags[toupper(*newname) - 'A'] &
     785                               DRIVE_NOTWRITEABLE)
     786                          && toupper(*newname) != toupper(*wk->li->list[x])
     787                          && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZEL,
     788                                               &fs4, sizeof(fs4))
     789                          && !(fs4.attrFile & FILE_DIRECTORY)) {
     790
     791                        FSALLOCATE fsa;
     792                        ULONGLONG ullFreeBytes;
     793                        CHAR *ptr;
     794                        INT cntr;
     795
     796                        Notify(GetPString(IDS_FITTINGTEXT));
     797                        DosError(FERR_DISABLEHARDERR);
     798                        if (!DosQueryFSInfo(toupper(*newname) - '@',
     799                                            FSIL_ALLOC,
     800                                            &fsa, sizeof(FSALLOCATE))) {
     801                          // Assume large file support
     802                          ullFreeBytes = (ULONGLONG) fsa.cUnitAvail * fsa.cSectorUnit *
     803                            fsa.cbSector;
     804                          if (ullFreeBytes) {
     805                            // Find item that will fit in available space
     806                            for (cntr = x + 1; wk->li->list[cntr]; cntr++) {
     807                              DosError(FERR_DISABLEHARDERR);
     808                              if (!DosQueryPathInfo(wk->li->list[cntr],
     809                                                    FIL_QUERYEASIZEL,
     810                                                    &fs4,
     811                                                    sizeof(fs4)) &&
     812                                  !(fs4.attrFile & FILE_DIRECTORY) &&
     813                                  // fixme to use CBLIST_TO_EASIZE?
     814                                  fs4.cbFile + fs4.cbList <= ullFreeBytes) {
     815                                // Swap with failing item
     816                                ptr = wk->li->list[x];
     817                                wk->li->list[x] = wk->li->list[cntr];
     818                                wk->li->list[cntr] = ptr;
     819                                goto Retry;
     820                              }
     821                            }
     822                            Notify(GetPString(IDS_COULDNTFITTEXT));
     823                          }
     824                        }
     825                        rc = saymsg(MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION,
     826                                    wk->hwndFrame,
     827                                    GetPString(IDS_DISKFULLTEXT),
     828                                    "%s", GetPString(IDS_ANOTHERDISKTEXT));
     829                        if (rc == MBID_RETRY)
     830                          goto Retry;
     831                        if (rc == MBID_ABORT)
     832                          goto Abort;
     833                      }
     834                      else if (rc == ERROR_PIPE_NOT_CONNECTED && iCounter < 25) {
     835                        DbgMsg(pszSrcFile, __LINE__, "ERROR_PIPE_NOT_CONNECTED retries %i", iCounter);
     836                        iCounter ++;
     837                        DosSleep(200);
     838                        goto Retry;
     839                      }
     840                      else {
     841                        if (LogFileHandle)
     842                          fprintf(LogFileHandle,
     843                                  GetPString(IDS_LOGTOFAILEDTEXT),
     844                                  move, wk->li->list[x], newname, rc);
     845                        rc = Dos_Error(MB_ENTERCANCEL,
     846                                       rc,
     847                                       wk->hwndFrame,
     848                                       pszSrcFile,
     849                                       __LINE__,
     850                                       "%s %s \"%s\" %s\"%s\" %s.",
     851                                       move,
     852                                       GetPString(IDS_OFTEXT),
     853                                       wk->li->list[x],
     854                                       GetPString(IDS_TOTEXT),
     855                                       newname, GetPString(IDS_FAILEDTEXT));
     856                        if (rc == MBID_CANCEL)
     857                          goto Abort;
     858                      }
     859                    }
     860                    else {
     861                      if (LogFileHandle)
     862                        fprintf(LogFileHandle,
     863                                "%s \"%s\" %s\"%s\"\n",
     864                                moved,
     865                                wk->li->list[x],
     866                                GetPString(IDS_TOTEXT), newname);
     867                      if (fSyncUpdates ||
     868                          AddToList(wk->li->list[x],
     869                                    &files, &numfiles, &numalloc))
     870                        Broadcast(hab2,
     871                                  wk->hwndCnr,
     872                                  UM_UPDATERECORD,
     873                                  MPFROMP(wk->li->list[x]), MPVOID);
     874                      if (fSyncUpdates ||
     875                          AddToList(newname, &files, &numfiles, &numalloc))
     876                        Broadcast(hab2,
     877                                  wk->hwndCnr,
     878                                  UM_UPDATERECORD, MPFROMP(newname), MPVOID);
     879                    }
     880                  }
     881                  break;
     882                }
    872883
    873884              case IDM_COMPARE:
Note: See TracChangeset for help on using the changeset viewer.