Changeset 1354


Ignore:
Timestamp:
Dec 25, 2008, 11:43:34 PM (17 years ago)
Author:
Gregg Young
Message:

Added driveflags to over ride write verify for USB removable drives that fail when it is on (Ticket 323); A flag to prevent directory name from being broadcast to drives in the tree cnr prior to a recursive scan of the drive (causes dbl directory names Ticket 321) Add option for multithreaded recursive scan of user selected drives at startup (Ticket 322).

Location:
trunk/dll
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/comp.c

    r1335 r1354  
    6666#include <share.h>
    6767#include <io.h>
     68#include <ctype.h>
    6869// #include <process.h>                 // _endthread
    6970
    … …  
    115116#include "fortify.h"                    // 06 May 08 SHL added
    116117#include "excputil.h"                   // xbeginthread
     118#include "info.h"                       // driveflags
    117119
    118120typedef struct
    … …  
    549551            break;
    550552
    551           case IDM_MOVE:
    552             if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR))
    553               BldFullPathName(szNewName, cmp->leftdir, pciS->pszDisplayName);
    554             else
    555               BldFullPathName(szNewName, cmp->rightdir, pciS->pszDisplayName);
    556             // Make directory if required
    557             strcpy(szDirName, szNewName);
    558             p = strrchr(szDirName, '\\');
    559             if (p) {
    560               if (p > szDirName + 2)
    561                 p++;
    562               *p = 0;
    563               if (IsFile(szDirName) == -1)
    564                 MassMkdir(hwndMain, szDirName);
    565             }
    566             rc = docopyf(MOVE, pciS->pszFileName, "%s", szNewName);
    567             if (!rc && stricmp(pciS->pszFileName, szNewName)) {
    568               WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciS),
    569                          MPFROM2SHORT(FALSE, CRA_SELECTED));
    570               if (pciD->rc.flRecordAttr & CRA_SELECTED)
    571                 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
    572                            MPFROM2SHORT(FALSE, CRA_SELECTED));
    573               FreeCnrItemData(pciD);
    574               pciD->pszFileName = xstrdup(szNewName, pszSrcFile, __LINE__);
    575               if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
    576                 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
    577                 if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
    578                   pciD->pszDisplayName++;
    579               }
    580               else {
    581                 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
    582                 if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
    583                   pciD->pszDisplayName++;
    584               }
    585               pciD->pszLongName = pciS->pszLongName;
    586               pciS->pszLongName = NullStr;      // 07 Sep 08 SHL avoid aliased pointer
    587               if (pciD->pszSubject != NullStr) {
    588                 xfree(pciD->pszSubject, pszSrcFile, __LINE__);
    589                 pciD->pszSubject = NullStr;
    590               }
    591               pciD->attrFile = pciS->attrFile;
    592               pciD->pszDispAttr = pciS->pszDispAttr;
    593               pciD->flags = 0;          // Just on one side
    594               pciD->date = pciS->date;
    595               pciD->time = pciS->time;
    596               pciD->ladate = pciS->ladate;
    597               pciD->latime = pciS->latime;
    598               pciD->crdate = pciS->crdate;
    599               pciD->crtime = pciS->crtime;
    600               pciD->cbFile = pciS->cbFile;
    601               pciD->easize = pciS->easize;
    602 
    603               if (pciS->pszFileName != NullStr) {
    604                 xfree(pciS->pszFileName, pszSrcFile, __LINE__);
    605                 pciS->pszFileName = NullStr;
    606                 pciS->pszDisplayName = pciS->pszFileName;
    607                 pciS->rc.pszIcon = pciS->pszFileName;
    608               }
    609               if (pciS->pszSubject != NullStr) {
    610                 xfree(pciS->pszSubject, pszSrcFile, __LINE__);
    611                 pciS->pszSubject = NullStr;
    612               }
    613               pciS->flags = 0;          // Just on one side
    614 
    615               WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pciS),
    616                          MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    617 
    618               WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
    619                          MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    620 
    621               if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_LEFTDIR))
    622                 cmp->cmp->totalleft--;
    623               else
    624                 cmp->cmp->totalright--;
    625             }
    626             else if (rc) {
    627               rc = Dos_Error(MB_ENTERCANCEL,
    628                              rc,
    629                              HWND_DESKTOP,
    630                              pszSrcFile,
    631                              __LINE__,
    632                              GetPString(IDS_COMPMOVEFAILEDTEXT),
    633                              pciS->pszFileName, szNewName);
    634               if (rc == MBID_CANCEL)    // Cause loop to break
    635                 pciNextS = NULL;
    636             }
    637             break;
    638 
    639           case IDM_COPY:
    640             if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR))
    641               BldFullPathName(szNewName, cmp->leftdir, pciS->pszDisplayName);
    642             else
    643               BldFullPathName(szNewName, cmp->rightdir, pciS->pszDisplayName);
    644             // Make directory if required
    645             strcpy(szDirName, szNewName);
    646             p = strrchr(szDirName, '\\');
    647             if (p) {
    648               if (p > szDirName + 2)
    649                 p++;
    650               *p = 0;
    651               if (IsFile(szDirName) == -1)
    652                 MassMkdir(hwndMain, szDirName);
    653             }
    654             rc = docopyf(COPY, pciS->pszFileName, "%s", szNewName);
    655             if (rc) {
    656               rc = Dos_Error(MB_ENTERCANCEL,
    657                              rc,
    658                              HWND_DESKTOP,
    659                              pszSrcFile,
    660                              __LINE__,
    661                              GetPString(IDS_COMPCOPYFAILEDTEXT),
    662                              pciS->pszFileName, szNewName);
    663               if (rc == MBID_CANCEL)
    664                 pciNextS = NULL;        // Cause loop to break
    665             }
    666             else {
    667               WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciS),
    668                          MPFROM2SHORT(FALSE, CRA_SELECTED));
    669               if (pciD->rc.flRecordAttr & CRA_SELECTED)
    670                 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
    671                            MPFROM2SHORT(FALSE, CRA_SELECTED));
    672               // 12 Jan 08 SHL
    673               if (pciD->pszFileName == NullStr) {
    674                 if (hwndCnrD == WinWindowFromID(cmp->hwnd, COMP_LEFTDIR))
    675                   cmp->totalleft++;
    676                 else
    677                   cmp->totalright++;
    678               }
    679               FreeCnrItemData(pciD);
    680               pciD->pszFileName = xstrdup(szNewName, pszSrcFile, __LINE__);
    681               if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
    682                 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
    683                 if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
    684                   pciD->pszDisplayName++;
    685               }
    686               else {
    687                 pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
    688                 if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
    689                   pciD->pszDisplayName++;
    690               }
    691               pciD->attrFile = pciS->attrFile;
    692               pciD->pszDispAttr = pciS->pszDispAttr;
    693               pciD->flags = CNRITEM_EXISTS;     // Now on both sides
    694               pciD->date = pciS->date;
    695               pciD->time = pciS->time;
    696               pciD->ladate = pciS->ladate;
    697               pciD->latime = pciS->latime;
    698               pciD->crdate = pciS->crdate;
    699               pciD->crtime = pciS->crtime;
    700               pciD->cbFile = pciS->cbFile;
    701               pciD->easize = pciS->easize;
    702 
    703               // Forget status until we regenerate it
    704               if (pciS->pszSubject != NullStr) {
    705                 xfree(pciS->pszSubject, pszSrcFile, __LINE__);
    706                 pciS->pszSubject = NullStr;
    707               }
    708               pciS->flags = CNRITEM_EXISTS;     // Now on both sides
    709 
    710               WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pciS),
    711                          MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    712               WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
    713                          MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    714             }
    715             break;
     553          case IDM_MOVE:
     554            {
     555              BOOL fResetVerify = FALSE;
     556
     557              if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR))
     558                BldFullPathName(szNewName, cmp->leftdir, pciS->pszDisplayName);
     559              else
     560                BldFullPathName(szNewName, cmp->rightdir, pciS->pszDisplayName);
     561              // Make directory if required
     562              strcpy(szDirName, szNewName);
     563              p = strrchr(szDirName, '\\');
     564              if (fVerify && (driveflags[toupper(*szNewName) - 'A'] & DRIVE_WRITEVERIFYOFF ||
     565                              driveflags[toupper(*pciS->pszFileName) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
     566                DosSetVerify(FALSE);
     567                fResetVerify = TRUE;
     568              }
     569              if (p) {
     570                if (p > szDirName + 2)
     571                  p++;
     572                *p = 0;
     573                if (IsFile(szDirName) == -1)
     574                  MassMkdir(hwndMain, szDirName);
     575              }
     576              rc = docopyf(MOVE, pciS->pszFileName, "%s", szNewName);
     577              if (fResetVerify) {
     578                DosSetVerify(fVerify);
     579                fResetVerify = FALSE;
     580              }
     581              if (!rc && stricmp(pciS->pszFileName, szNewName)) {
     582                WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciS),
     583                           MPFROM2SHORT(FALSE, CRA_SELECTED));
     584                if (pciD->rc.flRecordAttr & CRA_SELECTED)
     585                  WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
     586                             MPFROM2SHORT(FALSE, CRA_SELECTED));
     587                FreeCnrItemData(pciD);
     588                pciD->pszFileName = xstrdup(szNewName, pszSrcFile, __LINE__);
     589                if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
     590                  pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
     591                  if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
     592                    pciD->pszDisplayName++;
     593                }
     594                else {
     595                  pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
     596                  if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
     597                    pciD->pszDisplayName++;
     598                }
     599                pciD->pszLongName = pciS->pszLongName;
     600                pciS->pszLongName = NullStr;    // 07 Sep 08 SHL avoid aliased pointer
     601                if (pciD->pszSubject != NullStr) {
     602                  xfree(pciD->pszSubject, pszSrcFile, __LINE__);
     603                  pciD->pszSubject = NullStr;
     604                }
     605                pciD->attrFile = pciS->attrFile;
     606                pciD->pszDispAttr = pciS->pszDispAttr;
     607                pciD->flags = 0;                // Just on one side
     608                pciD->date = pciS->date;
     609                pciD->time = pciS->time;
     610                pciD->ladate = pciS->ladate;
     611                pciD->latime = pciS->latime;
     612                pciD->crdate = pciS->crdate;
     613                pciD->crtime = pciS->crtime;
     614                pciD->cbFile = pciS->cbFile;
     615                pciD->easize = pciS->easize;
     616
     617                if (pciS->pszFileName != NullStr) {
     618                  xfree(pciS->pszFileName, pszSrcFile, __LINE__);
     619                  pciS->pszFileName = NullStr;
     620                  pciS->pszDisplayName = pciS->pszFileName;
     621                  pciS->rc.pszIcon = pciS->pszFileName;
     622                }
     623                if (pciS->pszSubject != NullStr) {
     624                  xfree(pciS->pszSubject, pszSrcFile, __LINE__);
     625                  pciS->pszSubject = NullStr;
     626                }
     627                pciS->flags = 0;                // Just on one side
     628
     629                WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pciS),
     630                           MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
     631
     632                WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
     633                           MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
     634
     635                if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_LEFTDIR))
     636                  cmp->cmp->totalleft--;
     637                else
     638                  cmp->cmp->totalright--;
     639              }
     640              else if (rc) {
     641                rc = Dos_Error(MB_ENTERCANCEL,
     642                               rc,
     643                               HWND_DESKTOP,
     644                               pszSrcFile,
     645                               __LINE__,
     646                               GetPString(IDS_COMPMOVEFAILEDTEXT),
     647                               pciS->pszFileName, szNewName);
     648                if (rc == MBID_CANCEL)  // Cause loop to break
     649                  pciNextS = NULL;
     650              }
     651              break;
     652            }
     653
     654          case IDM_COPY:
     655            {
     656              BOOL fResetVerify = FALSE;
     657
     658              if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR))
     659                BldFullPathName(szNewName, cmp->leftdir, pciS->pszDisplayName);
     660              else
     661                BldFullPathName(szNewName, cmp->rightdir, pciS->pszDisplayName);
     662              // Make directory if required
     663              strcpy(szDirName, szNewName);
     664              p = strrchr(szDirName, '\\');
     665              if (fVerify && (driveflags[toupper(*szNewName) - 'A'] & DRIVE_WRITEVERIFYOFF ||
     666                                driveflags[toupper(*pciS->pszFileName) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
     667                DosSetVerify(FALSE);
     668                fResetVerify = TRUE;
     669              }
     670              if (p) {
     671                if (p > szDirName + 2)
     672                  p++;
     673                *p = 0;
     674                if (IsFile(szDirName) == -1)
     675                  MassMkdir(hwndMain, szDirName);
     676              }
     677              rc = docopyf(COPY, pciS->pszFileName, "%s", szNewName);
     678              if (fResetVerify) {
     679                DosSetVerify(fVerify);
     680                fResetVerify = FALSE;
     681              }
     682              if (rc) {
     683                rc = Dos_Error(MB_ENTERCANCEL,
     684                               rc,
     685                               HWND_DESKTOP,
     686                               pszSrcFile,
     687                               __LINE__,
     688                               GetPString(IDS_COMPCOPYFAILEDTEXT),
     689                               pciS->pszFileName, szNewName);
     690                if (rc == MBID_CANCEL)
     691                  pciNextS = NULL;      // Cause loop to break
     692              }
     693              else {
     694                WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciS),
     695                           MPFROM2SHORT(FALSE, CRA_SELECTED));
     696                if (pciD->rc.flRecordAttr & CRA_SELECTED)
     697                  WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
     698                             MPFROM2SHORT(FALSE, CRA_SELECTED));
     699                // 12 Jan 08 SHL
     700                if (pciD->pszFileName == NullStr) {
     701                  if (hwndCnrD == WinWindowFromID(cmp->hwnd, COMP_LEFTDIR))
     702                    cmp->totalleft++;
     703                  else
     704                    cmp->totalright++;
     705                }
     706                FreeCnrItemData(pciD);
     707                pciD->pszFileName = xstrdup(szNewName, pszSrcFile, __LINE__);
     708                if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
     709                  pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
     710                  if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
     711                    pciD->pszDisplayName++;
     712                }
     713                else {
     714                  pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
     715                  if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
     716                    pciD->pszDisplayName++;
     717                }
     718                pciD->attrFile = pciS->attrFile;
     719                pciD->pszDispAttr = pciS->pszDispAttr;
     720                pciD->flags = CNRITEM_EXISTS;   // Now on both sides
     721                pciD->date = pciS->date;
     722                pciD->time = pciS->time;
     723                pciD->ladate = pciS->ladate;
     724                pciD->latime = pciS->latime;
     725                pciD->crdate = pciS->crdate;
     726                pciD->crtime = pciS->crtime;
     727                pciD->cbFile = pciS->cbFile;
     728                pciD->easize = pciS->easize;
     729
     730                // Forget status until we regenerate it
     731                if (pciS->pszSubject != NullStr) {
     732                  xfree(pciS->pszSubject, pszSrcFile, __LINE__);
     733                  pciS->pszSubject = NullStr;
     734                }
     735                pciS->flags = CNRITEM_EXISTS;   // Now on both sides
     736
     737                WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pciS),
     738                           MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
     739                WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
     740                           MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
     741              }
     742              break;
     743            }
    716744
    717745          default:

  • trunk/dll/filldir.c

    r1347 r1354  
    118118CHAR *WPProgram;
    119119volatile INT StubbyScanCount;
     120volatile INT ProcessDirCount;
    120121
    121122typedef struct {
    … …  
    204205      hmq = WinCreateMsgQueue(thab, 0);
    205206      if (hmq) {
     207        StubbyScanCount++;
    206208        IncrThreadUsage();
    207209        priority_normal();
    208         StubbyScanCount++;
    209         ret = Stubby(StubbyScan->hwndCnr, StubbyScan->pci);
    210         if (ret == 0 && !StubbyScan->RamDrive) {
    211           if (WinIsWindow((HAB)0, StubbyScan->hwndCnr))
     210        ret = Stubby(StubbyScan->hwndCnr, StubbyScan->pci);
     211        //DbgMsg(pszSrcFile, __LINE__, "Stubby %i ", ret);
     212        if (ret == 1) {
     213          if (WinIsWindow((HAB)0, StubbyScan->hwndCnr)) {
    212214            WinSendMsg(StubbyScan->hwndCnr,
    213215                       CM_INVALIDATERECORD,
    214216                       MPFROMP(&StubbyScan->pci),
    215217                       MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     218            if (fRScanLocal) {
     219              if (!(driveflags[toupper(*StubbyScan->pci->pszFileName) - 'A'] &
     220                    ((fRScanNoWrite ? 0 : DRIVE_NOTWRITEABLE) |
     221                     (fRScanRemote ? 0 : DRIVE_REMOTE) |
     222                     (fRScanSlow ? 0 : DRIVE_SLOW) |
     223                     (fRScanVirtual ? 0 : DRIVE_VIRTUAL)))
     224                  && fInitialDriveScan) {
     225                WinSendMsg(StubbyScan->hwndCnr, CM_EXPANDTREE, MPFROMP(StubbyScan->pci), MPVOID);
     226                //DbgMsg(pszSrcFile, __LINE__, "expanded %x %s", StubbyScan->hwndCnr, StubbyScan->pci->pszFileName);
     227                WinSendMsg(StubbyScan->hwndCnr, CM_COLLAPSETREE, MPFROMP(StubbyScan->pci), MPVOID);
     228              }
     229            }
     230            else  if ((fRScanRemote && (driveflags[toupper(*StubbyScan->pci->pszFileName) - 'A'] &
     231                      DRIVE_REMOTE)) ||
     232                      (fRScanVirtual && (driveflags[toupper(*StubbyScan->pci->pszFileName) - 'A'] &
     233                                         DRIVE_VIRTUAL)) && fInitialDriveScan) {
     234              if (!(driveflags[toupper(*StubbyScan->pci->pszFileName) - 'A'] &
     235                    ((fRScanNoWrite ? NULL : DRIVE_NOTWRITEABLE) |
     236                     (fRScanSlow ? NULL : DRIVE_SLOW)))) {
     237                WinSendMsg(StubbyScan->hwndCnr, CM_EXPANDTREE, MPFROMP(StubbyScan->pci), MPVOID);
     238                //DbgMsg(pszSrcFile, __LINE__, "expanded %x %s", StubbyScan->hwndCnr, StubbyScan->pci->pszFileName);
     239                WinSendMsg(StubbyScan->hwndCnr, CM_COLLAPSETREE, MPFROMP(StubbyScan->pci), MPVOID);
     240              }
     241            }
    216242          }
     243        }
    217244        if (WinIsWindow((HAB)0, StubbyScan->hwndDrivesList)) {
    218245          WinSendMsg(StubbyScan->hwndDrivesList,
    … …  
    222249        }
    223250        StubbyScanCount--;
    224         if (StubbyScanCount == 0)
    225           fInitialDriveScan = FALSE;
     251       /* if (StubbyScanCount == 0) {
     252          if (fInitialDriveScan) {
     253            WinShowWindow(StubbyScan->hwndCnr, TRUE);
     254            WinShowWindow(StubbyScan->hwndDrivesList, TRUE);
     255          }
     256          fInitialDriveScan = FALSE;
     257        }*/
    226258        WinDestroyMsgQueue(hmq);
    227259      }
    … …  
    231263    free(StubbyScan);
    232264  } // if StubbyScan
     265# ifdef FORTIFY
     266  Fortify_LeaveScope();
     267#  endif
     268
     269  // _endthread();                      // 10 Dec 08 SHL
     270}
     271
     272VOID ProcessDirectoryThread(VOID * arg)
     273{
     274  PROCESSDIR *ProcessDir;
     275  HAB thab;
     276  HMQ hmq = (HMQ) 0;
     277  //BOOL ret;
     278
     279  DosError(FERR_DISABLEHARDERR);
     280
     281# ifdef FORTIFY
     282  Fortify_EnterScope();
     283#  endif
     284
     285  ProcessDir = (PROCESSDIR *)arg;
     286  if (ProcessDir && ProcessDir->pciParent && ProcessDir->pciParent->pszFileName && ProcessDir->hwndCnr) {
     287    thab = WinInitialize(0);
     288    if (thab) {
     289      hmq = WinCreateMsgQueue(thab, 0);
     290      if (hmq) {
     291        ProcessDirCount ++;
     292        IncrThreadUsage();
     293        priority_normal();
     294        ProcessDirectory(ProcessDir->hwndCnr,
     295                         ProcessDir->pciParent,
     296                         ProcessDir->szDirBase,
     297                         ProcessDir->filestoo,
     298                         ProcessDir->recurse,
     299                         ProcessDir->partial,
     300                         ProcessDir->stopflag,
     301                         ProcessDir->dcd,                       // Optional
     302                         ProcessDir->pulTotalFiles,     // Optional
     303                         ProcessDir->pullTotalBytes);   // Optional
     304        ProcessDirCount --;
     305        WinDestroyMsgQueue(hmq);
     306      }
     307      DecrThreadUsage();
     308      WinTerminate(thab);
     309    }
     310    free(ProcessDir);
     311  } // if ProcessDir
    233312# ifdef FORTIFY
    234313  Fortify_LeaveScope();
    … …  
    11531232                     MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
    11541233    while (pci && (INT)pci != -1) {
    1155       if (pci->attrFile & FILE_DIRECTORY)
    1156         Stubby(hwndCnr, pci);
     1234      if ((pci->attrFile & FILE_DIRECTORY))
     1235        if (fInitialDriveScan)
     1236          Stubby(hwndCnr, pci);
     1237        else {
     1238          while (StubbyScanCount != 0)
     1239            DosSleep(50);
     1240          Stubby(hwndCnr, pci);
     1241        }
     1242        //Stubby(hwndCnr, pci);
    11571243      pci = WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
    11581244                       MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    … …  
    12171303    driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    12181304                      DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
    1219                       DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS);
     1305                      DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS |
     1306                      DRIVE_WRITEVERIFYOFF);
    12201307  }
    12211308  memset(driveserial, -1, sizeof(driveserial));
    … …  
    13381425              driveflags[x] &= ~DRIVE_NOLONGNAMES;
    13391426          }
    1340 
     1427          if (!fVerifyOffChecked[x]) {
     1428            if (driveflags[x] & DRIVE_REMOVABLE)
     1429              driveflags[x] |= DRIVE_WRITEVERIFYOFF;
     1430            if (!(driveflags[x] & DRIVE_IGNORE | DRIVE_INVALID)) {
     1431              CHAR Key[80];
     1432
     1433              sprintf(Key, "%c.VerifyOffChecked", (CHAR) (x + 'A'));
     1434              fVerifyOffChecked[x] = TRUE;
     1435              PrfWriteProfileData(fmprof, appname, Key, &fVerifyOffChecked[x], sizeof(BOOL));
     1436            }
     1437          }
    13411438          pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
    13421439          if ((ULONG)(toupper(*szDrive) - '@') == ulCurDriveNum)
    … …  
    16071704    } // while
    16081705    StubbyScanCount--;
    1609     if (StubbyScanCount == 0)
    1610       fInitialDriveScan = FALSE;
    16111706  }
    16121707  if (hwndParent)
    … …  
    17021797    }
    17031798  }
    1704 
    17051799  didonce = TRUE;
    1706 
     1800  if (fInitialDriveScan) {
     1801    HWND hwndDrivesList = WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
     1802                                          MAIN_DRIVELIST);
     1803    while (StubbyScanCount != 0 || ProcessDirCount != 0)
     1804      DosSleep(50);
     1805    WinShowWindow(hwndCnr, TRUE);
     1806    WinShowWindow(hwndDrivesList, TRUE);
     1807    fInitialDriveScan = FALSE;
     1808  }
    17071809} // FillTreeCnr
    17081810

  • trunk/dll/filldir.h

    r1299 r1354  
    4949VOID FreeCnrItemData(PCNRITEM pci);
    5050INT RemoveCnrItems(HWND hwnd, PCNRITEM pci, USHORT usCnt, USHORT usFlags);
     51VOID ProcessDirectoryThread(VOID * arg);
    5152
    5253// Data declarations
    … …  
    5758extern HPOINTER hptrReadonly;
    5859extern HPOINTER hptrSystem;
    59 extern volatile INT  StubbyScanCount;
     60extern volatile INT StubbyScanCount;
     61extern volatile INT ProcessDirCount;
     62
     63typedef struct {
     64
     65  HWND     hwndCnr;
     66  PCNRITEM pciParent;
     67  CHAR     *szDirBase;
     68  BOOL     filestoo;
     69  BOOL     recurse;
     70  BOOL     partial;
     71  CHAR           *stopflag;
     72  DIRCNRDATA     *dcd;                // Optional
     73  ULONG          *pulTotalFiles;       // Optional
     74  PULONGLONG     pullTotalBytes;      // Optional
     75}
     76PROCESSDIR;
    6077
    6178#endif // FILLDIR_H

  • trunk/dll/flesh.c

    r1353 r1354  
    4949#include "notify.h"                     // Notify
    5050#include "wrappers.h"                   // xfree
     51#include "excputil.h"                   // xbeginthread
    5152
    5253// Data definitions
    … …  
    190191        DRIVE_INCLUDEFILES)
    191192      includefiles = TRUE;
    192     ProcessDirectory(hwndCnr,
    193                      pciParent,
    194                      pciParent->pszFileName,
    195                      includefiles,      // filestoo
    196                      TRUE,              // recurse
    197                      TRUE,              // partial
    198                      NULL,              // stop flag
    199                      dcd,
    200                      NULL,              // total files
    201                      NULL);             // total bytes
    202   }
     193    if (fInitialDriveScan) {
     194      PROCESSDIR *ProcessDir;
     195
     196      ProcessDir = xmallocz(sizeof(PROCESSDIR), pszSrcFile, __LINE__);
     197      if (!ProcessDir)
     198        return FALSE;
     199      ProcessDir->hwndCnr = hwndCnr;
     200      ProcessDir->pciParent = pciParent;
     201      ProcessDir->szDirBase = pciParent->pszFileName;
     202      ProcessDir->filestoo = includefiles;
     203      ProcessDir->recurse = TRUE;
     204      ProcessDir->partial = TRUE;
     205      ProcessDir->stopflag = NULL;
     206      ProcessDir->dcd = dcd;
     207      ProcessDir->pulTotalFiles = NULL;
     208      ProcessDir->pullTotalBytes = NULL;
     209
     210      if (xbeginthread(ProcessDirectoryThread,
     211                       65536,
     212                       ProcessDir,
     213                       pszSrcFile,
     214                       __LINE__) == -1)
     215      {
     216        xfree(ProcessDir, pszSrcFile, __LINE__);
     217      }
     218    }
     219    else  {
     220      ProcessDirectory(hwndCnr,
     221                       pciParent,
     222                       pciParent->pszFileName,
     223                       includefiles,    // filestoo
     224                       TRUE,            // recurse
     225                       TRUE,            // partial
     226                       NULL,            // stop flag
     227                       dcd,
     228                       NULL,            // total files
     229                       NULL);           // total bytes
     230    }
     231  }
     232  driveflags[*pciParent->pszFileName - 'A'] |= DRIVE_RSCANNED;
    203233  return TRUE;
    204234}
    … …  
    457487            ri.cRecordsInsert = 1;
    458488            ri.fInvalidateRecord = TRUE;
    459             DbgMsg(pszSrcFile, __LINE__, "Stubby %p CM_INSERTRECORD \"%s\" %.255s", hwndCnr, pci->pszFileName, pffb->achName); // 18 Dec 08 SHL fixme debug
     489            //DbgMsg(pszSrcFile, __LINE__, "Stubby %p CM_INSERTRECORD \"%s\" %.255s", hwndCnr, pci->pszFileName, pffb->achName); // 18 Dec 08 SHL fixme debug
    460490            if (!WinSendMsg(hwndCnr,
    461491                            CM_INSERTRECORD, MPFROMP(pci), MPFROMP(&ri))) {
    … …  
    463493              WinSetFocus(HWND_DESKTOP, hwndCnr);
    464494              if (WinIsWindow((HAB)0, hwndCnr)) {
    465                 DbgMsg(pszSrcFile, __LINE__, "Stubby %p CM_INSERTRECORD %s", hwndCnr, pci->pszFileName); // 18 Dec 08 SHL fixme debug
     495                //DbgMsg(pszSrcFile, __LINE__, "Stubby %p CM_INSERTRECORD %s", hwndCnr, pci->pszFileName); // 18 Dec 08 SHL fixme debug
    466496                if (!WinSendMsg(hwndCnr,
    467497                                CM_INSERTRECORD, MPFROMP(pci), MPFROMP(&ri))) {

  • trunk/dll/fm3dlg.h

    r1306 r1354  
    689689#define CFGH_RUNFTPWORKDIR                                                              25348
    690690#define CFGH_RUNHTTPWORKDIR                                                     25349
     691#define CFGH_LIBPATHSTRICTMAILRUN                                       25350
    691692#define CFGH_RUNMAILWORKDIR                                                     25351
    692693#define CFGH_MAILRUN                                                                            25352
    … …  
    695696#define CFGH_LIBPATHSTRICTHTTPRUN                                       25357
    696697#define CFGH_LIBPATHSTRICTFTPRUN                                                25358
    697 #define CFGH_FIND                                                                                       25359
    698 #define CFGH_LIBPATHSTRICTMAILRUN                                       25360
     698#define CFGH_FIND                                                               25359
     699
    699700
    700701#define CFGS_FRAME                                                                              25360
    … …  
    706707#define CFGS_FORCELOWER                                                                 25366
    707708#define CFGS_REMOTEBUG                                                                  25367
    708 #define CFGS_NOREMOVABLESCAN                                                    25368
     709#define CFGS_NOREMOVABLESCAN                                                            25368
    709710#define CFGS_FILESTOGET                                                                 25369
    710 
    711 #define CFGA_FRAME                                                                              25370
    712 #define CFGA_QUICKARCFIND                                                               25371
    713 #define CFGA_DEFARCNAME                                                                 25372
    714 #define CFGA_DEFARC                                                                             25373
    715 #define CFGA_FOLDERAFTEREXTRACT                                         25374
    716 #define CFGA_ARCSTUFFVISIBLE                                                    25375
    717 #define CFGA_VIRUS                                                                              25376
    718 #define CFGA_EXTRACTPATH                                                                25377
    719 #define CFGA_FIND                                                                               25378
    720 #define CFGA_FILENAMEPATH                                                               25379
     711#define CFGS_RSCANLOCAL                                                                 25370
     712#define CFGS_RSCANREMOTE                                                                25371
     713#define CFGS_RSCANVIRTUAL                                                               25372
     714#define CFGS_RSCANSLOW                                                                  25373
     715#define CFGS_RSCANNOWRITE                                                               25374
     716
     717#define CFGA_FRAME                                                                              25380
     718#define CFGA_QUICKARCFIND                                                               25381
     719#define CFGA_DEFARCNAME                                                                 25382
     720#define CFGA_DEFARC                                                                             25383
     721#define CFGA_FOLDERAFTEREXTRACT                                         25384
     722#define CFGA_ARCSTUFFVISIBLE                                                    25385
     723#define CFGA_VIRUS                                                                              25386
     724#define CFGA_EXTRACTPATH                                                                25387
     725#define CFGA_FIND                                                                               25388
     726#define CFGA_FILENAMEPATH                                                               25389
    721727
    722728#define CFG5_FRAME                                                                              25500
    … …  
    902908#define DVS_NOSTATS                                                                             27017
    903909#define DVS_RAMDISK                                                                             27018
     910#define DVS_WRITEVERIFYOFF                                                                      27019
     911#define DVS_RSCANNED                                                                            27020
    904912
    905913#define MRG_FRAME                                                                                       27100

  • trunk/dll/fm3dll.h

    r1325 r1354  
    155155#define DRIVE_NOSTATS       0x00010000
    156156#define DRIVE_RAMDISK       0x00020000
     157#define DRIVE_WRITEVERIFYOFF 0x00040000
     158#define DRIVE_RSCANNED      0x00080000
    157159
    158160#define SORT_FIRSTEXTENSION 0x00000001

  • trunk/dll/fm3res.dlg

    r1338 r1354  
    19151915    BEGIN
    19161916        AUTOCHECKBOX    "Load Subjects", CFGS_LOADSUBJECTS, 4, 128, 106, 10
    1917         AUTOCHECKBOX    "Load Longnames", CFGS_LOADLONGNAMES, 4, 116, 106,
    1918                         10
    1919         AUTOCHECKBOX    "Load file icons", CFGS_NOICONSFILES, 4, 104, 106,
    1920                         10
     1917        AUTOCHECKBOX    "Load Longnames", CFGS_LOADLONGNAMES, 4, 116, 106, 10
     1918        AUTOCHECKBOX    "Load file icons", CFGS_NOICONSFILES, 4, 104, 106, 10
    19211919        AUTOCHECKBOX    "Load dir icons", CFGS_NOICONSDIRS, 4, 92, 106, 10
    19221920        AUTOCHECKBOX    "Uppercase names", CFGS_FORCEUPPER, 4, 80, 106, 10
    19231921        AUTOCHECKBOX    "Lowercase names", CFGS_FORCELOWER, 4, 68, 106, 10
    19241922        AUTOCHECKBOX    "Remote find bug", CFGS_REMOTEBUG, 4, 56, 106, 10
    1925         AUTOCHECKBOX    "Don't scan removables", CFGS_NOREMOVABLESCAN, 4, 44,
    1926                         106, 10
     1923        AUTOCHECKBOX    "Don't scan removables", CFGS_NOREMOVABLESCAN, 4, 44, 106, 10
    19271924        LTEXT           "Find count", -1, 4, 28, 54, 12, NOT WS_GROUP
    19281925        CONTROL         "", CFGS_FILESTOGET, 44, 30, 64, 12, WC_SPINBUTTON,
    … …  
    19301927                        SPBS_JUSTCENTER | WS_TABSTOP | SPBS_FASTSPIN |
    19311928                        WS_VISIBLE
     1929        LTEXT           "Recurse scan at startup:", -1, 130, 128, 106, 10, NOT WS_GROUP
     1930        AUTOCHECKBOX    "Local hard drives", CFGS_RSCANLOCAL, 136, 116, 106, 10
     1931        AUTOCHECKBOX    "Remote drives", CFGS_RSCANREMOTE, 136, 104, 106, 10
     1932        AUTOCHECKBOX    "Virtual drives", CFGS_RSCANVIRTUAL, 136, 92, 106, 10
     1933        AUTOCHECKBOX    "Slow drives of drive types selected", CFGS_RSCANSLOW,
     1934                        142, 80, 136, 10
     1935        AUTOCHECKBOX    "Read only drives of drive types selected", CFGS_RSCANNOWRITE,
     1936                        142, 68, 136, 10
    19321937        PUSHBUTTON      "~Help", IDM_HELP, 120, 4, 40, 14, BS_NOPOINTERFOCUS |
    19331938                        WS_GROUP
    … …  
    20342039            FCF_TITLEBAR
    20352040    BEGIN
    2036         CHECKBOX       "Virtual Drive", DVS_VIRTUAL, 4, 122, 94, 10,
     2041        CHECKBOX       "Virtual Drive", DVS_VIRTUAL, 4, 126, 94, 10,
    20372042                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20382043                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2039         CHECKBOX        "Removable", DVS_REMOVABLE, 4, 110, 94, 10,
     2044        CHECKBOX        "Removable", DVS_REMOVABLE, 4, 114, 94, 10,
    20402045                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20412046                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2042         CHECKBOX        "RAMDISK", DVS_RAMDISK, 4, 98, 94, 10,
     2047        CHECKBOX        "RAMDISK", DVS_RAMDISK, 4, 102, 98, 10,
    20432048                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20442049                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2045         CHECKBOX        "Remote Drive", DVS_REMOTE, 4, 86, 94, 10,
     2050        CHECKBOX        "Remote Drive", DVS_REMOTE, 4, 90, 94, 10,
    20462051                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20472052                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2048         CHECKBOX        "CD-ROM", DVS_CDROM, 4, 74, 94, 10,
     2053        CHECKBOX        "CD-ROM", DVS_CDROM, 4, 78, 94, 10,
    20492054                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20502055                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2051         CHECKBOX        "Zipstream", DVS_ZIPSTREAM, 4, 62, 94, 10,
     2056        CHECKBOX        "Zipstream", DVS_ZIPSTREAM, 4, 66, 94, 10,
    20522057                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20532058                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2054         CHECKBOX        "Ignore", DVS_IGNORE, 4, 50, 94, 10,
     2059        CHECKBOX        "Ignore", DVS_IGNORE, 4, 54, 94, 10,
    20552060                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20562061                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2057         CHECKBOX        "Boot drive", DVS_BOOT, 4, 38, 94, 10,
     2062        CHECKBOX        "Boot drive", DVS_BOOT, 4, 42, 94, 10,
    20582063                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20592064                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2060         CHECKBOX        "Invalid", DVS_INVALID, 4, 26, 94, 10,
     2065        CHECKBOX        "Invalid", DVS_INVALID, 4, 30, 94, 10,
    20612066                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20622067                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2063         CHECKBOX        "Not writeable", DVS_NOTWRITEABLE, 106, 122, 94, 10,
     2068        CHECKBOX        "Recursive scan done", DVS_RSCANNED, 4, 18, 94, 10,
    20642069                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20652070                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2066         CHECKBOX        "~No longnames", DVS_NOLONGNAMES, 106, 110, 94, 10,
     2071        CHECKBOX        "Not writeable", DVS_NOTWRITEABLE, 106, 126, 94, 10,
    20672072                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    20682073                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
    2069         AUTOCHECKBOX    "No ~Prescan", DVS_NOPRESCAN, 106, 98, 94, 10,
    2070                         BS_NOPOINTERFOCUS | NOT WS_TABSTOP
    2071         AUTOCHECKBOX    "~Don't load icons", DVS_NOLOADICONS, 106, 86, 94,10, BS_NOPOINTERFOCUS
    2072         AUTOCHECKBOX    "Don't load ~subjects", DVS_NOLOADSUBJS, 106, 74, 94,10, BS_NOPOINTERFOCUS
    2073         AUTOCHECKBOX    "Don't load ~longnames", DVS_NOLOADLONGS, 106, 62,106, 10, BS_NOPOINTERFOCUS
    2074         AUTOCHECKBOX    "Slo~w drive", DVS_SLOW, 106, 50, 94, 10, BS_NOPOINTERFOCUS
    2075         AUTOCHECKBOX    "Include ~files in tree", DVS_INCLUDEFILES, 106, 38,106, 10, BS_NOPOINTERFOCUS
    2076         AUTOCHECKBOX    "~No drive stats", DVS_NOSTATS, 106, 26,106, 10, BS_NOPOINTERFOCUS
     2074        CHECKBOX        "~No longnames", DVS_NOLONGNAMES, 106, 114, 94, 10,
     2075                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
     2076                        PRESPARAMS PP_FOREGROUNDCOLOR, 0x00808080L
     2077        AUTOCHECKBOX    "No ~Prescan", DVS_NOPRESCAN, 106, 102, 94, 10,
     2078                        BS_NOPOINTERFOCUS | NOT WS_TABSTOP
     2079        AUTOCHECKBOX    "~Don't load icons", DVS_NOLOADICONS, 106, 90, 94,10, BS_NOPOINTERFOCUS
     2080        AUTOCHECKBOX    "Don't load ~subjects", DVS_NOLOADSUBJS, 106, 78, 94,10, BS_NOPOINTERFOCUS
     2081        AUTOCHECKBOX    "Don't load ~longnames", DVS_NOLOADLONGS, 106, 66,106, 10, BS_NOPOINTERFOCUS
     2082        AUTOCHECKBOX    "Slo~w drive", DVS_SLOW, 106, 54, 94, 10, BS_NOPOINTERFOCUS
     2083        AUTOCHECKBOX    "Include ~files in tree", DVS_INCLUDEFILES, 106, 42,106, 10, BS_NOPOINTERFOCUS
     2084        AUTOCHECKBOX    "~No drive stats", DVS_NOSTATS, 106, 30, 106, 10, BS_NOPOINTERFOCUS
     2085        AUTOCHECKBOX    "Write ~verify off", DVS_WRITEVERIFYOFF, 106, 18, 106, 10, BS_NOPOINTERFOCUS
    20772086        DEFPUSHBUTTON   "Okay", DID_OK, 4, 4, 40, 14, BS_NOPOINTERFOCUS | WS_GROUP
    20782087        PUSHBUTTON      "~Help", IDM_HELP, 64, 4, 40, 14, BS_NOPOINTERFOCUS
    … …  
    27702779        AUTOCHECKBOX    "~Link sets icon", CFGG_LINKSETSICON, 122, 128, 106,
    27712780                        10
    2772         AUTOCHECKBOX    "~Verify disk writes", CFGG_VERIFYWRITES, 122, 116,
    2773                         132, 10
     2781        AUTOCHECKBOX    "~Verify disk writes (also check individual driveflags)",
     2782                        CFGG_VERIFYWRITES, 122, 116, 162, 10
    27742783        AUTOCHECKBOX    "~Drag&drop dialog", CFGG_DNDDLG, 122, 104, 106, 10
    27752784        AUTOCHECKBOX    "Default delete ~permanent", CFGG_DEFAULTDELETEPERM, 122,

  • trunk/dll/info.c

    r1347 r1354  
    982982                     ((driveflags[drive] & DRIVE_INCLUDEFILES) != 0));
    983983      WinCheckButton(hwnd,DVS_NOSTATS,
    984                      ((driveflags[drive] & DRIVE_NOSTATS) != 0));
     984                     ((driveflags[drive] & DRIVE_NOSTATS) != 0));
     985      WinCheckButton(hwnd,DVS_WRITEVERIFYOFF,
     986                     ((driveflags[drive] & DRIVE_WRITEVERIFYOFF) != 0));
     987      WinCheckButton(hwnd,DVS_RSCANNED,
     988                     ((driveflags[drive] & DRIVE_RSCANNED) != 0));
    985989    }
    986990    return 0;
    … …  
    10221026          driveflags[drive] |= DRIVE_NOSTATS;
    10231027        else
    1024           driveflags[drive] &= (~DRIVE_NOSTATS);
     1028          driveflags[drive] &= (~DRIVE_NOSTATS);
     1029        if (WinQueryButtonCheckstate(hwnd,DVS_WRITEVERIFYOFF))
     1030          driveflags[drive] |= DRIVE_WRITEVERIFYOFF;
     1031        else
     1032          driveflags[drive] &= (~DRIVE_WRITEVERIFYOFF);
     1033        if (WinQueryButtonCheckstate(hwnd,DVS_RSCANNED))
     1034          driveflags[drive] |= DRIVE_RSCANNED;
     1035        else
     1036          driveflags[drive] &= (~DRIVE_RSCANNED);
    10251037        {
    10261038          ULONG flags;
    1027           CHAR s[80];
    1028 
    1029           sprintf(s, "%c.DriveFlags", (CHAR) (drive + 'A'));
     1039          CHAR FlagKey[80];
     1040
     1041          sprintf(FlagKey, "%c.DriveFlags", (CHAR) (drive + 'A'));
    10301042          flags = driveflags[drive];
    10311043          flags &= (~(DRIVE_REMOVABLE | DRIVE_NOTWRITEABLE |
    10321044                      DRIVE_IGNORE | DRIVE_CDROM |
    1033                       DRIVE_NOLONGNAMES | DRIVE_REMOTE |
     1045                      DRIVE_REMOTE | DRIVE_RSCANNED |
    10341046                      DRIVE_BOOT | DRIVE_INVALID | DRIVE_ZIPSTREAM |
    10351047                      DRIVE_VIRTUAL  | DRIVE_RAMDISK));
    1036           PrfWriteProfileData(fmprof, appname, s, &flags, sizeof(ULONG));
     1048          PrfWriteProfileData(fmprof, appname, FlagKey, &flags, sizeof(ULONG));
    10371049        }
    10381050      }

  • trunk/dll/init.c

    r1351 r1354  
    15491549  PrfQueryProfileData(fmprof, appname, "RemoteBug", &fRemoteBug, &size);
    15501550  size = sizeof(BOOL);
     1551  PrfQueryProfileData(fmprof, appname, "RScanLocal", &fRScanLocal, &size);
     1552  size = sizeof(BOOL);
     1553  PrfQueryProfileData(fmprof, appname, "RScanRemote", &fRScanRemote, &size);
     1554  size = sizeof(BOOL);
     1555  PrfQueryProfileData(fmprof, appname, "RScanVirtual", &fRScanVirtual, &size);
     1556  size = sizeof(BOOL);
     1557  PrfQueryProfileData(fmprof, appname, "RScanSlow", &fRScanSlow, &size);
     1558  size = sizeof(BOOL);
     1559  PrfQueryProfileData(fmprof, appname, "RScanNoWrite", &fRScanNoWrite, &size);
     1560  size = sizeof(BOOL);
    15511561  PrfQueryProfileData(fmprof, appname, "Drag&DropDlg", &fDragndropDlg, &size);
    15521562  size = sizeof(BOOL);

  • trunk/dll/mainwnd.c

    r1335 r1354  
    34193419          if (hwndDir) {
    34203420            hwndC = WinWindowFromID(hwndDir, FID_CLIENT);
    3421             if (hwndC) {
     3421            if (hwndC) {
    34223422              HWND hwndCnr = WinWindowFromID(hwndC, DIR_CNR);
    34233423              if (!hwndPPSave) {
    … …  
    34953495                                   MPFROMLONG(sizeof(CNRINFO)))) {
    34963496                      cnri.flWindowAttr = dcd->flWindowAttr;
    3497                       WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
    3498                                 CM_SETCNRINFO,
    3499                                 MPFROMP(&cnri),
    3500                                 MPFROMLONG(CMA_FLWINDOWATTR));
     3497                      WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
     3498                                CM_SETCNRINFO,
     3499                                MPFROMP(&cnri),
     3500                                MPFROMLONG(CMA_FLWINDOWATTR));
    35013501                    }
    35023502                  }
    … …  
    35043504                if (fDeleteState)
    35053505                  PrfWriteProfileData(fmprof, FM3Str, szKey, NULL, 0L);
    3506                   if (!PostMsg(hwndCnr, UM_SETUP2, NULL, NULL))
    3507                     WinSendMsg(hwndCnr, UM_SETUP2, NULL, NULL);
    3508               }
     3506                if (!PostMsg(hwndCnr, UM_SETUP2, NULL, NULL))
     3507                  WinSendMsg(hwndCnr, UM_SETUP2, NULL, NULL);
     3508              }
    35093509            }
    35103510            fRestored = TRUE;
    … …  
    57035703                                    WC_COMBOBOX,
    57045704                                    (PSZ) NULL,
    5705                                     WS_VISIBLE | CBS_DROPDOWN,
     5705                                    //WS_VISIBLE |
     5706                                    CBS_DROPDOWN,
    57065707                                    (swp.x +
    57075708                                     WinQuerySysValue(HWND_DESKTOP,

  • trunk/dll/misc.c

    r1253 r1354  
    9696#include "commafmt.h"                   // CommaFmtULL
    9797#include "fortify.h"
     98#include "info.h"                       // driveflags
    9899
    99100#define CONTAINER_COLUMNS       13      /* Number of columns in details view */
    … …  
    798799      CHAR szData[CCHMAXPATH], testname[CCHMAXPATH];
    799800      HWND hwndMLE = WinWindowFromID(hwnd, CID_MLE);
     801      BOOL fResetVerify = FALSE;
    800802
    801803      if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
    … …  
    925927                return (MRESULT) FALSE;
    926928              }
     929              if (fVerify && (driveflags[toupper(*szData) - 'A'] & DRIVE_WRITEVERIFYOFF ||
     930                              driveflags[toupper(*testname) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
     931                DosSetVerify(FALSE);
     932                fResetVerify = TRUE;
     933              }
    927934              if (docopyf(MOVE, szData, "%s", testname))
    928935                Runtime_Error(pszSrcFile, __LINE__, "docopyf");
    … …  
    945952                  }
    946953                }
     954              }
     955              if (fResetVerify) {
     956                DosSetVerify(fVerify);
     957                fResetVerify = FALSE;
    947958              }
    948959            }

  • trunk/dll/mkdir.c

    r1348 r1354  
    4444CHAR targetdir[CCHMAXPATH];
    4545
    46 static PSZ pszSrcFile = __FILE__;
     46//static PSZ pszSrcFile = __FILE__;
    4747
    4848APIRET MassMkdir(HWND hwndClient, CHAR * dir)
    … …  
    7474    if (!last) {
    7575      Broadcast((HAB) 0, hwndClient, UM_UPDATERECORD, MPFROMP(s), MPVOID);
    76       DbgMsg(pszSrcFile, __LINE__, "UM_UPDATERECORD %s", s);
     76      //DbgMsg(pszSrcFile, __LINE__, "UM_UPDATERECORD %s", s);
    7777    }
    7878    else if (last == ERROR_ACCESS_DENIED) {
    … …  
    100100  APIRET ret = 0, error;
    101101  INT isfile;
     102  BOOL fResetVerify = FALSE;
    102103
    103104  if (DosQueryPathInfo(dir, FIL_QUERYFULLNAME, s, sizeof(s)))
    … …  
    141142        return -3;
    142143    }
    143     error = MassMkdir(hwndClient, s);
     144    if (fVerify && driveflags[toupper(*s) - 'A'] & DRIVE_WRITEVERIFYOFF) {
     145      DosSetVerify(FALSE);
     146      fResetVerify = TRUE;
     147    }
     148    error = MassMkdir(hwnd, s);
     149    if (fResetVerify) {
     150      DosSetVerify(fVerify);
     151      fResetVerify = FALSE;
     152    }
    144153    if (error) {
    145154      Dos_Error(MB_CANCEL,
    … …  
    165174  CHAR szBuff[CCHMAXPATH];
    166175  APIRET error;
     176  BOOL fResetVerify = FALSE;
    167177
    168178Over:
    … …  
    190200      goto Over;
    191201    }
     202    if (fVerify && driveflags[toupper(*szBuff) - 'A'] & DRIVE_WRITEVERIFYOFF) {
     203      DosSetVerify(FALSE);
     204      fResetVerify = TRUE;
     205    }
    192206    error = MassMkdir(hwnd, szBuff);
     207    if (fResetVerify) {
     208      DosSetVerify(fVerify);
     209      fResetVerify = FALSE;
     210    }
    193211    if (error)
    194212      Dos_Error(MB_ENTER,

  • trunk/dll/notebook.c

    r1306 r1354  
    8282#include "wrappers.h"                   // xmalloc
    8383#include "fortify.h"
     84#include "info.h"                       // driveflags
    8485
    8586static VOID SaveLastPageIndex(HWND hwnd);
    … …  
    133134BOOL fRealIdle;
    134135BOOL fRemoteBug;
     136BOOL fRScanLocal;
     137BOOL fRScanRemote;
     138BOOL fRScanVirtual;
     139BOOL fRScanSlow;
     140BOOL fRScanNoWrite;
    135141BOOL fSaveState;
    136142BOOL fSeparateParms;
    … …  
    469475    WinCheckButton(hwnd, CFGS_FORCEUPPER, fForceUpper);
    470476    WinCheckButton(hwnd, CFGS_NOREMOVABLESCAN, fNoRemovableScan);
     477    WinCheckButton(hwnd, CFGS_RSCANLOCAL, fRScanLocal);
     478    WinCheckButton(hwnd, CFGS_RSCANREMOTE, fRScanRemote);
     479    WinCheckButton(hwnd, CFGS_RSCANVIRTUAL, fRScanVirtual);
     480    WinCheckButton(hwnd, CFGS_RSCANSLOW, fRScanSlow);
     481    WinCheckButton(hwnd, CFGS_RSCANNOWRITE, fRScanNoWrite);
    471482    WinCheckButton(hwnd, CFGS_REMOTEBUG, fRemoteBug);
    472483    WinSendDlgItemMsg(hwnd, CFGS_FILESTOGET, SPBM_SETCURRENTVALUE,
    … …  
    527538    fRemoteBug = WinQueryButtonCheckstate(hwnd, CFGS_REMOTEBUG);
    528539    PrfWriteProfileData(fmprof, appname, "RemoteBug", &fRemoteBug,
     540                        sizeof(BOOL));
     541    fRScanLocal = WinQueryButtonCheckstate(hwnd, CFGS_RSCANLOCAL);
     542    PrfWriteProfileData(fmprof, appname, "RScanLocal", &fRScanLocal,
     543                        sizeof(BOOL));
     544    fRScanRemote = WinQueryButtonCheckstate(hwnd, CFGS_RSCANREMOTE);
     545    PrfWriteProfileData(fmprof, appname, "RScanRemote", &fRScanRemote,
     546                        sizeof(BOOL));
     547    fRScanVirtual = WinQueryButtonCheckstate(hwnd, CFGS_RSCANVIRTUAL);
     548    PrfWriteProfileData(fmprof, appname, "RScanVirtual", &fRScanVirtual,
     549                        sizeof(BOOL));
     550    fRScanSlow = WinQueryButtonCheckstate(hwnd, CFGS_RSCANSLOW);
     551    PrfWriteProfileData(fmprof, appname, "RScanSlow", &fRScanSlow,
     552                        sizeof(BOOL));
     553    fRScanNoWrite = WinQueryButtonCheckstate(hwnd, CFGS_RSCANNOWRITE);
     554    PrfWriteProfileData(fmprof, appname, "RScanNoWrite", &fRScanNoWrite,
    529555                        sizeof(BOOL));
    530556    fNoRemovableScan = WinQueryButtonCheckstate(hwnd, CFGS_NOREMOVABLESCAN);
    … …  
    32733299      fFolderAfterExtract = FALSE;
    32743300      fVerify = TRUE;
     3301      DosSetVerify(TRUE);
    32753302      fNoSearch = TRUE;
    3276       DosSetVerify(TRUE);
    32773303      fForceUpper = FALSE;
    32783304      fForceLower = TRUE;

  • trunk/dll/notebook.h

    r1241 r1354  
    7474extern BOOL fRealIdle;
    7575extern BOOL fRemoteBug;
     76extern BOOL fRScanLocal;
     77extern BOOL fRScanRemote;
     78extern BOOL fRScanVirtual;
     79extern BOOL fRScanSlow;
     80extern BOOL fRScanNoWrite;
    7681extern BOOL fSaveState;
    7782extern BOOL fSeparateParms;

  • trunk/dll/rename.c

    r1226 r1354  
    1717
    1818#include <string.h>
     19#include <ctype.h>
    1920
    2021#define INCL_WIN
    … …  
    3637#include "commafmt.h"                   // CommaFmtULL
    3738#include "strips.h"                     // bstrip
     39#include "info.h"                       // driveflags
    3840
    3941MRESULT EXPENTRY RenameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    … …  
    238240        CHAR newexist[CCHMAXPATH], fullname[CCHMAXPATH];
    239241        INT was;
    240         APIRET rc;
     242        APIRET rc;
     243        BOOL fResetVerify = FALSE;
    241244
    242245        *newexist = 0;
    … …  
    247250            strcpy(fullname, newexist);
    248251          was = IsFile(fullname);
    249           if (was == -1) {
    250             rc = docopyf(MOVE, mv->target, "%s", fullname);
     252          if (was == -1) {
     253            if (fVerify && (driveflags[toupper(*mv->target) - 'A'] & DRIVE_WRITEVERIFYOFF ||
     254                              driveflags[toupper(*fullname) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
     255              DosSetVerify(FALSE);
     256              fResetVerify = TRUE;
     257            }
     258            rc = docopyf(MOVE, mv->target, "%s", fullname);
     259            if (fResetVerify) {
     260              DosSetVerify(fVerify);
     261              fResetVerify = FALSE;
     262            }
    251263            if (rc) {
    252264              if ((LONG) rc > 0)

  • trunk/dll/seeall.c

    r1335 r1354  
    613613          INT type;
    614614          FILESTATUS4L fs4;
    615           BOOL isnewer, existed;
     615          BOOL isnewer, existed, fResetVerify = FALSE;
    616616
    617617          for (x = 0; list[x]; x++) {
    … …  
    731731                             message);
    732732            if (fRealIdle)
    733               priority_idle();
     733              priority_idle();
     734            if (fVerify && (driveflags[toupper(*list[x]) - 'A'] & DRIVE_WRITEVERIFYOFF ||
     735                            driveflags[toupper(*newname) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
     736              DosSetVerify(FALSE);
     737              fResetVerify = TRUE;
     738            }
    734739            if (plen) {
    735740              /* make directory/ies, if required */
    … …  
    745750              }
    746751            }
    747             rc = docopyf(type, list[x], "%s", newname);
     752            rc = docopyf(type, list[x], "%s", newname);
     753            if (fResetVerify) {
     754              DosSetVerify(fVerify);
     755              fResetVerify = FALSE;
     756            }
    748757            priority_normal();
    749758            if (rc) {

  • trunk/dll/treecnr.c

    r1352 r1354  
    19451945                                DRIVE_NOLOADICONS | DRIVE_NOLOADSUBJS |
    19461946                                DRIVE_NOLOADLONGS | DRIVE_INCLUDEFILES |
    1947                                 DRIVE_SLOW | DRIVE_NOSTATS);
     1947                                DRIVE_SLOW | DRIVE_NOSTATS |
     1948                                DRIVE_WRITEVERIFYOFF);
    19481949
    19491950              if (removable == 1)
    … …  
    27402741                driveflags[toupper(*pci->pszFileName) - 'A'] &=
    27412742                  (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    2742                    DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS | DRIVE_NOSTATS);
     2743                   DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS | DRIVE_NOSTATS |
     2744                   DRIVE_WRITEVERIFYOFF);
    27432745                DriveFlagsOne(toupper(*pci->pszFileName) - 'A');
    27442746                driveflag = driveflags[toupper(*pci->pszFileName) - 'A'];

  • trunk/dll/valid.c

    r1351 r1354  
    6868CHAR *NTFS;
    6969CHAR *RAMFS;
     70BOOL fVerifyOffChecked[26];
    7071
    7172APIRET MakeFullName(char *pszFileName)
    … …  
    598599      strcat(fname, ".");
    599600      ret = DosQueryAppType(fname, &apptype);
    600     }
     601    } //fixme protectonly BMT GKY 23 Dec 08
    601602    if ((!ret && (!apptype ||
    602603                  (apptype &
    … …  
    691692  driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    692693                    DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
    693                     DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS);
     694                    DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS |
     695                    DRIVE_WRITEVERIFYOFF);
    694696  if (removable != -1) {
    695697    struct
    … …  
    751753VOID FillInDriveFlags(VOID * dummy)
    752754{
    753   ULONG ulDriveNum, ulDriveMap;
     755  ULONG ulDriveNum, ulDriveMap, size;
    754756  register INT x;
    755757
    … …  
    757759    driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    758760                      DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS |
    759                       DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS);
     761                      DRIVE_INCLUDEFILES | DRIVE_SLOW | DRIVE_NOSTATS |
     762                      DRIVE_WRITEVERIFYOFF);
    760763  memset(driveserial, -1, sizeof(driveserial));
    761764  DosError(FERR_DISABLEHARDERR);
    … …  
    764767    if (ulDriveMap & (1 << x) && !(driveflags[x] & DRIVE_IGNORE)) {
    765768      {
    766         CHAR s[80];
    767         ULONG flags = 0, size = sizeof(ULONG);
    768 
    769         sprintf(s, "%c.DriveFlags", (CHAR) (x + 'A'));
    770         if (PrfQueryProfileData(fmprof, appname, s, &flags, &size) &&
    771             size == sizeof(ULONG))
    772           driveflags[x] |= flags;
     769        ULONG flags = 0, size = sizeof(ULONG);
     770        CHAR FlagKey[80];
     771
     772          sprintf(FlagKey, "%c.DriveFlags", (CHAR) (x + 'A'));
     773          if (PrfQueryProfileData(fmprof, appname, FlagKey, &flags, &size) &&
     774              size == sizeof(ULONG))
     775            driveflags[x] |= flags;
    773776      }
    774777
    … …  
    795798    if (startdrive)
    796799      driveflags[startdrive - 1] |= DRIVE_BOOT;
     800  }
     801  {
     802    INT x;
     803    CHAR Key[80];
     804
     805    for (x = 2; x < 26; x++) {
     806      sprintf(Key, "%c.VerifyOffChecked", (CHAR) (x + 'A'));
     807      size = sizeof(BOOL);
     808      PrfQueryProfileData(fmprof, appname, Key, &fVerifyOffChecked[x], &size);
     809      if (!fVerifyOffChecked[x]) {
     810        if (driveflags[x] & DRIVE_REMOVABLE)
     811          driveflags[x] |= DRIVE_WRITEVERIFYOFF;
     812        if (!(driveflags[x] & DRIVE_IGNORE | DRIVE_INVALID)) {
     813          fVerifyOffChecked[x] = TRUE;
     814          PrfWriteProfileData(fmprof, appname, Key, &fVerifyOffChecked[x], sizeof(BOOL));
     815        }
     816      }
     817    }
    797818  }
    798819}

  • trunk/dll/valid.h

    r1214 r1354  
    5151extern CHAR *NDFS32;
    5252extern CHAR *RAMFS;
     53extern BOOL fVerifyOffChecked[26];
    5354
    5455#endif  // VALID_H

  • trunk/dll/worker.c

    r1351 r1354  
    679679                    INT type;
    680680                    FILESTATUS4L fs4;
    681                     BOOL isnewer, existed;
     681                    BOOL isnewer, existed, fResetVerify = FALSE;
    682682
    683683                    type = (wk->li->type == IDM_RENAME) ? MOVE :
    … …  
    805805                            (usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
    806806                            NullStr);
    807                     AddNote(message);
     807                    AddNote(message);
     808                    if (fVerify && (driveflags[toupper(*wk->li->targetpath) - 'A'] & DRIVE_WRITEVERIFYOFF) |
     809                        (driveflags[toupper(*wk->li->list[x]) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
     810                      DosSetVerify(FALSE);
     811                      fResetVerify = TRUE;
     812                    }
    808813                    if (plen) {
    809814                      /* make directory/ies, if required */
    … …  
    822827                    if (fRealIdle)
    823828                      priority_idle();
    824                     rc = docopyf(type, wk->li->list[x], "%s", newname);
     829                    rc = docopyf(type, wk->li->list[x], "%s", newname);
     830                    if (fResetVerify) {
     831                      DosSetVerify(fVerify);
     832                      fResetVerify = FALSE;
     833                    }
    825834                    priority_normal();
    826835                    if (rc) {
    … …  
    907916                                wk->li->list[x],
    908917                                GetPString(IDS_TOTEXT), newname);
    909                       if (//fSyncUpdates ||
     918                      if ((driveflags[*wk->li->targetpath - 'A'] & DRIVE_RSCANNED) &&
    910919                          AddToList(wk->li->list[x],
    911920                                    &files, &numfiles, &numalloc))
    … …  
    914923                                  UM_UPDATERECORD,
    915924                                  MPFROMP(wk->li->list[x]), MPVOID);
    916                       if (//fSyncUpdates ||
     925                      if ((driveflags[*wk->li->targetpath - 'A'] & DRIVE_RSCANNED) &&
    917926                          AddToList(newname, &files, &numfiles, &numalloc))
    918927                        Broadcast(hab2,
    … …  
    10191028        Abort:
    10201029
    1021           if (files) {
    1022             Broadcast(hab2,
    1023                       wk->hwndCnr,
    1024                       UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
     1030          if (files) {
     1031            if (driveflags[*wk->li->targetpath - 'A'] & DRIVE_RSCANNED)
     1032              Broadcast(hab2,
     1033                        wk->hwndCnr,
     1034                        UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
    10251035           // DbgMsg(pszSrcFile, __LINE__, "UM_UPDATERECORD %s", *files);
    10261036            FreeList(files);
    … …  
    16111621                if (!wk->li->list || !wk->li->list[0])
    16121622                  break;
    1613               }
     1623              }
     1624              if (fVerify && driveflags[toupper(*wk->li->list[0]) - 'A'] & DRIVE_WRITEVERIFYOFF)
     1625                DosSetVerify(FALSE);
    16141626              DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    16151627              for (x = 0; wk->li->list[x]; x++) {
    … …  
    16981710                                __LINE__,
    16991711                                GetPString(IDS_DELETEFAILED2TEXT),
    1700                                 wk->li->list[x]) == MBID_CANCEL)
    1701                     break;
     1712                                wk->li->list[x]) == MBID_CANCEL) {
     1713                    DosSetVerify(fVerify);
     1714                    break;
     1715                  }
    17021716                }
    17031717                else {
    … …  
    17171731                }
    17181732              } // for
    1719             }
     1733            }
     1734            if (fVerify)
     1735              DosSetVerify(fVerify);
    17201736            break;
    17211737          } // switch

  • trunk/dll/wrappers.c

    r1215 r1354  
    2121#include <stdlib.h>
    2222#include <string.h>
     23#include <ctype.h>
    2324
    2425#define INCL_WIN
    … …  
    4041
    4142#include "fortify.h"                    // GetPString
     43#include "info.h"                       // driveflags
     44#include "notebook.h"                   // fVerify
    4245
    4346// Data definitions
    … …  
    226229    APIRET rc;
    227230    BOOL crosses = ((ULONG)pInfoBuf ^
    228                    ((ULONG)pInfoBuf + cbInfoBuf - 1)) &
    229                    ~0xffff;
    230 
     231                    ((ULONG)pInfoBuf + cbInfoBuf - 1)) & ~0xffff;
     232    BOOL fResetVerify = FALSE;
     233
     234    if (fVerify && driveflags[toupper(*pszPathName) - 'A'] & DRIVE_WRITEVERIFYOFF) {
     235      DosSetVerify(FALSE);
     236      fResetVerify = TRUE;
     237    }
    231238    switch (ulInfoLevel) {
    232239      case FIL_STANDARD:
    … …  
    281288        rc = ERROR_INVALID_PARAMETER;
    282289    } // switch
    283 
     290    if (fResetVerify) {
     291      DosSetVerify(fVerify);
     292      fResetVerify = FALSE;
     293    }
    284294    return rc;
    285295}
Note: See TracChangeset for help on using the changeset viewer.