Changeset 748


Ignore:
Timestamp:
Aug 2, 2007, 5:09:27 AM (13 years ago)
Author:
Steven Levine
Message:

Rework comp.c to to sync with CNRITEM mods
Rework comp.c to remove vast amount of duplicate code
Clean up select.c while auditing for CNRITEM sync
Sync fm3dll.h with comp.c mods

Location:
trunk/dll
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/dll/comp.c

    r746 r748  
    2525  22 Mar 07 GKY Use QWL_USER
    2626  29 Jul 07 SHL Use Win_Error to report container errors
     27  01 Aug 07 SHL Rework to sync with CNRITEM mods
     28  01 Aug 07 SHL Rework to remove vast amount of duplicate code
    2729
    2830***********************************************************************/
     
    353355  HMQ hmq;
    354356  HWND hwndCnrS, hwndCnrD;
    355   PCNRITEM pci, pciO, pcin, pciOn;
     357  PCNRITEM pci, pciD, pciNextS, pciNextD;
    356358  CHAR newname[CCHMAXPATH], dirname[CCHMAXPATH], *p;
    357359  APIRET rc;
    358360
    359   if (!cmp)
     361  if (!cmp) {
     362    Runtime_Error(pszSrcFile, __LINE__, "no data");
    360363    return;
     364  }
    361365
    362366  DosError(FERR_DISABLEHARDERR);
     
    407411      pci = WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPVOID,
    408412                       MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    409       pciO = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPVOID,
     413      pciD = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPVOID,
    410414                        MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    411       while (pci && (INT) pci != -1 && pciO && (INT) pciO != -1) {
    412 
    413         pcin = WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPFROMP(pci),
     415
     416      while (pci && (INT)pci != -1 && pciD && (INT)pciD != -1) {
     417
     418        pciNextS = WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPFROMP(pci),
    414419                          MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    415         pciOn = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPFROMP(pciO),
     420        pciNextD = WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPFROMP(pciD),
    416421                           MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    417         if (*pci->pszFileName && (pci->rc.flRecordAttr & CRA_SELECTED)) {
     422
     423        if (*pci->pszFileName && pci->rc.flRecordAttr & CRA_SELECTED) {
     424
     425          // Source name not blank
    418426          switch (cmp->action) {
    419427          case IDM_DELETE:
     
    421429              WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    422430                         MPFROM2SHORT(FALSE, CRA_SELECTED));
    423               if (!*pciO->pszFileName) {
     431
     432              if (!*pciD->pszFileName) {
     433                // Other side is blank
    424434                WinSendMsg(hwndCnrS, CM_REMOVERECORD, MPFROMP(&pci),
    425435                           MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
    426                 if (pciO->rc.flRecordAttr & CRA_SELECTED)
    427                   WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciO),
     436                if (pciD->rc.flRecordAttr & CRA_SELECTED)
     437                  WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
    428438                             MPFROM2SHORT(FALSE, CRA_SELECTED));
    429                 WinSendMsg(hwndCnrD, CM_REMOVERECORD, MPFROMP(&pciO),
     439                WinSendMsg(hwndCnrD, CM_REMOVERECORD, MPFROMP(&pciD),
    430440                           MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
    431441              }
    432442              else {
    433                 pci->pszFileName = xstrdup(NullStr, pszSrcFile, __LINE__);
    434                 //pci->pszFileName = pci->szFileName;
     443                // Other side is not blank
     444                FreeCnrItemData(pci);
    435445                pci->flags = 0;
    436446                WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
     
    441451              else
    442452                cmp->cmp->totalright--;
    443               DosSleep(0L);
     453              DosSleep(1);
    444454            }
    445455            break;
     
    454464                      cmp->rightdir[strlen(cmp->rightdir) - 1] ==
    455465                      '\\' ? NullStr : "\\", pci->pszFileName);
    456             /* make directory if required */
     466            // Make directory if required
    457467            strcpy(dirname, newname);
    458468            p = strrchr(dirname, '\\');
     
    468478              WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    469479                         MPFROM2SHORT(FALSE, CRA_SELECTED));
    470               if (pciO->rc.flRecordAttr & CRA_SELECTED)
    471                 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciO),
     480              if (pciD->rc.flRecordAttr & CRA_SELECTED)
     481                WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
    472482                           MPFROM2SHORT(FALSE, CRA_SELECTED));
    473               pciO->pszFileName = xstrdup(newname, pszSrcFile, __LINE__);
     483              FreeCnrItemData(pciD);
     484              pciD->pszFileName = xstrdup(newname, pszSrcFile, __LINE__);
    474485              if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
    475                 pciO->pszDisplayName = pciO->pszFileName + strlen(cmp->leftdir);
     486                pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
    476487                if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
    477                   pciO->pszFileName++;
     488                  pciD->pszFileName++;
    478489              }
    479490              else {
    480                 pciO->pszDisplayName = pciO->pszFileName + strlen(cmp->rightdir);
     491                pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
    481492                if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
    482                   pciO->pszFileName++;
     493                  pciD->pszFileName++;
    483494              }
    484               strcpy(pciO->szDispAttr, pci->szDispAttr);
    485               pciO->attrFile = pci->attrFile;
    486               pciO->flags = 0;
    487               pciO->date = pci->date;
    488               pciO->time = pci->time;
    489               pciO->ladate = pci->ladate;
    490               pciO->latime = pci->latime;
    491               pciO->crdate = pci->crdate;
    492               pciO->crtime = pci->crtime;
    493               pciO->cbFile = pci->cbFile;
    494               pciO->easize = pci->easize;
    495               pciO->pszSubject = xstrdup(NullStr, pszSrcFile, __LINE__);
    496               pci->pszFileName = xstrdup(NullStr, pszSrcFile, __LINE__);
    497               //pci->pszFileName = pci->szFileName;
     495              strcpy(pciD->szDispAttr, pci->szDispAttr);
     496              pciD->attrFile = pci->attrFile;
     497              pciD->flags = 0;
     498              pciD->date = pci->date;
     499              pciD->time = pci->time;
     500              pciD->ladate = pci->ladate;
     501              pciD->latime = pci->latime;
     502              pciD->crdate = pci->crdate;
     503              pciD->crtime = pci->crtime;
     504              pciD->cbFile = pci->cbFile;
     505              pciD->easize = pci->easize;
     506              pciD->pszSubject = NullStr;
     507              pci->pszFileName = NullStr;
    498508              pci->flags = 0;
    499509              WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
    500510                         MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    501               WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciO),
     511              WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
    502512                         MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    503513            }
     
    510520                             GetPString(IDS_COMPMOVEFAILEDTEXT),
    511521                             pci->pszFileName, newname);
    512               if (rc == MBID_CANCEL)    /* cause loop to break */
    513                 pcin = NULL;
     522              if (rc == MBID_CANCEL)    // Cause loop to break
     523                pciNextS = NULL;
    514524            }
    515525            break;
     
    524534                      cmp->rightdir[strlen(cmp->rightdir) - 1] ==
    525535                      '\\' ? NullStr : "\\", pci->pszFileName);
    526             /* make directory if required */
     536            // Make directory if required
    527537            strcpy(dirname, newname);
    528538            p = strrchr(dirname, '\\');
     
    544554                             pci->pszFileName, newname);
    545555              if (rc == MBID_CANCEL)
    546                 pcin = NULL;            /* cause loop to break */
     556                pciNextS = NULL;                // Cause loop to break
    547557            }
    548558            else {
    549559              WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    550560                         MPFROM2SHORT(FALSE, CRA_SELECTED));
    551               if (pciO->rc.flRecordAttr & CRA_SELECTED)
    552                 WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciO),
     561              if (pciD->rc.flRecordAttr & CRA_SELECTED)
     562                WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciD),
    553563                           MPFROM2SHORT(FALSE, CRA_SELECTED));
    554               pciO->pszFileName = xstrdup(newname, pszSrcFile, __LINE__);
     564              FreeCnrItemData(pciD);
     565              pciD->pszFileName = xstrdup(newname, pszSrcFile, __LINE__);
    555566              if (hwndCnrS == WinWindowFromID(cmp->hwnd, COMP_RIGHTDIR)) {
    556                 pciO->pszDisplayName = pciO->pszFileName + strlen(cmp->leftdir);
     567                pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->leftdir);
    557568                if (cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
    558                   pciO->pszFileName++;
     569                  pciD->pszFileName++;
    559570              }
    560571              else {
    561                 pciO->pszDisplayName = pciO->pszFileName + strlen(cmp->rightdir);
     572                pciD->pszDisplayName = pciD->pszFileName + strlen(cmp->rightdir);
    562573                if (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
    563                   pciO->pszFileName++;
     574                  pciD->pszFileName++;
    564575              }
    565               strcpy(pciO->szDispAttr, pci->szDispAttr);
    566               pciO->attrFile = pci->attrFile;
    567               pciO->flags = CNRITEM_EXISTS;
    568               pciO->date = pci->date;
    569               pciO->time = pci->time;
    570               pciO->ladate = pci->ladate;
    571               pciO->latime = pci->latime;
    572               pciO->crdate = pci->crdate;
    573               pciO->crtime = pci->crtime;
    574               pciO->cbFile = pci->cbFile;
    575               pciO->easize = pci->easize;
    576               pci->pszSubject = xstrdup(NullStr, pszSrcFile, __LINE__);
     576              strcpy(pciD->szDispAttr, pci->szDispAttr);
     577              pciD->attrFile = pci->attrFile;
     578              pciD->flags = CNRITEM_EXISTS;
     579              pciD->date = pci->date;
     580              pciD->time = pci->time;
     581              pciD->ladate = pci->ladate;
     582              pciD->latime = pci->latime;
     583              pciD->crdate = pci->crdate;
     584              pciD->crtime = pci->crtime;
     585              pciD->cbFile = pci->cbFile;
     586              pciD->easize = pci->easize;
     587              pci->pszSubject = NullStr;
     588              pci->pszLongname = NullStr;
    577589              pci->flags = CNRITEM_EXISTS;
    578590              WinSendMsg(hwndCnrS, CM_INVALIDATERECORD, MPFROMP(&pci),
    579591                         MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    580               WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciO),
     592              WinSendMsg(hwndCnrD, CM_INVALIDATERECORD, MPFROMP(&pciD),
    581593                         MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED));
    582594            }
     
    585597          default:
    586598            break;
    587           }                             // switch
    588         }
    589         pci = pcin;
    590         pciO = pciOn;
    591       }                                 // while
     599          } // switch
     600
     601        } // if have name
     602
     603        pci = pciNextS;
     604        pciD = pciNextD;
     605
     606      } // while
    592607    Abort:
    593608      WinDestroyMsgQueue(hmq);
     
    648663}
    649664
    650 static VOID FillDirList(CHAR * str, INT skiplen, BOOL recurse,
    651                         FILELIST *** list, INT * numfiles, INT * numalloc)
     665/**
     666 * Build FILELIST given pathname
     667 */
     668
     669static VOID FillDirList(CHAR *str, INT skiplen, BOOL recurse,
     670                        FILELIST ***list, INT *numfiles, INT *numalloc)
    652671{
    653672
    654   register BYTE *fb;
    655   register CHAR *enddir;
    656   register ULONG x;
     673  BYTE *fb;
     674  CHAR *enddir;
     675  ULONG x;
    657676  CHAR *maskstr;
    658677  FILEFINDBUF4 *ffb4, *pffb;
     
    661680  APIRET rc;
    662681
    663   if (!str || !*str)
     682  if (!str || !*str) {
     683    Runtime_Error(pszSrcFile, __LINE__, "no data");
    664684    return;
     685  }
     686
    665687  if (!recurse)
    666688    ulM = 128;
     
    731753  Abort:
    732754    DosFindClose(hDir);
    733     DosSleep(0L);
     755    DosSleep(1);
    734756  }
    735757  free(maskstr);
     
    755777  HMQ hmq;
    756778  BOOL notified = FALSE;
    757   static CHAR attrstring[] = "RHS\0DA";
     779  const PSZ attrstring = "RHS\0DA";
    758780  HWND hwndLeft, hwndRight;
    759 
    760   if (!cmp)
     781  CHAR szBuf[CCHMAXPATH];
     782  CNRINFO cnri;
     783
     784  if (!cmp) {
     785    Runtime_Error(pszSrcFile, __LINE__, "no data");
    761786    _endthread();
     787  }
    762788
    763789  DosError(FERR_DISABLEHARDERR);
     
    776802      INT r;
    777803      INT y;
     804      UINT i;
    778805      ULONG cntr;
    779806      FILELIST **filesl = NULL;
     
    783810      INT numallocl = 0;
    784811      INT numallocr = 0;
    785       INT lenl;                 // Directory prefix length
     812      INT lenl;                         // Directory prefix length
    786813      INT lenr;
    787       UINT recsNeeded;          // fixme to check ovf
     814      UINT recsNeeded;
    788815      PCNRITEM pcilFirst;
    789816      PCNRITEM pcirFirst;
     
    805832        lenr++;
    806833      priority_normal();
    807       /* clear containers */
     834      // Clear containers
    808835      WinSendMsg(hwndRight, CM_REMOVERECORD,
    809836                 MPVOID, MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE));
     
    812839      cmp->cmp->totalleft = cmp->cmp->totalright = 0;
    813840
    814       /* build list of all files in left directory */
     841      // Build list of all files in left directory
    815842      if (fForceLower)
    816843        strlwr(cmp->leftdir);
     
    822849      if (filesl)
    823850        qsort(filesl, numfilesl, sizeof(CHAR *), CompNames);
    824       /* build list of all files in right directory */
     851
     852      // Build list of all files in right directory
    825853      if (!*cmp->rightlist) {
    826854        if (fForceLower)
     
    832860      }
    833861      else {
    834         /* use snapshot file */
     862        // Use snapshot file
    835863        FILE *fp;
    836864        FILEFINDBUF4 fb4;
     
    844872        else {
    845873          while (!feof(fp)) {
    846             /* first get name of directory */
     874            // First get name of directory
    847875            if (!xfgets_bstripcr(str, sizeof(str), fp, pszSrcFile, __LINE__))
    848876              break;                    // EOF
    849877            p = str;
    850878            if (*p == '\"') {
    851               /* Quoted */
     879              // Quoted
    852880              p++;
    853881              if (*p && *p != '\"') {
     
    869897              }
    870898            }
    871           }                             // while !EOF
    872           {
    873             CNRINFO cnri;
    874 
    875             memset(&cnri, 0, sizeof(cnri));
    876             cnri.cb = sizeof(cnri);
    877             cnri.pszCnrTitle = cmp->rightdir;
    878             WinSendMsg(hwndRight, CM_SETCNRINFO,
    879                        MPFROMP(&cnri), MPFROMLONG(CMA_CNRTITLE));
    880           }
     899          } // while !EOF
     900
     901          memset(&cnri, 0, sizeof(cnri));
     902          cnri.cb = sizeof(cnri);
     903          cnri.pszCnrTitle = cmp->rightdir;
     904          if (!WinSendMsg(hwndRight, CM_SETCNRINFO,
     905                     MPFROMP(&cnri), MPFROMLONG(CMA_CNRTITLE))) {
     906            Win_Error(hwndRight, cmp->hwnd, pszSrcFile, __LINE__, "CM_SETCNRINFO");
     907          }
     908
    881909          if (*cmp->rightdir) {
    882910            lenr = strlen(cmp->rightdir) +
     
    957985                }
    958986              }
    959             }                           // while
    960           }                             // if have rightdir
     987            } // while
     988          } // if have rightdir
    961989          fclose(fp);
    962990        }
    963       }                                 // if snapshot file
     991      } // if snapshot file
    964992
    965993      if (filesr)
    966994        qsort(filesr, numfilesr, sizeof(CHAR *), CompNames);
    967995
    968       /* we now have two lists of files, both sorted. */
    969       /* first, count total number of container entries required */
     996      // We now have two lists of files, both sorted.
     997      // Count total number of container entries required on each side
    970998      l = r = 0;
    971999      recsNeeded = 0;
    9721000      while ((filesl && filesl[l]) || (filesr && filesr[r])) {
    973         if ((filesl && filesl[l]) && (filesr && filesr[r])) {
    974           x = stricmp(filesl[l]->fname, filesr[r]->fname);
    975           if (!x) {
    976             l++;                        // In both
    977             r++;
    978           }
    979           else if (x < 0)
    980             l++;                        // In left only
     1001
     1002        if (filesl && filesl[l]) {
     1003          if (filesr && filesr[r])
     1004            x = stricmp(filesl[l]->fname, filesr[r]->fname);
    9811005          else
    982             r++;                        // In right only
    983         }
    984         else if (filesl && filesl[l])
    985           l++;                          // In left only
    986         else                            /* filesr && filesr[r] */
    987           r++;                          // In right only
    988         recsNeeded++;                   /* keep count of how many entries req'd */
    989       }
     1006            x = -1;                     // Left side list longer
     1007        }
     1008        else
     1009          x = +1;                       // Right side list longer
     1010
     1011        if (x <= 0)
     1012          l++;                          // On left side
     1013        if (x >= 0)
     1014          r++;                          // On right side
     1015
     1016        recsNeeded++;                   // Keep count of how many entries req'd
     1017
     1018      } // while
     1019
    9901020      WinSendMsg(cmp->hwnd, UM_CONTAINERHWND, MPVOID, MPVOID);
    991       /* now insert records into the containers */
     1021
     1022      // Now insert records into the containers
    9921023      cntr = 0;
    9931024      l = r = 0;
     
    10201051        }
    10211052      }
     1053
    10221054      if (recsNeeded) {
     1055
    10231056        pcil = pcilFirst;
    10241057        pcir = pcirFirst;
    10251058        while ((filesl && filesl[l]) || (filesr && filesr[r])) {
    10261059          pcir->hwndCnr = hwndRight;
    1027           //pcir->pszFileName = pcir->szFileName;
    1028           // 23 Jul 07 SHL fixme to set pszIcon after pszFileName allocated
    1029           // 23 Jul 07 SHL fixme to set pszLongName after pszFileName allocated
    1030           pcir->pszFileName = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);//29 Jul 07 GKY Temp fix to crash
    1031           pcir->rc.pszIcon = pcir->pszFileName;
    1032           pcir->rc.hptrIcon = (HPOINTER) 0;
    1033           pcir->pszDisplayName = NULL;          // Not used here
    1034           pcir->pszSubject = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
    1035           //pcir->pszLongname = pcir->pszFileName;
     1060          pcir->rc.hptrIcon = (HPOINTER) 0;
    10361061          pcir->pszDispAttr = pcir->szDispAttr;
     1062
    10371063          pcil->hwndCnr = hwndLeft;
    1038           //pcil->pszFileName = pcil->szFileName;
    1039           pcil->pszFileName = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);//29 Jul 07 GKY Temp fix to crash
    1040           pcil->rc.pszIcon = pcil->pszFileName;
    10411064          pcil->rc.hptrIcon = (HPOINTER) 0;
    10421065          pcil->pszDispAttr = pcil->szDispAttr;
    1043           pcil->pszDisplayName = NULL;  // Not used here
    1044           pcil->pszSubject = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__) ;
    1045           //pcil->pszLongname = pcil->pszFileName;
    1046           if ((filesl && filesl[l]) && (filesr && filesr[r])) {
     1066
     1067          if (filesl && filesl[l]) {
     1068            if (filesr && filesr[r])
     1069              x = stricmp(filesl[l]->fname, filesr[r]->fname);
     1070            else
     1071              x = -1;                   // Left side list longer
     1072          }
     1073          else
     1074            x = +1;                     // Right side list longer
     1075
     1076          if (x <= 0) {
     1077            // File appears on left side
     1078            sprintf(szBuf, "%s%s%s", cmp->leftdir,
     1079                    (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
     1080                    NullStr : "\\", filesl[l]->fname);
     1081            pcil->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);
     1082            pcil->pszDisplayName = pcil->pszFileName + lenl;
     1083            pcil->attrFile = filesl[l]->attrFile;
     1084            y = 0;
     1085            for (i = 0; i < 6; i++) {
     1086              if (attrstring[i]) {
     1087                pcil->szDispAttr[y++] = (CHAR)(pcil->attrFile & (1 << i) ?
     1088                                           attrstring[i] : '-');
     1089              }
     1090            }
     1091            pcil->szDispAttr[5] = 0;
     1092            pcil->cbFile = filesl[l]->cbFile;
     1093            pcil->easize = filesl[l]->easize;
     1094            pcil->date.day = filesl[l]->date.day;
     1095            pcil->date.month = filesl[l]->date.month;
     1096            pcil->date.year = filesl[l]->date.year + 1980;
     1097            pcil->time.seconds = filesl[l]->time.twosecs * 2;
     1098            pcil->time.minutes = filesl[l]->time.minutes;
     1099            pcil->time.hours = filesl[l]->time.hours;
     1100            pcil->ladate.day = filesl[l]->ladate.day;
     1101            pcil->ladate.month = filesl[l]->ladate.month;
     1102            pcil->ladate.year = filesl[l]->ladate.year + 1980;
     1103            pcil->latime.seconds = filesl[l]->latime.twosecs * 2;
     1104            pcil->latime.minutes = filesl[l]->latime.minutes;
     1105            pcil->latime.hours = filesl[l]->latime.hours;
     1106            pcil->crdate.day = filesl[l]->crdate.day;
     1107            pcil->crdate.month = filesl[l]->crdate.month;
     1108            pcil->crdate.year = filesl[l]->crdate.year + 1980;
     1109            pcil->crtime.seconds = filesl[l]->crtime.twosecs * 2;
     1110            pcil->crtime.minutes = filesl[l]->crtime.minutes;
     1111            pcil->crtime.hours = filesl[l]->crtime.hours;
     1112            if (*cmp->dcd.mask.szMask) {
     1113              if (!Filter((PMINIRECORDCORE) pcil, (PVOID)&cmp->dcd.mask)) {
     1114                pcil->rc.flRecordAttr |= CRA_FILTERED;
     1115                pcir->rc.flRecordAttr |= CRA_FILTERED;
     1116              }
     1117            }
     1118            pcil->flags |= CNRITEM_EXISTS;
     1119          } // if on left
     1120
     1121          if (x >= 0) {
     1122            // File appears on right side
     1123            sprintf(szBuf, "%s%s%s", cmp->rightdir,
     1124                    (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
     1125                    NullStr : "\\", filesr[r]->fname);
     1126            pcir->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);   // 31 Jul 07 SHL
     1127            pcir->pszDisplayName = pcir->pszFileName + lenr;
     1128            pcir->attrFile = filesr[r]->attrFile;
     1129            // pcir->rc.hptrIcon = hptrFile;
     1130            y = 0;
     1131            for (i = 0; i < 6; i++) {
     1132              if (attrstring[i]) {
     1133                pcir->szDispAttr[y++] = (CHAR)(pcir->attrFile & (1 << i) ?
     1134                                          attrstring[i] : '-');
     1135              }
     1136            }
     1137            pcir->szDispAttr[5] = 0;
     1138            pcir->cbFile = filesr[r]->cbFile;
     1139            pcir->easize = filesr[r]->easize;
     1140            pcir->date.day = filesr[r]->date.day;
     1141            pcir->date.month = filesr[r]->date.month;
     1142            pcir->date.year = filesr[r]->date.year + 1980;
     1143            pcir->time.seconds = filesr[r]->time.twosecs * 2;
     1144            pcir->time.minutes = filesr[r]->time.minutes;
     1145            pcir->time.hours = filesr[r]->time.hours;
     1146            pcir->ladate.day = filesr[r]->ladate.day;
     1147            pcir->ladate.month = filesr[r]->ladate.month;
     1148            pcir->ladate.year = filesr[r]->ladate.year + 1980;
     1149            pcir->latime.seconds = filesr[r]->latime.twosecs * 2;
     1150            pcir->latime.minutes = filesr[r]->latime.minutes;
     1151            pcir->latime.hours = filesr[r]->latime.hours;
     1152            pcir->crdate.day = filesr[r]->crdate.day;
     1153            pcir->crdate.month = filesr[r]->crdate.month;
     1154            pcir->crdate.year = filesr[r]->crdate.year + 1980;
     1155            pcir->crtime.seconds = filesr[r]->crtime.twosecs * 2;
     1156            pcir->crtime.minutes = filesr[r]->crtime.minutes;
     1157            pcir->crtime.hours = filesr[r]->crtime.hours;
     1158            if (~pcil->rc.flRecordAttr & CRA_FILTERED &&
     1159                *cmp->dcd.mask.szMask) {
     1160              if (!Filter((PMINIRECORDCORE)pcir, (PVOID)&cmp->dcd.mask)) {
     1161                pcil->rc.flRecordAttr |= CRA_FILTERED;
     1162                pcir->rc.flRecordAttr |= CRA_FILTERED;
     1163              }
     1164            }
     1165            pcir->flags |= CNRITEM_EXISTS;
     1166          } // if on right
     1167
     1168          if (x == 0) {
     1169            // File appears on both sides
     1170            pch = szBuf;
     1171            // Subject field holds status messages
     1172            *pch = 0;
     1173            if (pcil->cbFile + pcil->easize > pcir->cbFile + pcir->easize) {
     1174              pcil->flags |= CNRITEM_LARGER;
     1175              pcir->flags |= CNRITEM_SMALLER;
     1176              strcpy(pch, GetPString(IDS_LARGERTEXT));
     1177              pch += 6;
     1178            }
     1179            else if (pcil->cbFile + pcil->easize <
     1180                     pcir->cbFile + pcir->easize) {
     1181              pcil->flags |= CNRITEM_SMALLER;
     1182              pcir->flags |= CNRITEM_LARGER;
     1183              strcpy(pch, GetPString(IDS_SMALLERTEXT));
     1184              pch += 7;
     1185            }
     1186            if ((pcil->date.year > pcir->date.year) ? TRUE :
     1187                (pcil->date.year < pcir->date.year) ? FALSE :
     1188                (pcil->date.month > pcir->date.month) ? TRUE :
     1189                (pcil->date.month < pcir->date.month) ? FALSE :
     1190                (pcil->date.day > pcir->date.day) ? TRUE :
     1191                (pcil->date.day < pcir->date.day) ? FALSE :
     1192                (pcil->time.hours > pcir->time.hours) ? TRUE :
     1193                (pcil->time.hours < pcir->time.hours) ? FALSE :
     1194                (pcil->time.minutes > pcir->time.minutes) ? TRUE :
     1195                (pcil->time.minutes < pcir->time.minutes) ? FALSE :
     1196                (pcil->time.seconds > pcir->time.seconds) ? TRUE :
     1197                (pcil->time.seconds < pcir->time.seconds) ? FALSE : FALSE) {
     1198              pcil->flags |= CNRITEM_NEWER;
     1199              pcir->flags |= CNRITEM_OLDER;
     1200              if (pch != szBuf) {
     1201                strcpy(pch, ", ");
     1202                pch += 2;
     1203              }
     1204              strcpy(pch, GetPString(IDS_NEWERTEXT));
     1205              pch += 5;
     1206            }
     1207            else if ((pcil->date.year < pcir->date.year) ? TRUE :
     1208                     (pcil->date.year > pcir->date.year) ? FALSE :
     1209                     (pcil->date.month < pcir->date.month) ? TRUE :
     1210                     (pcil->date.month > pcir->date.month) ? FALSE :
     1211                     (pcil->date.day < pcir->date.day) ? TRUE :
     1212                     (pcil->date.day > pcir->date.day) ? FALSE :
     1213                     (pcil->time.hours < pcir->time.hours) ? TRUE :
     1214                     (pcil->time.hours > pcir->time.hours) ? FALSE :
     1215                     (pcil->time.minutes < pcir->time.minutes) ? TRUE :
     1216                     (pcil->time.minutes > pcir->time.minutes) ? FALSE :
     1217                     (pcil->time.seconds < pcir->time.seconds) ? TRUE :
     1218                     (pcil->time.seconds > pcir->time.seconds) ? FALSE :
     1219                     FALSE) {
     1220              pcil->flags |= CNRITEM_OLDER;
     1221              pcir->flags |= CNRITEM_NEWER;
     1222              if (pch != szBuf) {
     1223                strcpy(pch, ", ");
     1224                pch += 2;
     1225              }
     1226              strcpy(pch, GetPString(IDS_OLDERTEXT));
     1227              pch += 5;
     1228            }
     1229            *pch = 0;           // fixme to be gone?
     1230            // fixme to known why not displayed - defect?
     1231            pcil->pszSubject = *szBuf ? strdup(szBuf) : NullStr;
     1232
     1233          } // if on both sides
     1234
     1235          if (x <= 0) {
     1236            free(filesl[l]);
     1237            l++;
     1238          }
     1239
     1240          if (x >= 0) {
     1241            free(filesr[r]);
     1242            r++;
     1243          }
     1244
     1245#if 0 //============================ fixme to be gone =================
     1246
     1247          if (filesl && filesl[l] && filesr && filesr[r]) {
     1248            // Got two names
    10471249            x = stricmp(filesl[l]->fname, filesr[r]->fname);
    10481250            if (!x) {
    1049                 // Same
    1050               sprintf(pcil->pszFileName, "%s%s%s", cmp->leftdir,
     1251              // Names match - insert on both sides
     1252              sprintf(szBuf, "%s%s%s", cmp->leftdir,
    10511253                      (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
    10521254                      NullStr : "\\", filesl[l]->fname);
    10531255              // pcil->rc.hptrIcon = hptrFile;
     1256              pcil->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__); // 31 Jul 07 SHL
    10541257              pcil->pszDisplayName = pcil->pszFileName + lenl;
    10551258              pcil->attrFile = filesl[l]->attrFile;
     
    10881291                }
    10891292              }
    1090               sprintf(pcir->pszFileName, "%s%s%s", cmp->rightdir,
     1293              sprintf(szBuf, "%s%s%s", cmp->rightdir,
    10911294                      (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
    10921295                      NullStr : "\\", filesr[r]->fname);
     1296              pcir->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__); // 31 Jul 07 SHL
    10931297              pcir->pszDisplayName = pcir->pszFileName + lenr;
    10941298              pcir->attrFile = filesr[r]->attrFile;
     
    11231327              pcil->flags |= CNRITEM_EXISTS;
    11241328              pcir->flags |= CNRITEM_EXISTS;
    1125               pch = pcil->pszSubject;
     1329              pch = szBuf;
     1330              // Subject field holds status messages
     1331              // pch = pcil->pszSubject;
     1332              *pch = 0;
    11261333              if (pcil->cbFile + pcil->easize > pcir->cbFile + pcir->easize) {
    11271334                pcil->flags |= CNRITEM_LARGER;
     
    11511358                pcil->flags |= CNRITEM_NEWER;
    11521359                pcir->flags |= CNRITEM_OLDER;
    1153                 if (pch != pcil->pszSubject) {
     1360                if (pch != szBuf) {
    11541361                  strcpy(pch, ", ");
    11551362                  pch += 2;
     
    11731380                pcil->flags |= CNRITEM_OLDER;
    11741381                pcir->flags |= CNRITEM_NEWER;
    1175                 if (pch != pcil->pszSubject) {
     1382                if (pch != szBuf) {
    11761383                  strcpy(pch, ", ");
    11771384                  pch += 2;
     
    11811388              }
    11821389              *pch = 0;
     1390              pcil->pszSubject = *szBuf ? strdup(szBuf) : NullStr;
    11831391              r++;
    11841392              l++;
    11851393            }
    11861394            else if (x < 0) {
    1187               // Just on left
    1188               sprintf(pcil->pszFileName, "%s%s%s", cmp->leftdir,
    1189                       (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
    1190                       NullStr : "\\", filesl[l]->fname);
     1395              // Left side name less than right side name
     1396              // Insert name on left, leave blank filler on right
     1397              sprintf(szBuf, "%s%s%s", cmp->leftdir,
     1398                      cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\' ?
     1399                        NullStr : "\\",
     1400                      filesl[l]->fname);
     1401              pcil->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);
    11911402              pcil->pszDisplayName = pcil->pszFileName + lenl;
    11921403              pcil->attrFile = filesl[l]->attrFile;
     
    12291440            }
    12301441            else {
    1231               // Just on right
    1232               sprintf(pcir->pszFileName, "%s%s%s", cmp->rightdir,
    1233                       (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
    1234                       NullStr : "\\", filesr[r]->fname);
     1442              // Left side name larger than right side name
     1443              // Insert name on right, leave blank filler on left
     1444              sprintf(szBuf, "%s%s%s", cmp->rightdir,
     1445                      cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\' ?
     1446                        NullStr : "\\",
     1447                      filesr[r]->fname);
     1448              pcir->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);
    12351449              pcir->pszDisplayName = pcir->pszFileName + lenr;
    12361450              pcir->attrFile = filesr[r]->attrFile;
     
    12751489          }
    12761490          else if (filesl && filesl[l]) {
    1277             // Just on left
    1278             sprintf(pcil->pszFileName, "%s%s%s", cmp->leftdir,
    1279                     (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
    1280                     NullStr : "\\", filesl[l]->fname);
     1491            // Left side list longer than right side list
     1492            // Insert name on left, leave blank filler on right
     1493            sprintf(szBuf, "%s%s%s", cmp->leftdir,
     1494                    cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\' ?
     1495                      NullStr : "\\",
     1496                    filesl[l]->fname);
     1497            pcil->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);
    12811498            pcil->pszDisplayName = pcil->pszFileName + lenl;
    12821499            pcil->attrFile = filesl[l]->attrFile;
     
    13181535          }
    13191536          else {
    1320             /* filesr && filesr[r] */
    1321             // Just on right
    1322             sprintf(pcir->pszFileName, "%s%s%s", cmp->rightdir,
    1323                     (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
    1324                     NullStr : "\\", filesr[r]->fname);
     1537            // filesr && filesr[r]
     1538            // Right side list longer than left side
     1539            // Insert name on right, leave blank filler on left
     1540            sprintf(szBuf, "%s%s%s", cmp->rightdir,
     1541                    cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\' ?
     1542                      NullStr : "\\",
     1543                    filesr[r]->fname);
     1544            pcir->pszFileName = xstrdup(szBuf, pszSrcFile, __LINE__);
    13251545            pcir->pszDisplayName = pcir->pszFileName + lenr;
    13261546            pcir->attrFile = filesr[r]->attrFile;
     
    13621582            r++;
    13631583          }
     1584
     1585#endif //=========================== fixme to be gone =================
     1586
     1587          // Ensure empty buffers point somewhere
     1588          if (!pcil->pszFileName) {
     1589            pcil->pszFileName = NullStr;
     1590            pcil->pszDisplayName = pcil->pszFileName;
     1591          }
     1592
     1593          if (!pcir->pszFileName) {
     1594            pcir->pszFileName = NullStr;
     1595            pcir->pszDisplayName = pcir->pszFileName;
     1596          }
     1597
     1598          pcil->rc.pszIcon = pcil->pszFileName;         // fixme to be pszDisplayName?
     1599          pcir->rc.pszIcon = pcir->pszFileName;
     1600          pcil->pszLongname = pcil->pszFileName;
     1601          pcir->pszLongname = pcir->pszFileName;
     1602
     1603          if (!pcil->pszSubject)
     1604            pcil->pszSubject = NullStr;
     1605          if (!pcir->pszSubject)
     1606            pcil->pszSubject = NullStr;
     1607
     1608          // fixme to be time based - every 2 sec should be OK
    13641609          if (!(cntr % 500))
    1365             DosSleep(1L);
     1610            DosSleep(1);
    13661611          else if (!(cntr % 50))
    1367             DosSleep(0L);
     1612            DosSleep(1);
     1613
    13681614          cntr++;
     1615
    13691616          pcil = (PCNRITEM) pcil->rc.preccNextRecord;
    13701617          pcir = (PCNRITEM) pcir->rc.preccNextRecord;
    1371         }                               // while
     1618
     1619        } // while filling left or right
     1620
    13721621        if (filesl)
    13731622          free(filesl);                 // Free header - have already freed elements
     
    13761625          free(filesr);
    13771626        filesr = NULL;
    1378         /* insert 'em */
     1627        // Insert 'em
    13791628        WinSendMsg(cmp->hwnd, UM_CONTAINERDIR, MPVOID, MPVOID);
     1629
    13801630        memset(&ri, 0, sizeof(RECORDINSERT));
    13811631        ri.cb = sizeof(RECORDINSERT);
     
    13971647          numfilesl = 0;
    13981648        }
     1649
    13991650        memset(&ri, 0, sizeof(RECORDINSERT));
    14001651        ri.cb = sizeof(RECORDINSERT);
     
    14181669          numfilesr = 0;
    14191670        }
     1671
    14201672        cmp->cmp->totalleft = numfilesl;
    14211673        cmp->cmp->totalright = numfilesr;
    1422       }                                 // if recsNeeded
     1674
     1675      } // if recsNeeded
     1676
    14231677      Deselect(hwndLeft);
    14241678      Deselect(hwndRight);
     1679
    14251680      if (!PostMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPVOID, MPVOID))
    14261681        WinSendMsg(cmp->hwnd, UM_CONTAINER_FILLED, MPVOID, MPVOID);
    14271682      notified = TRUE;
     1683
    14281684      if (filesl)
    1429         FreeList((CHAR **) filesl);     // Must have failed to create container
     1685        FreeList((CHAR **)filesl);      // Must have failed to create container
    14301686      if (filesr)
    1431         FreeList((CHAR **) filesr);
     1687        FreeList((CHAR **)filesr);
     1688
    14321689      WinDestroyMsgQueue(hmq);
    14331690    }
     
    15801837        LoadDetailsSwitches("DirCmp", &cmp->dcd);
    15811838        cmp->dcd.detailslongname = FALSE;
    1582         cmp->dcd.detailsicon = FALSE;   /* TRUE; */
     1839        cmp->dcd.detailsicon = FALSE;   // TRUE;
    15831840      }
    15841841      memset(&cnri, 0, sizeof(CNRINFO));
     
    16221879  case WM_DRAWITEM:
    16231880    if (mp2) {
    1624 
    1625       POWNERITEM pown = (POWNERITEM) mp2;
     1881      POWNERITEM pown = (POWNERITEM)mp2;
    16261882      PCNRDRAWITEMINFO pcown;
    16271883      PCNRITEM pci;
    16281884
    1629       pcown = (PCNRDRAWITEMINFO) pown->hItem;
     1885      pcown = (PCNRDRAWITEMINFO)pown->hItem;
    16301886      if (pcown) {
    16311887        pci = (PCNRITEM) pcown->pRecord;
    1632         if (pci && (INT) pci != -1 && !*pci->pszFileName)
     1888        // 01 Aug 07 SHL if field null or blank, we draw
     1889        // fixme to know why - probably to optimize and bypass draw?
     1890        if (pci && (INT)pci != -1 && !*pci->pszFileName)
    16331891          return MRFROMLONG(TRUE);
    16341892      }
     
    17702028          SetShiftState();
    17712029          if (pci) {
    1772             if ((pci->rc.flRecordAttr & CRA_INUSE) || !*pci->pszFileName)
     2030            if (pci->rc.flRecordAttr & CRA_INUSE || !pci || !*pci->pszFileName)
    17732031              break;
    17742032            WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     
    18032061          cmp->hwndCalling = WinWindowFromID(hwnd, SHORT1FROMMP(mp1));
    18042062          if (pci) {
    1805             if (!*pci->pszFileName || *cmp->rightlist)
     2063            if (!pci || !*pci->pszFileName || *cmp->rightlist)
    18062064              break;
    18072065            id = COMP_MENU;
     
    18512109            pci = (PCNRITEM) pre->pRecord;
    18522110            if (pci) {
    1853               if (!*pci->pszFileName) {
     2111              if (!pci || !*pci->pszFileName) {
    18542112                if (pci->rc.flRecordAttr & CRA_SELECTED)
    18552113                  WinSendDlgItemMsg(hwnd, SHORT1FROMMP(mp1),
     
    20492307          pcir = WinSendMsg(hwndr, CM_QUERYRECORD, MPFROMP(pcir),
    20502308                            MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    2051         }                               // while
     2309        } // while
    20522310        if (needRefresh) {
    20532311          WinSendMsg(hwndl, CM_INVALIDATERECORD,
     
    20852343                                    MPFROMLONG(CMA_FIRST),
    20862344                                    MPFROMSHORT(CRA_CURSORED));
    2087         if (pci) {
     2345        // 01 Aug 07 SHL
     2346        if (pci && *pci->pszFileName) {
    20882347          if (cmp->hwndCalling == hwndLeft)
    20892348            strcpy(ofile, cmp->rightdir);
     
    20942353          strcat(ofile, pci->pszFileName);
    20952354          if (*compare) {
    2096 
    20972355            CHAR *fakelist[3];
    2098 
    20992356            fakelist[0] = pci->pszFileName;
    21002357            fakelist[1] = ofile;
     
    21042361          }
    21052362          else {
    2106 
    21072363            FCOMPARE fc;
    2108 
    21092364            memset(&fc, 0, sizeof(fc));
    21102365            fc.size = sizeof(fc);
     
    21332388          temp = fSelectedAlways;
    21342389          fSelectedAlways = TRUE;
    2135           pci = (PCNRITEM) CurrentRecord(hwnd);
     2390          pci = (PCNRITEM)CurrentRecord(hwnd);
    21362391          fSelectedAlways = temp;
    2137           if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
     2392          // 01 Aug 07 SHL
     2393          if (pci && ~pci->attrFile & FILE_DIRECTORY) {
    21382394            p = strrchr(pci->pszFileName, '\\');
    21392395            if (p) {
     
    23712627    case IDM_SELECTONE:
    23722628    case IDM_SELECTSAMECONTENT:
    2373     case IDM_SELECTIDENTICAL:           // name, size and time
    2374     case IDM_SELECTSAME:                // name and size
     2629    case IDM_SELECTIDENTICAL:           // Name, size and time
     2630    case IDM_SELECTSAME:                // Name and size
    23752631    case IDM_INVERT:
    23762632      cmp = INSTDATA(hwnd);
     
    24812737                     !strcmp(realappname, FM3Str))
    24822738              TileChildren(cmp->hwndParent, TRUE);
    2483             DosSleep(64L);
     2739            DosSleep(64);
    24842740            PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(COMP_COLLECT, 0), MPVOID);
    24852741            break;
  • trunk/dll/fm3dll.h

    r743 r748  
    642642                              const BOOL partial, DIRCNRDATA *pdcd);
    643643VOID FreeCnrItem(HWND hwnd, PCNRITEM pci);
     644VOID FreeCnrItemData(PCNRITEM pci);
    644645VOID RemoveCnrItems(HWND hwnd, PCNRITEM pci, USHORT usCnt, USHORT usFlags);
    645646
  • trunk/dll/select.c

    r730 r748  
    2020  12 May 07 SHL Use dcd->ulItemsToUnHilite
    2121  14 Jun 07 SHL SelectAll: make odd expression go away
     22  01 Aug 07 SHL Clean up while auditing for CNRITEM sync
    2223
    2324***********************************************************************/
     
    5455  }
    5556  pci = (PCNRITEM) CurrentRecord(hwndCnr);
    56   if (pci && (INT) pci != -1) {
     57  if (pci && (INT)pci != -1) {
    5758    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    5859      attribute = CRA_SELECTED;
     
    6061                       MPFROMSHORT(attribute));
    6162    }
    62     while (pci && (INT) pci != -1) {
     63    while (pci && (INT)pci != -1) {
    6364      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    6465                 MPFROM2SHORT(FALSE, CRA_SELECTED));
     
    7980
    8081VOID SelectList(HWND hwndCnr, BOOL partial, BOOL deselect, BOOL clearfirst,
    81                 PCNRITEM pciParent, CHAR * filename, CHAR ** list)
     82                PCNRITEM pciParent, PSZ filename, CHAR ** list)
    8283{
    8384
     
    157158}
    158159
    159 VOID SelectAll(HWND hwndCnr, BOOL files, BOOL dirs, CHAR * maskstr,
    160                CHAR * text, BOOL is_arc)
     160VOID SelectAll(HWND hwndCnr, BOOL files, BOOL dirs, PSZ maskstr,
     161               PSZ text, BOOL is_arc)
    161162{
    162163
    163164  PCNRITEM pci;
    164165  BOOL markit;
    165   register CHAR *file;
     166  PSZ file;
     167  PSZ pszToMatch;
    166168  MASK Mask;
    167   register INT x;
     169  INT x;
    168170  ULONG textlen = 0;
    169171
     
    175177  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
    176178                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    177   while (pci && (INT) pci != -1) {
     179  while (pci && (INT)pci != -1) {
     180
    178181    markit = FALSE;
    179     if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
     182
     183    if (~pci->rc.flRecordAttr & CRA_FILTERED) {
    180184      if (!is_arc) {
    181         if (files && !(pci->attrFile & FILE_DIRECTORY))
     185        if (files && ~pci->attrFile & FILE_DIRECTORY)
    182186          markit = TRUE;
    183         if (dirs && (pci->attrFile & FILE_DIRECTORY))
     187        if (dirs && pci->attrFile & FILE_DIRECTORY)
    184188          markit = TRUE;
    185189      }
     
    188192      if (maskstr && *maskstr && markit) {
    189193        markit = FALSE;
     194        // Point a filename part
    190195        file = strrchr(pci->pszFileName, '\\');
    191196        if (!file)
     
    197202        for (x = 0; Mask.pszMasks[x]; x++) {
    198203          if (*Mask.pszMasks[x]) {
     204            if ((strchr(Mask.pszMasks[x], '\\') ||
     205                strchr(Mask.pszMasks[x], ':')))
     206              pszToMatch = pci->pszFileName;
     207            else
     208              pszToMatch = file;
    199209            if (*Mask.pszMasks[x] != '/') {
    200               if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    201                             strchr(Mask.pszMasks[x], ':')) ?
    202                              pci->pszFileName :
    203                              file,
    204                            Mask.pszMasks[x],
    205                            FALSE)) {
     210              if (wildcard(pszToMatch, Mask.pszMasks[x], FALSE)) {
    206211                markit = TRUE;
    207212              }
    208213            }
    209214            else {
    210               if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    211                             strchr(Mask.pszMasks[x], ':')) ?
    212                               pci->pszFileName :
    213                               file,
    214                             Mask.pszMasks[x] + 1,
    215                            FALSE)) {
     215              if (wildcard(pszToMatch, Mask.pszMasks[x] + 1, FALSE)) {
    216216                markit = FALSE;
    217217                break;
     
    222222      }
    223223    }
    224     if (markit && text && *text && !(pci->attrFile & FILE_DIRECTORY)) {
    225 
    226       CHAR *input;
    227 
    228       markit = FALSE;
    229       input = xmalloc(65537, pszSrcFile, __LINE__);
    230       if (input) {
    231         ULONG pos;
    232         LONG len;
    233         FILE *inputFile;
    234 
    235         if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
    236           pos = ftell(inputFile);
    237           while (!feof(inputFile)) {
    238             if (pos)
    239               fseek(inputFile, pos - 256, SEEK_SET);
    240             len = fread(input, 1, 65536, inputFile);
    241             if (len >= 0) {
    242               if (findstring(text, textlen, input, len, FALSE)) {
    243                 markit = TRUE;
     224
     225    if (markit && text && *text) {
     226      if (~pci->attrFile & FILE_DIRECTORY) {
     227        PSZ input;
     228        markit = FALSE;
     229        input = xmalloc(65537, pszSrcFile, __LINE__);
     230        if (input) {
     231          ULONG pos;
     232          LONG len;
     233          FILE *inputFile;
     234
     235          if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
     236            pos = ftell(inputFile);
     237            while (!feof(inputFile)) {
     238              if (pos)
     239                fseek(inputFile, pos - 256, SEEK_SET);
     240              len = fread(input, 1, 65536, inputFile);
     241              if (len >= 0) {
     242                if (findstring(text, textlen, input, len, FALSE)) {
     243                  markit = TRUE;
     244                  break;
     245                }
     246              }
     247              else
    244248                break;
    245               }
    246249            }
    247             else
    248               break;
     250            fclose(inputFile);
    249251          }
    250           fclose(inputFile);
     252          free(input);
     253          DosSleep(1L);
    251254        }
    252         free(input);
    253         DosSleep(1L);
    254       }
    255     }
    256     else if (markit && text && *text && (pci->attrFile & FILE_DIRECTORY))
    257       markit = FALSE;
     255      }
     256      else
     257        markit = FALSE;
     258    }
     259
    258260    if (markit)
    259261      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     
    264266}
    265267
    266 VOID DeselectAll(HWND hwndCnr, BOOL files, BOOL dirs, CHAR * maskstr,
    267                  CHAR * text, BOOL is_arc)
     268VOID DeselectAll(HWND hwndCnr, BOOL files, BOOL dirs, PSZ maskstr,
     269                 PSZ text, BOOL is_arc)
    268270{
    269271  PCNRITEM pci;
    270272  BOOL unmarkit;
    271   register CHAR *file;
     273  PSZ file;
     274  PSZ pszToMatch;
    272275  MASK Mask;
    273276  register INT x;
     
    281284  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
    282285                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    283   while (pci && (INT) pci != -1) {
     286  while (pci && (INT)pci != -1) {
    284287    unmarkit = FALSE;
    285     if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
     288    if (~pci->rc.flRecordAttr & CRA_FILTERED) {
    286289      if (!is_arc) {
    287         if (files && !(pci->attrFile & FILE_DIRECTORY))
     290        if (files && ~pci->attrFile & FILE_DIRECTORY)
    288291          unmarkit = TRUE;
    289292        if (dirs && (pci->attrFile & FILE_DIRECTORY))
     
    303306        for (x = 0; Mask.pszMasks[x]; x++) {
    304307          if (*Mask.pszMasks[x]) {
     308            if (strchr(Mask.pszMasks[x], '\\') ||
     309                strchr(Mask.pszMasks[x], ':'))
     310              pszToMatch = pci->pszFileName;
     311            else
     312              pszToMatch = file;
    305313            if (*Mask.pszMasks[x] != '/') {
    306               if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    307                             strchr(Mask.pszMasks[x], ':')) ?
    308                            pci->pszFileName : file, Mask.pszMasks[x], FALSE))
     314              if (wildcard(pszToMatch, Mask.pszMasks[x], FALSE))
    309315                unmarkit = TRUE;
    310316            }
    311317            else {
    312               if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
    313                             strchr(Mask.pszMasks[x], ':')) ?
    314                            pci->pszFileName : file, Mask.pszMasks[x] + 1,
    315                            FALSE)) {
     318              if (wildcard(pszToMatch, Mask.pszMasks[x] + 1, FALSE)) {
    316319                unmarkit = FALSE;
    317320                break;
     
    322325      }
    323326    }
    324     if (unmarkit && text && *text && !(pci->attrFile & FILE_DIRECTORY)) {
    325 
    326       CHAR *input;
    327 
    328       unmarkit = FALSE;
    329       input = xmalloc(65537, pszSrcFile, __LINE__);
    330       if (input) {
    331         ULONG pos;
    332         LONG len;
    333         FILE *inputFile;
    334 
    335         if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
    336           pos = ftell(inputFile);
    337           while (!feof(inputFile)) {
    338             if (pos)
    339               fseek(inputFile, pos - 256, SEEK_SET);
    340             len = fread(input, 1, 65536, inputFile);
    341             if (len >= 0) {
    342               if (findstring(text, textlen, input, len, FALSE)) {
    343                 unmarkit = TRUE;
     327
     328    if (unmarkit && text && *text) {
     329      if (~pci->attrFile & FILE_DIRECTORY) {
     330        PSZ input;
     331        unmarkit = FALSE;
     332        input = xmalloc(65537, pszSrcFile, __LINE__);
     333        if (input) {
     334          ULONG pos;
     335          LONG len;
     336          FILE *inputFile;
     337
     338          if ((inputFile = _fsopen(pci->pszFileName, "rb", SH_DENYNO)) != NULL) {
     339            pos = ftell(inputFile);
     340            while (!feof(inputFile)) {
     341              if (pos)
     342                fseek(inputFile, pos - 256, SEEK_SET);
     343              len = fread(input, 1, 65536, inputFile);
     344              if (len >= 0) {
     345                if (findstring(text, textlen, input, len, FALSE)) {
     346                  unmarkit = TRUE;
     347                  break;
     348                }
     349              }
     350              else
    344351                break;
    345               }
    346352            }
    347             else
    348               break;
     353            fclose(inputFile);
    349354          }
    350           fclose(inputFile);
     355          free(input);
     356          DosSleep(1L);
    351357        }
    352         free(input);
    353         DosSleep(1L);
    354       }
    355     }
    356     else if (unmarkit && text && *text && (pci->attrFile & FILE_DIRECTORY))
    357       unmarkit = FALSE;
     358      }
     359      else
     360        unmarkit = FALSE;
     361    }
     362
    358363    if (unmarkit)
    359364      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pci,
     
    372377                               MPFROMLONG(CMA_FIRST),
    373378                               MPFROMSHORT(CRA_SELECTED));
    374   while (pcil && (INT) pcil != -1) {
     379  while (pcil && (INT)pcil != -1) {
    375380    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pcil),
    376381               MPFROM2SHORT(FALSE, CRA_SELECTED));
     
    394399             MPFROMLONG(sizeof(CNRINFO)));
    395400  pci = (PCNRITEM) CurrentRecord(hwndCnr);
    396   if (pci && (INT) pci != -1) {
     401  if (pci && (INT)pci != -1) {
    397402    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    398403      attribute = CRA_SELECTED;
     
    401406    }
    402407  }
    403   while (pci && (INT) pci != -1) {
     408  while (pci && (INT)pci != -1) {
    404409    pciH = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
    405410                      MPFROMSHORT(attribute));
     
    433438  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
    434439                              MPFROMLONG(CMA_FIRST), MPFROMSHORT(attribute));
    435   if (pci && (INT) pci != -1) {
     440  if (pci && (INT)pci != -1) {
    436441    if (attribute == CRA_CURSORED) {
    437442      if (pci->rc.flRecordAttr & CRA_SELECTED) {
     
    443448    }
    444449  }
    445   while (pci && (INT) pci != -1) {
     450  while (pci && (INT)pci != -1) {
    446451    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    447452               MPFROM2SHORT(!quitit,
     
    462467
    463468  pci = (PCNRITEM) CurrentRecord(hwndCnr);
    464   if (pci && (INT) pci != -1) {
     469  if (pci && (INT)pci != -1) {
    465470    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    466471      attribute = CRA_SELECTED;
     
    469474    }
    470475  }
    471   while (pci && (INT) pci != -1) {
    472     if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
     476  while (pci && (INT)pci != -1) {
     477    if (~pci->rc.flRecordAttr & CRA_FILTERED) {
    473478      didone = TRUE;
    474479      if (pulTotalFiles)
     
    531536                           MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    532537  if (pciParent) {
    533     if (expand && !(pciParent->rc.flRecordAttr & CRA_EXPANDED))
     538    if (expand && ~pciParent->rc.flRecordAttr & CRA_EXPANDED)
    534539      WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciParent), MPVOID);
    535540    else if (!expand && (pciParent->rc.flRecordAttr & CRA_EXPANDED))
     
    539544    if (pci)
    540545      DosSleep(1L);
    541     while (pci && (INT) pci != -1) {
     546    while (pci && (INT)pci != -1) {
    542547      ExpandAll(hwndCnr, expand, pci);
    543548      pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
     
    545550    }
    546551  }
    547   DosSleep(0L);
     552  DosSleep(1);
    548553}
    549554
     
    554559  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
    555560                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    556   while (pci && (INT) pci != -1) {
    557     if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    558       if (!(pci->rc.flRecordAttr & CRA_SELECTED))
     561  while (pci && (INT)pci != -1) {
     562    if (~pci->rc.flRecordAttr & CRA_FILTERED) {
     563      if (~pci->rc.flRecordAttr & CRA_SELECTED)
    559564        WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    560565                   MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    616621                               MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    617622  x = 0;
    618   while (pciD && (INT) pciD != -1 && x < numD) {
     623  while (pciD && (INT)pciD != -1 && x < numD) {
    619624    if (reset)
    620625      pciD->flags = 0;
     
    629634      DosSleep(1L);
    630635    else if (!(x % 50))
    631       DosSleep(0L);
     636      DosSleep(1);
    632637  }
    633638  if (numD != x) {
     
    646651                               MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    647652  x = 0;
    648   while (pciS && (INT) pciS != -1 && x < numS) {
     653  while (pciS && (INT)pciS != -1 && x < numS) {
    649654    if (reset)
    650655      pciS->flags = 0;
     
    659664      DosSleep(1L);
    660665    else if (!(x % 50))
    661       DosSleep(0L);
     666      DosSleep(1);
    662667  }
    663668  if (numS != x) {
     
    674679  if (reset) {
    675680    for (x = 0; x < numS; x++) {
     681
    676682      if (!*pciSa[x]->pszFileName || !*pciDa[x]->pszFileName)
    677683        continue;
     684
    678685      pciSa[x]->flags |= CNRITEM_EXISTS;
    679686      pciDa[x]->flags |= CNRITEM_EXISTS;
     
    722729        DosSleep(1L);
    723730      else if (!(x % 50))
    724         DosSleep(0L);
     731        DosSleep(1);
    725732    }
    726733  }
     
    729736  case IDM_SELECTIDENTICAL:
    730737    for (x = 0; x < numS; x++) {
    731       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED)) {
     738      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED) {
    732739        if (*pciSa[x]->pszFileName &&
    733             (pciSa[x]->flags & CNRITEM_EXISTS) &&
    734             !(pciSa[x]->flags & CNRITEM_SMALLER) &&
    735             !(pciSa[x]->flags & CNRITEM_LARGER) &&
    736             !(pciSa[x]->flags & CNRITEM_NEWER) &&
    737             !(pciSa[x]->flags & CNRITEM_OLDER)) {
    738           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     740            pciSa[x]->flags & CNRITEM_EXISTS &&
     741            ~pciSa[x]->flags & CNRITEM_SMALLER &&
     742            ~pciSa[x]->flags & CNRITEM_LARGER &&
     743            ~pciSa[x]->flags & CNRITEM_NEWER &&
     744            ~pciSa[x]->flags & CNRITEM_OLDER) {
     745          if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    739746            WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    740747                       MPFROM2SHORT(TRUE, CRA_SELECTED));
    741           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     748          if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    742749            WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    743750                       MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    746753          DosSleep(1L);
    747754        else if (!(x % 50))
    748           DosSleep(0L);
     755          DosSleep(1);
    749756      }
    750757    }
     
    753760  case IDM_SELECTSAME:
    754761    for (x = 0; x < numS; x++) {
    755       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     762      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
    756763          *pciSa[x]->pszFileName &&
    757           (pciSa[x]->flags & CNRITEM_EXISTS) &&
    758           !(pciSa[x]->flags & CNRITEM_SMALLER) &&
    759           !(pciSa[x]->flags & CNRITEM_LARGER)) {
    760         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     764          pciSa[x]->flags & CNRITEM_EXISTS &&
     765          ~pciSa[x]->flags & CNRITEM_SMALLER &&
     766          ~pciSa[x]->flags & CNRITEM_LARGER) {
     767        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    761768          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    762769                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    763         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     770        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    764771          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    765772                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    768775        DosSleep(1L);
    769776      else if (!(x % 50))
    770         DosSleep(0L);
     777        DosSleep(1);
    771778    }
    772779    break;
     
    779786          *pciDa[x]->pszFileName &&
    780787          pciSa[x]->flags & CNRITEM_EXISTS &&
    781           pciDa[x]->flags & CNRITEM_EXISTS) {
    782 
     788          pciDa[x]->flags & CNRITEM_EXISTS)
     789      {
    783790        FILE *fp1 = NULL;
    784791        FILE *fp2 = NULL;
     
    839846        }
    840847        if (gotMatch) {
    841           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     848          if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    842849            WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    843850                       MPFROM2SHORT(TRUE, CRA_SELECTED));
    844           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     851          if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    845852            WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    846853                       MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    850857        DosSleep(1L);
    851858      else if (!(x % 50))
    852         DosSleep(0L);
     859        DosSleep(1);
    853860    }                                   // for records
    854861    break;
     
    856863  case IDM_SELECTBOTH:
    857864    for (x = 0; x < numS; x++) {
    858       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    859           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
    860         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     865      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     866          *pciSa[x]->pszFileName &&
     867          pciSa[x]->flags & CNRITEM_EXISTS) {
     868        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    861869          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    862870                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    863         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     871        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    864872          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    865873                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    868876        DosSleep(1L);
    869877      else if (!(x % 50))
    870         DosSleep(0L);
     878        DosSleep(1);
    871879    }
    872880    break;
     
    874882  case IDM_SELECTONE:
    875883    for (x = 0; x < numS; x++) {
    876       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    877           *pciSa[x]->pszFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
    878         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     884      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     885          *pciSa[x]->pszFileName &&
     886          ~pciSa[x]->flags & CNRITEM_EXISTS)
     887      {
     888        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    879889          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    880890                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    881891      }
    882       else if (*pciDa[x]->pszFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
    883         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     892      else if (*pciDa[x]->pszFileName &&
     893               ~pciDa[x]->flags & CNRITEM_EXISTS) {
     894        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    884895          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    885896                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    888899        DosSleep(1L);
    889900      else if (!(x % 50))
    890         DosSleep(0L);
     901        DosSleep(1);
    891902    }
    892903    break;
     
    894905  case IDM_SELECTBIGGER:
    895906    for (x = 0; x < numS; x++) {
    896       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    897           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
    898         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     907      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     908          pciSa[x]->flags & CNRITEM_LARGER) {
     909        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    899910          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    900911                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    901912      }
    902       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    903                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
    904         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     913      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     914               *pciDa[x]->pszFileName &&
     915               pciDa[x]->flags & CNRITEM_LARGER) {
     916        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    905917          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    906918                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    909921        DosSleep(1L);
    910922      else if (!(x % 50))
    911         DosSleep(0L);
     923        DosSleep(1);
    912924    }
    913925    break;
     
    915927  case IDM_SELECTSMALLER:
    916928    for (x = 0; x < numS; x++) {
    917       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    918           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
    919         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     929      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     930          *pciSa[x]->pszFileName &&
     931          pciSa[x]->flags & CNRITEM_SMALLER) {
     932        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    920933          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    921934                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    922935      }
    923       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    924                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
    925         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     936      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     937               *pciDa[x]->pszFileName &&
     938               pciDa[x]->flags & CNRITEM_SMALLER) {
     939        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    926940          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    927941                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    930944        DosSleep(1L);
    931945      else if (!(x % 50))
    932         DosSleep(0L);
     946        DosSleep(1);
    933947    }
    934948    break;
     
    936950  case IDM_SELECTNEWER:
    937951    for (x = 0; x < numS; x++) {
    938       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    939           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
    940         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     952      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     953          *pciSa[x]->pszFileName &&
     954          pciSa[x]->flags & CNRITEM_NEWER) {
     955        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    941956          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    942957                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    943958      }
    944       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    945                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
    946         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     959      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     960               *pciDa[x]->pszFileName &&
     961               pciDa[x]->flags & CNRITEM_NEWER) {
     962        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    947963          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    948964                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    951967        DosSleep(1L);
    952968      else if (!(x % 50))
    953         DosSleep(0L);
     969        DosSleep(1);
    954970    }
    955971    break;
     
    957973  case IDM_SELECTOLDER:
    958974    for (x = 0; x < numS; x++) {
    959       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    960           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
    961         if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     975      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     976          *pciSa[x]->pszFileName &&
     977          pciSa[x]->flags & CNRITEM_OLDER) {
     978        if (~pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    962979          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    963980                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    964981      }
    965       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    966                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
    967         if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     982      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     983               *pciDa[x]->pszFileName &&
     984               pciDa[x]->flags & CNRITEM_OLDER) {
     985        if (~pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    968986          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
    969987                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     
    972990        DosSleep(1L);
    973991      else if (!(x % 50))
    974         DosSleep(0L);
     992        DosSleep(1);
    975993    }
    976994    break;
     
    978996  case IDM_DESELECTBOTH:
    979997    for (x = 0; x < numS; x++) {
    980       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    981           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
     998      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     999          *pciSa[x]->pszFileName &&
     1000          pciSa[x]->flags & CNRITEM_EXISTS) {
    9821001        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    9831002          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     
    9901009        DosSleep(1L);
    9911010      else if (!(x % 50))
    992         DosSleep(0L);
     1011        DosSleep(1);
    9931012    }
    9941013    break;
     
    9961015  case IDM_DESELECTONE:
    9971016    for (x = 0; x < numS; x++) {
    998       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    999           *pciSa[x]->pszFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
     1017      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1018          *pciSa[x]->pszFileName &&
     1019          ~pciSa[x]->flags & CNRITEM_EXISTS) {
    10001020        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10011021          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    10021022                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    10031023      }
    1004       else if (*pciDa[x]->pszFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
     1024      else if (*pciDa[x]->pszFileName &&
     1025               ~pciDa[x]->flags & CNRITEM_EXISTS) {
    10051026        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10061027          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10101031        DosSleep(1L);
    10111032      else if (!(x % 50))
    1012         DosSleep(0L);
     1033        DosSleep(1);
    10131034    }
    10141035    break;
     
    10161037  case IDM_DESELECTBIGGER:
    10171038    for (x = 0; x < numS; x++) {
    1018       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1019           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
     1039      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1040          *pciSa[x]->pszFileName &&
     1041          pciSa[x]->flags & CNRITEM_LARGER) {
    10201042        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10211043          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    10221044                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    10231045      }
    1024       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1025                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
     1046      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1047               *pciDa[x]->pszFileName &&
     1048               pciDa[x]->flags & CNRITEM_LARGER) {
    10261049        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10271050          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10311054        DosSleep(1L);
    10321055      else if (!(x % 50))
    1033         DosSleep(0L);
     1056        DosSleep(1);
    10341057    }
    10351058    break;
     
    10371060  case IDM_DESELECTSMALLER:
    10381061    for (x = 0; x < numS; x++) {
    1039       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1040           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
     1062      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1063          *pciSa[x]->pszFileName &&
     1064          pciSa[x]->flags & CNRITEM_SMALLER) {
    10411065        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10421066          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    10431067                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    10441068      }
    1045       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1046                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
     1069      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1070               *pciDa[x]->pszFileName &&
     1071               pciDa[x]->flags & CNRITEM_SMALLER) {
    10471072        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10481073          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10521077        DosSleep(1L);
    10531078      else if (!(x % 50))
    1054         DosSleep(0L);
     1079        DosSleep(1);
    10551080    }
    10561081    break;
     
    10581083  case IDM_DESELECTNEWER:
    10591084    for (x = 0; x < numS; x++) {
    1060       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1061           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
     1085      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1086          *pciSa[x]->pszFileName &&
     1087          pciSa[x]->flags & CNRITEM_NEWER) {
    10621088        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10631089          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    10641090                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    10651091      }
    1066       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1067                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
     1092      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1093               *pciDa[x]->pszFileName &&
     1094               pciDa[x]->flags & CNRITEM_NEWER) {
    10681095        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10691096          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10731100        DosSleep(1L);
    10741101      else if (!(x % 50))
    1075         DosSleep(0L);
     1102        DosSleep(1);
    10761103    }
    10771104    break;
     
    10791106  case IDM_DESELECTOLDER:
    10801107    for (x = 0; x < numS; x++) {
    1081       if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1082           *pciSa[x]->pszFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
     1108      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1109          *pciSa[x]->pszFileName &&
     1110          pciSa[x]->flags & CNRITEM_OLDER) {
    10831111        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    10841112          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
    10851113                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    10861114      }
    1087       else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1088                *pciDa[x]->pszFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
     1115      else if (~pciDa[x]->rc.flRecordAttr & CRA_FILTERED &&
     1116               *pciDa[x]->pszFileName &&
     1117               pciDa[x]->flags & CNRITEM_OLDER) {
    10891118        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    10901119          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     
    10941123        DosSleep(1L);
    10951124      else if (!(x % 50))
    1096         DosSleep(0L);
     1125        DosSleep(1);
    10971126    }
    10981127    break;
     
    11061135      WinSendMsg(hwndCnrS, CM_INVALIDATERECORD,
    11071136                 MPFROMP(pciSa), MPFROM2SHORT((min(numS, 65535)), 0));
    1108       DosSleep(0L);
     1137      DosSleep(1);
    11091138      WinSendMsg(hwndCnrD, CM_INVALIDATERECORD,
    11101139                 MPFROMP(pciDa), MPFROM2SHORT((min(numD, 65535)), 0));
    11111140      numS -= min(numS, 65535);
    11121141      if (numS)
    1113         DosSleep(0L);
     1142        DosSleep(1);
    11141143    }
    11151144  }
     
    11371166  struct SS *ss2 = (struct SS *)s2;
    11381167
    1139   return stricmp((CHAR *) s1, ss2->pci->pszFileName);
     1168  return stricmp((PSZ)s1, ss2->pci->pszFileName);
    11401169}
    11411170
     
    12011230               hwndCnr,
    12021231               UM_NOTIFY, MPFROMP(GetPString(IDS_BUILDINGLISTSTEXT)), MPVOID);
    1203     DosSleep(0L);
     1232    DosSleep(1);
    12041233  }
    12051234
     
    12111240                                MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    12121241    x = 0;
    1213     while (pci && (INT) pci != -1) {
    1214       if (!(pci->rc.flRecordAttr & CRA_FILTERED) &&
    1215           !(pci->attrFile & FILE_DIRECTORY)) {
     1242    while (pci && (INT)pci != -1) {
     1243      if (~pci->rc.flRecordAttr & CRA_FILTERED &&
     1244          ~pci->attrFile & FILE_DIRECTORY) {
    12161245        Cnrs[z].ss =
    12171246          xrealloc(Cnrs[z].ss, (x + 1) * sizeof(struct SS), pszSrcFile,
     
    12311260                                  MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    12321261    }
    1233     DosSleep(0L);
     1262    DosSleep(1);
    12341263    Cnrs[z].numfiles = x;
    12351264    if (Cnrs[z].numfiles)
     
    13391368        Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].newest = Cnrs[z].ss[x].all =
    13401369          Cnrs[z].ss[x].largest = Cnrs[z].ss[x].smallest = FALSE;
    1341       DosSleep(0L);
     1370      DosSleep(1);
    13421371    }
    13431372    DosSleep(1L);
     
    13531382                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    13541383      }
    1355       DosSleep(0L);
     1384      DosSleep(1);
    13561385    }
    13571386    break;
     
    13641393                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    13651394      }
    1366       DosSleep(0L);
     1395      DosSleep(1);
    13671396    }
    13681397    break;
     
    13751404                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    13761405      }
    1377       DosSleep(0L);
     1406      DosSleep(1);
    13781407    }
    13791408    break;
     
    13861415                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    13871416      }
    1388       DosSleep(0L);
     1417      DosSleep(1);
    13891418    }
    13901419    break;
     
    13971426                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    13981427      }
    1399       DosSleep(0L);
     1428      DosSleep(1);
    14001429    }
    14011430    break;
     
    14081437                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    14091438      }
    1410       DosSleep(0L);
     1439      DosSleep(1);
    14111440    }
    14121441    break;
     
    14191448                     MPFROM2SHORT(TRUE, CRA_SELECTED));
    14201449      }
    1421       DosSleep(0L);
     1450      DosSleep(1);
    14221451    }
    14231452    break;
     
    14311460                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14321461      }
    1433       DosSleep(0L);
     1462      DosSleep(1);
    14341463    }
    14351464    break;
     
    14421471                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14431472      }
    1444       DosSleep(0L);
     1473      DosSleep(1);
    14451474    }
    14461475    break;
     
    14531482                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14541483      }
    1455       DosSleep(0L);
     1484      DosSleep(1);
    14561485    }
    14571486    break;
     
    14641493                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14651494      }
    1466       DosSleep(0L);
     1495      DosSleep(1);
    14671496    }
    14681497    break;
     
    14751504                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14761505      }
    1477       DosSleep(0L);
     1506      DosSleep(1);
    14781507    }
    14791508    break;
     
    14861515                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14871516      }
    1488       DosSleep(0L);
     1517      DosSleep(1);
    14891518    }
    14901519    break;
     
    14971526                     MPFROM2SHORT(FALSE, CRA_SELECTED));
    14981527      }
    1499       DosSleep(0L);
     1528      DosSleep(1);
    15001529    }
    15011530    break;
Note: See TracChangeset for help on using the changeset viewer.