Changeset 551 for trunk/dll/select.c


Ignore:
Timestamp:
Feb 28, 2007, 2:33:51 AM (19 years ago)
Author:
Gregg Young
Message:

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/select.c

    r442 r551  
    3939static PSZ pszSrcFile = __FILE__;
    4040
    41 VOID UnHilite (HWND hwndCnr,BOOL all,CHAR ***list)
     41VOID UnHilite(HWND hwndCnr, BOOL all, CHAR *** list)
    4242{
    4343  PCNRITEM pci;
    44   INT      numfiles = 0,numalloc = 0;
    45   INT      attribute = CRA_CURSORED;
     44  INT numfiles = 0, numalloc = 0;
     45  INT attribute = CRA_CURSORED;
    4646
    4747  if (all && list && *list) {
    … …  
    4949    *list = NULL;
    5050  }
    51   pci = (PCNRITEM)CurrentRecord(hwndCnr);
    52   if (pci && (INT)pci != -1) {
     51  pci = (PCNRITEM) CurrentRecord(hwndCnr);
     52  if (pci && (INT) pci != -1) {
    5353    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    5454      attribute = CRA_SELECTED;
    55       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    56                        MPFROMSHORT(attribute));
    57     }
    58     while (pci && (INT)pci != -1) {
    59       WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    60                  MPFROM2SHORT(FALSE,CRA_SELECTED));
     55      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     56                       MPFROMSHORT(attribute));
     57    }
     58    while (pci && (INT) pci != -1) {
     59      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     60                 MPFROM2SHORT(FALSE, CRA_SELECTED));
    6161      if (!all)
    62         break;
     62        break;
    6363      if (list)
    64         AddToList(pci->szFileName,list,&numfiles,&numalloc);
    65       pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,
    66                                  MPFROMP(pci),
    67                                  MPFROMSHORT(CRA_SELECTED));
    68     }
    69   }
    70 }
    71 
    72 VOID SelectList (HWND hwndCnr,BOOL partial,BOOL deselect,BOOL clearfirst,
    73                  PCNRITEM pciParent,CHAR *filename,CHAR **list)
    74 {
    75 
    76   PCNRITEM     pci;
     64        AddToList(pci->szFileName, list, &numfiles, &numalloc);
     65      pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
     66                                  MPFROMP(pci), MPFROMSHORT(CRA_SELECTED));
     67    }
     68  }
     69}
     70
     71VOID SelectList(HWND hwndCnr, BOOL partial, BOOL deselect, BOOL clearfirst,
     72                PCNRITEM pciParent, CHAR * filename, CHAR ** list)
     73{
     74
     75  PCNRITEM pci;
    7776  register INT x;
    78   BOOL         foundone = FALSE;
    79   ULONG        errs = 0L;
     77  BOOL foundone = FALSE;
     78  ULONG errs = 0L;
    8079
    8180  if (clearfirst && !deselect)
    82     UnHilite(hwndCnr,TRUE,NULL);
     81    UnHilite(hwndCnr, TRUE, NULL);
    8382  if (list && list[0]) {
    84     for (x = 0;list[x];x++) {
     83    for (x = 0; list[x]; x++) {
    8584      pci = FindCnrRecord(hwndCnr,
    86                           list[x],
    87                           pciParent,
    88                           partial,
    89                           partial,
    90                           TRUE);
     85                          list[x], pciParent, partial, partial, TRUE);
    9186      if (pci) {
    92         WinSendMsg(hwndCnr,
    93                    CM_SETRECORDEMPHASIS,
    94                    MPFROMP(pci),
    95                    MPFROM2SHORT((SHORT)((deselect) ? FALSE : TRUE),
    96                                 CRA_SELECTED));
    97         foundone = TRUE;
     87        WinSendMsg(hwndCnr,
     88                   CM_SETRECORDEMPHASIS,
     89                   MPFROMP(pci),
     90                   MPFROM2SHORT((SHORT) ((deselect) ? FALSE : TRUE),
     91                                CRA_SELECTED));
     92        foundone = TRUE;
    9893      }
    9994    }
    … …  
    10499
    105100    FILE *fp;
    106     CHAR input[1024],*p;
    107 
    108     fp = _fsopen(filename,"r",SH_DENYNO);
     101    CHAR input[1024], *p;
     102
     103    fp = _fsopen(filename, "r", SH_DENYNO);
    109104    if (fp) {
    110105      while (!feof(fp)) {
    111         if (!xfgets_bstripcr(input,sizeof(input),fp,pszSrcFile,__LINE__))
    112           break;
    113         if (*input == '\"') {
    114           memmove(input,input + 1,strlen(input) + 1);
    115           lstrip(input);
    116           p = strchr(input,'\"');
    117           if (p)
    118             *p = 0;
    119           rstrip(input);
    120         }
    121         else {
    122           p = strchr(input,' ');
    123           if (p)
    124             *p = 0;
    125         }
    126         /* input now contains name of file to select */
    127         pci = FindCnrRecord(hwndCnr,
    128                             input,
    129                             pciParent,
    130                             partial,
    131                             partial,
    132                             TRUE);
    133         if (pci)       /* found it? */
    134           WinSendMsg(hwndCnr,
    135                      CM_SETRECORDEMPHASIS,
    136                      MPFROMP(pci),
    137                      MPFROM2SHORT((SHORT)((deselect) ? FALSE : TRUE),
    138                                   CRA_SELECTED));
    139         else
    140           errs++;
    141         if (errs > 50L) {  /* prevent runaway on bad file */
    142 
    143           APIRET ret;
    144 
    145           ret = saymsg(MB_YESNO,
    146                        hwndCnr,
    147                        GetPString(IDS_POSSIBLEERRORTEXT),
    148                        GetPString(IDS_MAYNOTBELISTTEXT),
    149                        filename);
    150           if (ret == MBID_NO)
    151             break;
    152           errs = 0L;
    153         }
     106        if (!xfgets_bstripcr(input, sizeof(input), fp, pszSrcFile, __LINE__))
     107          break;
     108        if (*input == '\"') {
     109          memmove(input, input + 1, strlen(input) + 1);
     110          lstrip(input);
     111          p = strchr(input, '\"');
     112          if (p)
     113            *p = 0;
     114          rstrip(input);
     115        }
     116        else {
     117          p = strchr(input, ' ');
     118          if (p)
     119            *p = 0;
     120        }
     121        /* input now contains name of file to select */
     122        pci = FindCnrRecord(hwndCnr,
     123                            input, pciParent, partial, partial, TRUE);
     124        if (pci)                        /* found it? */
     125          WinSendMsg(hwndCnr,
     126                     CM_SETRECORDEMPHASIS,
     127                     MPFROMP(pci),
     128                     MPFROM2SHORT((SHORT) ((deselect) ? FALSE : TRUE),
     129                                  CRA_SELECTED));
     130        else
     131          errs++;
     132        if (errs > 50L) {               /* prevent runaway on bad file */
     133
     134          APIRET ret;
     135
     136          ret = saymsg(MB_YESNO,
     137                       hwndCnr,
     138                       GetPString(IDS_POSSIBLEERRORTEXT),
     139                       GetPString(IDS_MAYNOTBELISTTEXT), filename);
     140          if (ret == MBID_NO)
     141            break;
     142          errs = 0L;
     143        }
    154144      }
    155145      fclose(fp);
    … …  
    158148}
    159149
    160 VOID SelectAll (HWND hwndCnr,BOOL files,BOOL dirs,CHAR *maskstr,
    161                 CHAR *text,BOOL is_arc)
    162 {
    163 
    164   PCNRITEM       pci;
    165   BOOL           markit;
     150VOID SelectAll(HWND hwndCnr, BOOL files, BOOL dirs, CHAR * maskstr,
     151               CHAR * text, BOOL is_arc)
     152{
     153
     154  PCNRITEM pci;
     155  BOOL markit;
    166156  register CHAR *file;
    167   MASK           Mask;
    168   register INT   x;
    169   ULONG          textlen = 0;
     157  MASK Mask;
     158  register INT x;
     159  ULONG textlen = 0;
    170160
    171161  if (text)
    172162    textlen = strlen(text);
    173   memset(&Mask,0,sizeof(Mask));
     163  memset(&Mask, 0, sizeof(Mask));
    174164  if (maskstr)
    175     SetMask(maskstr,&Mask);
    176   pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPVOID,
    177                              MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
    178   while ( pci && (INT)pci != -1 ) {
     165    SetMask(maskstr, &Mask);
     166  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
     167                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     168  while (pci && (INT) pci != -1) {
    179169    markit = FALSE;
    180170    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    181171      if (!is_arc) {
    182         if (files && !(pci->attrFile & FILE_DIRECTORY))
    183           markit = TRUE;
    184         if (dirs && (pci->attrFile & FILE_DIRECTORY))
    185           markit = TRUE;
     172        if (files && !(pci->attrFile & FILE_DIRECTORY))
     173          markit = TRUE;
     174        if (dirs && (pci->attrFile & FILE_DIRECTORY))
     175          markit = TRUE;
    186176      }
    187177      else
    188         markit = TRUE;
     178        markit = TRUE;
    189179      if (maskstr && *maskstr && markit) {
    190         markit = FALSE;
    191         file = strrchr(pci->szFileName,'\\');
    192         if (!file)
    193           file = strrchr(pci->szFileName,':');
    194         if (file)
    195           file++;
    196         else
    197           file = pci->szFileName;
    198         for (x = 0;Mask.pszMasks[x];x++) {
    199           if (*Mask.pszMasks[x]) {
    200             if (*Mask.pszMasks[x] != '/') {
    201               if (wildcard((strchr(Mask.pszMasks[x],'\\') ||
    202                            strchr(Mask.pszMasks[x],':')) ?
    203                            pci->szFileName : file,Mask.pszMasks[x],FALSE))
    204                 markit = TRUE;
    205             }
    206             else {
    207               if (wildcard((strchr(Mask.pszMasks[x],'\\') ||
    208                            strchr(Mask.pszMasks[x],':'),FALSE) ?
    209                            pci->szFileName : file,Mask.pszMasks[x] + 1,
    210                            FALSE)) {
    211                 markit = FALSE;
    212                 break;
    213               }
    214             }
    215           }
    216         }
     180        markit = FALSE;
     181        file = strrchr(pci->szFileName, '\\');
     182        if (!file)
     183          file = strrchr(pci->szFileName, ':');
     184        if (file)
     185          file++;
     186        else
     187          file = pci->szFileName;
     188        for (x = 0; Mask.pszMasks[x]; x++) {
     189          if (*Mask.pszMasks[x]) {
     190            if (*Mask.pszMasks[x] != '/') {
     191              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
     192                            strchr(Mask.pszMasks[x], ':')) ?
     193                           pci->szFileName : file, Mask.pszMasks[x], FALSE))
     194                markit = TRUE;
     195            }
     196            else {
     197              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||  //fixme always true?
     198                            strchr(Mask.pszMasks[x], ':'), FALSE) ?
     199                           pci->szFileName : file, Mask.pszMasks[x] + 1,
     200                           FALSE)) {
     201                markit = FALSE;
     202                break;
     203              }
     204            }
     205          }
     206        }
    217207      }
    218208    }
    … …  
    222212
    223213      markit = FALSE;
    224       input = xmalloc(65537,pszSrcFile,__LINE__);
     214      input = xmalloc(65537, pszSrcFile, __LINE__);
    225215      if (input) {
    226         ULONG pos;
    227         LONG len;
    228         FILE *inputFile;
    229 
    230         if ((inputFile = _fsopen(pci->szFileName,"rb",SH_DENYNO)) != NULL) {
    231           pos = ftell(inputFile);
    232           while (!feof(inputFile)) {
    233             if (pos)
    234               fseek(inputFile,pos - 256,SEEK_SET);
    235             len = fread(input,1,65536,inputFile);
    236             if (len >= 0) {
    237               if (findstring(text,textlen,input,len,FALSE)) {
    238                 markit = TRUE;
    239                 break;
    240               }
    241             }
    242             else
    243               break;
    244           }
    245           fclose(inputFile) ;
    246         }
    247         free(input);
    248         DosSleep(1L);
     216        ULONG pos;
     217        LONG len;
     218        FILE *inputFile;
     219
     220        if ((inputFile = _fsopen(pci->szFileName, "rb", SH_DENYNO)) != NULL) {
     221          pos = ftell(inputFile);
     222          while (!feof(inputFile)) {
     223            if (pos)
     224              fseek(inputFile, pos - 256, SEEK_SET);
     225            len = fread(input, 1, 65536, inputFile);
     226            if (len >= 0) {
     227              if (findstring(text, textlen, input, len, FALSE)) {
     228                markit = TRUE;
     229                break;
     230              }
     231            }
     232            else
     233              break;
     234          }
     235          fclose(inputFile);
     236        }
     237        free(input);
     238        DosSleep(1L);
    249239      }
    250240    }
    … …  
    252242      markit = FALSE;
    253243    if (markit)
    254       WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    255                  MPFROM2SHORT(TRUE,CRA_SELECTED));
    256     pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPFROMP(pci),
    257                                MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
    258   } // while
    259 }
    260 
    261 VOID DeselectAll (HWND hwndCnr,BOOL files,BOOL dirs,CHAR *maskstr,CHAR *text,
    262                   BOOL is_arc)
    263 {
    264   PCNRITEM       pci;
    265   BOOL           unmarkit;
     244      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     245                 MPFROM2SHORT(TRUE, CRA_SELECTED));
     246    pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
     247                                MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     248  }                                     // while
     249}
     250
     251VOID DeselectAll(HWND hwndCnr, BOOL files, BOOL dirs, CHAR * maskstr,
     252                 CHAR * text, BOOL is_arc)
     253{
     254  PCNRITEM pci;
     255  BOOL unmarkit;
    266256  register CHAR *file;
    267   MASK           Mask;
    268   register INT   x;
    269   ULONG          textlen = 0;
     257  MASK Mask;
     258  register INT x;
     259  ULONG textlen = 0;
    270260
    271261  if (text)
    272262    textlen = strlen(text);
    273   memset(&Mask,0,sizeof(Mask));
     263  memset(&Mask, 0, sizeof(Mask));
    274264  if (maskstr && *maskstr)
    275     SetMask(maskstr,&Mask);
    276   pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPVOID,
    277                              MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
    278   while ( pci && (INT)pci != -1 ) {
     265    SetMask(maskstr, &Mask);
     266  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
     267                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     268  while (pci && (INT) pci != -1) {
    279269    unmarkit = FALSE;
    280270    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    281271      if (!is_arc) {
    282         if (files && !(pci->attrFile & FILE_DIRECTORY))
    283           unmarkit = TRUE;
    284         if (dirs && (pci->attrFile & FILE_DIRECTORY))
    285           unmarkit = TRUE;
     272        if (files && !(pci->attrFile & FILE_DIRECTORY))
     273          unmarkit = TRUE;
     274        if (dirs && (pci->attrFile & FILE_DIRECTORY))
     275          unmarkit = TRUE;
    286276      }
    287277      else
    288         unmarkit = TRUE;
     278        unmarkit = TRUE;
    289279      if (maskstr && *maskstr && unmarkit) {
    290         unmarkit = FALSE;
    291         file = strrchr(pci->szFileName,'\\');
    292         if (!file)
    293           file = strrchr(pci->szFileName,':');
    294         if (file)
    295           file++;
    296         else
    297           file = pci->szFileName;
    298         for (x = 0;Mask.pszMasks[x];x++) {
    299           if (*Mask.pszMasks[x]) {
    300             if (*Mask.pszMasks[x] != '/') {
    301               if (wildcard((strchr(Mask.pszMasks[x],'\\') ||
    302                            strchr(Mask.pszMasks[x],':')) ?
    303                            pci->szFileName : file,Mask.pszMasks[x],FALSE))
    304                 unmarkit = TRUE;
    305             }
    306             else {
    307               if (wildcard((strchr(Mask.pszMasks[x],'\\') ||
    308                            strchr(Mask.pszMasks[x],':')) ?
    309                            pci->szFileName : file,Mask.pszMasks[x] + 1,
    310                            FALSE)) {
    311                 unmarkit = FALSE;
    312                 break;
    313               }
    314             }
    315           }
    316         }
     280        unmarkit = FALSE;
     281        file = strrchr(pci->szFileName, '\\');
     282        if (!file)
     283          file = strrchr(pci->szFileName, ':');
     284        if (file)
     285          file++;
     286        else
     287          file = pci->szFileName;
     288        for (x = 0; Mask.pszMasks[x]; x++) {
     289          if (*Mask.pszMasks[x]) {
     290            if (*Mask.pszMasks[x] != '/') {
     291              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
     292                            strchr(Mask.pszMasks[x], ':')) ?
     293                           pci->szFileName : file, Mask.pszMasks[x], FALSE))
     294                unmarkit = TRUE;
     295            }
     296            else {
     297              if (wildcard((strchr(Mask.pszMasks[x], '\\') ||
     298                            strchr(Mask.pszMasks[x], ':')) ?
     299                           pci->szFileName : file, Mask.pszMasks[x] + 1,
     300                           FALSE)) {
     301                unmarkit = FALSE;
     302                break;
     303              }
     304            }
     305          }
     306        }
    317307      }
    318308    }
    … …  
    322312
    323313      unmarkit = FALSE;
    324       input = xmalloc(65537,pszSrcFile,__LINE__);
     314      input = xmalloc(65537, pszSrcFile, __LINE__);
    325315      if (input) {
    326         ULONG pos;
    327         LONG len;
    328         FILE *inputFile;
    329 
    330         if ((inputFile = _fsopen(pci->szFileName,"rb",SH_DENYNO)) != NULL) {
    331           pos = ftell(inputFile);
    332           while (!feof(inputFile)) {
    333             if (pos)
    334               fseek(inputFile,pos - 256,SEEK_SET);
    335             len = fread(input,1,65536,inputFile);
    336             if (len >= 0) {
    337               if (findstring(text,textlen,input,len,FALSE)) {
    338                 unmarkit = TRUE;
    339                 break;
    340               }
    341             }
    342             else
    343               break;
    344           }
    345           fclose(inputFile) ;
    346         }
    347         free(input);
    348         DosSleep(1L);
     316        ULONG pos;
     317        LONG len;
     318        FILE *inputFile;
     319
     320        if ((inputFile = _fsopen(pci->szFileName, "rb", SH_DENYNO)) != NULL) {
     321          pos = ftell(inputFile);
     322          while (!feof(inputFile)) {
     323            if (pos)
     324              fseek(inputFile, pos - 256, SEEK_SET);
     325            len = fread(input, 1, 65536, inputFile);
     326            if (len >= 0) {
     327              if (findstring(text, textlen, input, len, FALSE)) {
     328                unmarkit = TRUE;
     329                break;
     330              }
     331            }
     332            else
     333              break;
     334          }
     335          fclose(inputFile);
     336        }
     337        free(input);
     338        DosSleep(1L);
    349339      }
    350340    }
    … …  
    352342      unmarkit = FALSE;
    353343    if (unmarkit)
    354       WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,pci,
    355                  MPFROM2SHORT(FALSE,CRA_SELECTED | CRA_CURSORED |
    356                               CRA_INUSE | CRA_SOURCE));
    357     pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPFROMP(pci),
    358                                MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
    359   }
    360 }
    361 
    362 VOID Deselect (HWND hwndCnr)
     344      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pci,
     345                 MPFROM2SHORT(FALSE, CRA_SELECTED | CRA_CURSORED |
     346                              CRA_INUSE | CRA_SOURCE));
     347    pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
     348                                MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     349  }
     350}
     351
     352VOID Deselect(HWND hwndCnr)
    363353{
    364354  PCNRITEM pcil;
    365355
    366   pcil = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,
    367                               MPFROMLONG(CMA_FIRST),
    368                               MPFROMSHORT(CRA_SELECTED));
    369   while (pcil && (INT)pcil != -1) {
    370     WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pcil),
    371                MPFROM2SHORT(FALSE,CRA_SELECTED));
    372     pcil = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMP(pcil),
    373                       MPFROMSHORT(CRA_SELECTED));
     356  pcil = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
     357                               MPFROMLONG(CMA_FIRST),
     358                               MPFROMSHORT(CRA_SELECTED));
     359  while (pcil && (INT) pcil != -1) {
     360    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pcil),
     361               MPFROM2SHORT(FALSE, CRA_SELECTED));
     362    pcil = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pcil),
     363                      MPFROMSHORT(CRA_SELECTED));
    374364  }
    375365}
    … …  
    377367//=== HideAll() Hide all selected records ===
    378368
    379 VOID HideAll (HWND hwndCnr)
    380 {
    381   PCNRITEM pci,pciH;
    382   INT      attribute = CRA_CURSORED;
    383   CNRINFO  cnri;
    384   BOOL     didone = FALSE;
    385 
    386   memset(&cnri,0,sizeof(CNRINFO));
     369VOID HideAll(HWND hwndCnr)
     370{
     371  PCNRITEM pci, pciH;
     372  INT attribute = CRA_CURSORED;
     373  CNRINFO cnri;
     374  BOOL didone = FALSE;
     375
     376  memset(&cnri, 0, sizeof(CNRINFO));
    387377  cnri.cb = sizeof(CNRINFO);
    388   WinSendMsg(hwndCnr,CM_QUERYCNRINFO,MPFROMP(&cnri),
    389              MPFROMLONG(sizeof(CNRINFO)));
    390   pci = (PCNRITEM)CurrentRecord(hwndCnr);
    391   if (pci && (INT)pci != -1) {
     378  WinSendMsg(hwndCnr, CM_QUERYCNRINFO, MPFROMP(&cnri),
     379             MPFROMLONG(sizeof(CNRINFO)));
     380  pci = (PCNRITEM) CurrentRecord(hwndCnr);
     381  if (pci && (INT) pci != -1) {
    392382    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    393383      attribute = CRA_SELECTED;
    394       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    395                        MPFROMSHORT(attribute));
    396     }
    397   }
    398   while (pci && (INT)pci != -1) {
    399     pciH = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMP(pci),
    400                       MPFROMSHORT(attribute));
    401     WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    402                MPFROM2SHORT(FALSE,CRA_CURSORED | CRA_SELECTED |
    403                                   CRA_INUSE | CRA_SOURCE));
     384      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     385                       MPFROMSHORT(attribute));
     386    }
     387  }
     388  while (pci && (INT) pci != -1) {
     389    pciH = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
     390                      MPFROMSHORT(attribute));
     391    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     392               MPFROM2SHORT(FALSE, CRA_CURSORED | CRA_SELECTED |
     393                            CRA_INUSE | CRA_SOURCE));
    404394    pci->rc.flRecordAttr |= CRA_FILTERED;
    405395    didone = TRUE;
    406396    if (fSyncUpdates) {
    407397      if (cnri.flWindowAttr & CV_DETAIL)
    408         WinSendMsg(hwndCnr,CM_INVALIDATERECORD,MPVOID,
    409                    MPFROM2SHORT(0,CMA_REPOSITION | CMA_ERASE));
     398        WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPVOID,
     399                   MPFROM2SHORT(0, CMA_REPOSITION | CMA_ERASE));
    410400      else
    411         WinSendMsg(hwndCnr,CM_INVALIDATERECORD,MPFROMP(&pci),
    412                    MPFROM2SHORT(1,CMA_REPOSITION | CMA_ERASE));
     401        WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPFROMP(&pci),
     402                   MPFROM2SHORT(1, CMA_REPOSITION | CMA_ERASE));
    413403    }
    414404    pci = pciH;
    415405  }
    416406  if (didone && !fSyncUpdates)
    417       WinSendMsg(hwndCnr,CM_INVALIDATERECORD,MPVOID,
    418                  MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    419 }
    420 
    421 VOID MarkAll (HWND hwndCnr,BOOL quitit,BOOL target,BOOL source)
     407    WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPVOID,
     408               MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     409}
     410
     411VOID MarkAll(HWND hwndCnr, BOOL quitit, BOOL target, BOOL source)
    422412{
    423413  PCNRITEM pci;
    424   INT      attribute = CRA_CURSORED;
     414  INT attribute = CRA_CURSORED;
    425415
    426416  if (quitit)
    427417    attribute = (target) ? CRA_TARGET : (source) ? CRA_SOURCE : CRA_INUSE;
    428   pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,
    429                              MPFROMLONG(CMA_FIRST),
    430                              MPFROMSHORT(attribute));
    431   if (pci && (INT)pci != -1) {
     418  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
     419                              MPFROMLONG(CMA_FIRST), MPFROMSHORT(attribute));
     420  if (pci && (INT) pci != -1) {
    432421    if (attribute == CRA_CURSORED) {
    433422      if (pci->rc.flRecordAttr & CRA_SELECTED) {
    434         attribute = CRA_SELECTED;
    435         pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    436                          MPFROMSHORT(attribute));
    437       }
    438     }
    439   }
    440   while ( pci && (INT)pci != -1) {
    441     WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    442                MPFROM2SHORT(!quitit,
    443                ((target) ? CRA_TARGET : (source) ? CRA_SOURCE : CRA_INUSE)));
    444     pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMP(pci),
    445                      MPFROMSHORT(attribute));
    446   }
    447 }
    448 
    449 VOID RemoveAll (HWND hwndCnr,ULONGLONG *pullTotalBytes,ULONG *pulTotalFiles)
     423        attribute = CRA_SELECTED;
     424        pci =
     425          WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     426                     MPFROMSHORT(attribute));
     427      }
     428    }
     429  }
     430  while (pci && (INT) pci != -1) {
     431    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     432               MPFROM2SHORT(!quitit,
     433                            ((target) ? CRA_TARGET : (source) ? CRA_SOURCE :
     434                             CRA_INUSE)));
     435    pci =
     436      WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
     437                 MPFROMSHORT(attribute));
     438  }
     439}
     440
     441VOID RemoveAll(HWND hwndCnr, ULONGLONG * pullTotalBytes,
     442               ULONG * pulTotalFiles)
    450443{
    451444  PCNRITEM pci;
    452   INT      attribute = CRA_CURSORED;
    453   BOOL     didone = FALSE;
    454 
    455   pci = (PCNRITEM)CurrentRecord(hwndCnr);
    456   if (pci && (INT)pci != -1) {
     445  INT attribute = CRA_CURSORED;
     446  BOOL didone = FALSE;
     447
     448  pci = (PCNRITEM) CurrentRecord(hwndCnr);
     449  if (pci && (INT) pci != -1) {
    457450    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    458451      attribute = CRA_SELECTED;
    459       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    460                        MPFROMSHORT(attribute));
    461     }
    462   }
    463   while (pci && (INT)pci != -1) {
    464     if (!(pci->rc.flRecordAttr & CRA_FILTERED))
    465     {
     452      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     453                       MPFROMSHORT(attribute));
     454    }
     455  }
     456  while (pci && (INT) pci != -1) {
     457    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    466458      didone = TRUE;
    467459      if (pulTotalFiles)
    468         *pulTotalFiles--;
     460        *pulTotalFiles--;
    469461      if (pullTotalBytes)
    470         *pullTotalBytes -= (pci->cbFile + pci->easize);
    471       WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    472                  MPFROM2SHORT(0,CRA_SELECTED));
     462        *pullTotalBytes -= (pci->cbFile + pci->easize);
     463      WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     464                 MPFROM2SHORT(0, CRA_SELECTED));
    473465      if (fSyncUpdates)
    474         WinSendMsg(hwndCnr,CM_REMOVERECORD,MPFROMP(&pci),
    475                    MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
     466        WinSendMsg(hwndCnr, CM_REMOVERECORD, MPFROMP(&pci),
     467                   MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
    476468      else
    477         WinSendMsg(hwndCnr,CM_REMOVERECORD,MPFROMP(&pci),
    478                    MPFROM2SHORT(1,CMA_FREE));
     469        WinSendMsg(hwndCnr, CM_REMOVERECORD, MPFROMP(&pci),
     470                   MPFROM2SHORT(1, CMA_FREE));
    479471      if (attribute == CRA_CURSORED)
    480         break;
    481       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    482                        MPFROMSHORT(attribute));
     472        break;
     473      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     474                       MPFROMSHORT(attribute));
    483475    }
    484476    else
    485       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMP(pci),
    486                        MPFROMSHORT(attribute));
     477      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
     478                       MPFROMSHORT(attribute));
    487479  }
    488480  if (didone && !fSyncUpdates)
    489       WinSendMsg(hwndCnr,CM_INVALIDATERECORD,MPVOID,
    490                  MPFROM2SHORT(0,CMA_REPOSITION));
     481    WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPVOID,
     482               MPFROM2SHORT(0, CMA_REPOSITION));
    491483}
    492484
    493485//== SetMask() Convert mask string to array of pointers to masks ==
    494486
    495 VOID SetMask (PSZ maskstr,MASK *mask)
     487VOID SetMask(PSZ maskstr, MASK * mask)
    496488{
    497489  UINT x;
    … …  
    499491
    500492  if (maskstr)
    501     strcpy(mask->szMask,maskstr);       // Got new mask string
     493    strcpy(mask->szMask, maskstr);      // Got new mask string
    502494  // Build array of pointers
    503495  p = mask->szMaskCopy;
    504   strcpy(p,mask->szMask);
    505   // memset(mask->pszMasks,0,sizeof(mask->pszMasks);    // fixme to be gone
     496  strcpy(p, mask->szMask);
     497  // memset(mask->pszMasks,0,sizeof(mask->pszMasks);    // fixme to be gone
    506498  // Allow up to 25 masks - ignore extras
    507499  for (x = 0; *p && x < 25; x++) {
    … …  
    513505      p++;
    514506    }
    515   } // for
     507  }                                     // for
    516508  mask->pszMasks[x] = NULL;             // Mark end
    517509}
    518510
    519 VOID ExpandAll (HWND hwndCnr,BOOL expand,PCNRITEM pciParent)
     511VOID ExpandAll(HWND hwndCnr, BOOL expand, PCNRITEM pciParent)
    520512{
    521513  PCNRITEM pci;
    522514
    523515  if (!pciParent)
    524     pciParent = WinSendMsg(hwndCnr,CM_QUERYRECORD,MPFROMP(NULL),
    525                            MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
     516    pciParent = WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(NULL),
     517                           MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    526518  if (pciParent) {
    527519    if (expand && !(pciParent->rc.flRecordAttr & CRA_EXPANDED))
    528       WinSendMsg(hwndCnr,CM_EXPANDTREE,MPFROMP(pciParent),MPVOID);
     520      WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciParent), MPVOID);
    529521    else if (!expand && (pciParent->rc.flRecordAttr & CRA_EXPANDED))
    530       WinSendMsg(hwndCnr,CM_COLLAPSETREE,MPFROMP(pciParent),MPVOID);
    531     pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPFROMP(pciParent),
    532                                MPFROM2SHORT(CMA_FIRSTCHILD,CMA_ITEMORDER));
     522      WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciParent), MPVOID);
     523    pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pciParent),
     524                                MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
    533525    if (pci)
    534526      DosSleep(1L);
    535     while (pci && (INT)pci != -1) {
    536       ExpandAll(hwndCnr,expand,pci);
    537       pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPFROMP(pci),
    538                                  MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
     527    while (pci && (INT) pci != -1) {
     528      ExpandAll(hwndCnr, expand, pci);
     529      pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
     530                                  MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    539531    }
    540532  }
    … …  
    542534}
    543535
    544 VOID InvertAll (HWND hwndCnr)
     536VOID InvertAll(HWND hwndCnr)
    545537{
    546538  PCNRITEM pci;
    547539
    548   pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPVOID,
    549                              MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
    550   while ( pci && (INT)pci != -1 ) {
     540  pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
     541                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     542  while (pci && (INT) pci != -1) {
    551543    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    552544      if (!(pci->rc.flRecordAttr & CRA_SELECTED))
    553         WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    554                    MPFROM2SHORT(TRUE,CRA_SELECTED));
     545        WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     546                   MPFROM2SHORT(TRUE, CRA_SELECTED));
    555547      else
    556         WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    557                    MPFROM2SHORT(FALSE,CRA_SELECTED));
    558     }
    559     pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORD,MPFROMP(pci),
    560                                MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
     548        WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     549                   MPFROM2SHORT(FALSE, CRA_SELECTED));
     550    }
     551    pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
     552                                MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    561553  }
    562554}
    … …  
    565557#pragma alloc_text(SELECT4,FreeCnrs,SpecialSelect2,CompSSNames,CompSSNamesB)
    566558
    567 VOID SpecialSelect (HWND hwndCnrS,HWND hwndCnrD,INT action,BOOL reset)
    568 {
    569   PCNRITEM       pciS,pciD,*pciSa = NULL,*pciDa = NULL;
    570   CNRINFO        cnri;
    571   BOOL           slow = FALSE;
    572   register INT   x,numD,numS;
     559VOID SpecialSelect(HWND hwndCnrS, HWND hwndCnrD, INT action, BOOL reset)
     560{
     561  PCNRITEM pciS, pciD, *pciSa = NULL, *pciDa = NULL;
     562  CNRINFO cnri;
     563  BOOL slow = FALSE;
     564  register INT x, numD, numS;
    573565
    574566  if (!hwndCnrS || !hwndCnrD)
    575567    return;
    576568
    577   memset(&cnri,0,sizeof(CNRINFO));
     569  memset(&cnri, 0, sizeof(CNRINFO));
    578570  cnri.cb = sizeof(CNRINFO);
    579   WinSendMsg(hwndCnrD,CM_QUERYCNRINFO,MPFROMP(&cnri),
    580              MPFROMLONG(sizeof(CNRINFO)));
    581   numD = (INT)cnri.cRecords;
    582   memset(&cnri,0,sizeof(CNRINFO));
     571  WinSendMsg(hwndCnrD, CM_QUERYCNRINFO, MPFROMP(&cnri),
     572             MPFROMLONG(sizeof(CNRINFO)));
     573  numD = (INT) cnri.cRecords;
     574  memset(&cnri, 0, sizeof(CNRINFO));
    583575  cnri.cb = sizeof(CNRINFO);
    584   WinSendMsg(hwndCnrS,CM_QUERYCNRINFO,MPFROMP(&cnri),
    585              MPFROMLONG(sizeof(CNRINFO)));
    586   numS = (INT)cnri.cRecords;
     576  WinSendMsg(hwndCnrS, CM_QUERYCNRINFO, MPFROMP(&cnri),
     577             MPFROMLONG(sizeof(CNRINFO)));
     578  numS = (INT) cnri.cRecords;
    587579  if (!numD || numS != numD) {
    588580    saymsg(MB_ENTER,
    589            HWND_DESKTOP,
    590            DEBUG_STRING,
    591            "numD (%lu) != numS (%lu)",
    592            numD,
    593            numS);
     581           HWND_DESKTOP,
     582           DEBUG_STRING, "numD (%lu) != numS (%lu)", numD, numS);
    594583    return;
    595584  }
    596   pciDa = xmalloc(sizeof(PCNRITEM) * numD,pszSrcFile,__LINE__);
     585  pciDa = xmalloc(sizeof(PCNRITEM) * numD, pszSrcFile, __LINE__);
    597586  if (!pciDa)
    598587    return;
    599588
    600   pciSa = xmalloc(sizeof(PCNRITEM) * numS,pszSrcFile,__LINE__);
     589  pciSa = xmalloc(sizeof(PCNRITEM) * numS, pszSrcFile, __LINE__);
    601590  if (!pciSa) {
    602591    free(pciDa);
    … …  
    606595Restart:
    607596
    608   memset(pciDa,0,sizeof(PCNRITEM) * numD);
    609   memset(pciSa,0,sizeof(PCNRITEM) * numS);
    610 
    611   pciD = (PCNRITEM)WinSendMsg(hwndCnrD,CM_QUERYRECORD,MPVOID,
    612                               MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
     597  memset(pciDa, 0, sizeof(PCNRITEM) * numD);
     598  memset(pciSa, 0, sizeof(PCNRITEM) * numS);
     599
     600  pciD = (PCNRITEM) WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPVOID,
     601                               MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    613602  x = 0;
    614   while ( pciD && (INT)pciD != -1 && x < numD) {
     603  while (pciD && (INT) pciD != -1 && x < numD) {
    615604    if (reset)
    616605      pciD->flags = 0;
    … …  
    618607    x++;
    619608    if (!slow)
    620       pciD = (PCNRITEM)pciD->rc.preccNextRecord;
     609      pciD = (PCNRITEM) pciD->rc.preccNextRecord;
    621610    else
    622       pciD = (PCNRITEM)WinSendMsg(hwndCnrD,CM_QUERYRECORD,MPFROMP(pciD),
    623                                  MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
     611      pciD = (PCNRITEM) WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPFROMP(pciD),
     612                                   MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    624613    if (!(x % 500))
    625614      DosSleep(1L);
    … …  
    635624    free(pciSa);
    636625    saymsg(MB_ENTER,
    637            HWND_DESKTOP,
    638            DEBUG_STRING,
    639            "numD (%lu) != x (%lu)",
    640            numD,
    641            x);
     626           HWND_DESKTOP, DEBUG_STRING, "numD (%lu) != x (%lu)", numD, x);
    642627    return;
    643628  }
    644629
    645   pciS = (PCNRITEM)WinSendMsg(hwndCnrS,CM_QUERYRECORD,MPVOID,
    646                               MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
     630  pciS = (PCNRITEM) WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPVOID,
     631                               MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    647632  x = 0;
    648   while (pciS && (INT)pciS != -1 && x < numS) {
     633  while (pciS && (INT) pciS != -1 && x < numS) {
    649634    if (reset)
    650635      pciS->flags = 0;
    … …  
    652637    x++;
    653638    if (!slow)
    654       pciS = (PCNRITEM)pciS->rc.preccNextRecord;
     639      pciS = (PCNRITEM) pciS->rc.preccNextRecord;
    655640    else
    656       pciS = (PCNRITEM)WinSendMsg(hwndCnrS,CM_QUERYRECORD,MPFROMP(pciS),
    657                                  MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
     641      pciS = (PCNRITEM) WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPFROMP(pciS),
     642                                   MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    658643    if (!(x % 500))
    659644      DosSleep(1L);
    … …  
    668653    free(pciSa);
    669654    free(pciDa);
    670     Runtime_Error(pszSrcFile, __LINE__,
    671            "numS (%lu) != x (%lu)", numS, x);
     655    Runtime_Error(pszSrcFile, __LINE__, "numS (%lu) != x (%lu)", numS, x);
    672656    return;
    673657  }
    674658
    675659  if (reset) {
    676     for (x = 0;x < numS;x++) {
     660    for (x = 0; x < numS; x++) {
    677661      if (!*pciSa[x]->szFileName || !*pciDa[x]->szFileName)
    678         continue;
     662        continue;
    679663      pciSa[x]->flags |= CNRITEM_EXISTS;
    680664      pciDa[x]->flags |= CNRITEM_EXISTS;
    681665      if (pciSa[x]->cbFile + pciSa[x]->easize >
    682          pciDa[x]->cbFile + pciDa[x]->easize) {
    683         pciSa[x]->flags |= CNRITEM_LARGER;
    684         pciDa[x]->flags |= CNRITEM_SMALLER;
     666          pciDa[x]->cbFile + pciDa[x]->easize) {
     667        pciSa[x]->flags |= CNRITEM_LARGER;
     668        pciDa[x]->flags |= CNRITEM_SMALLER;
    685669      }
    686670      else if (pciSa[x]->cbFile + pciSa[x]->easize <
    687               pciDa[x]->cbFile + pciDa[x]->easize) {
    688         pciSa[x]->flags |= CNRITEM_SMALLER;
    689         pciDa[x]->flags |= CNRITEM_LARGER;
     671               pciDa[x]->cbFile + pciDa[x]->easize) {
     672        pciSa[x]->flags |= CNRITEM_SMALLER;
     673        pciDa[x]->flags |= CNRITEM_LARGER;
    690674      }
    691675      if ((pciSa[x]->date.year > pciDa[x]->date.year) ? TRUE :
    692          (pciSa[x]->date.year < pciDa[x]->date.year) ? FALSE :
    693          (pciSa[x]->date.month > pciDa[x]->date.month) ? TRUE :
    694          (pciSa[x]->date.month < pciDa[x]->date.month) ? FALSE :
    695          (pciSa[x]->date.day > pciDa[x]->date.day) ? TRUE :
    696          (pciSa[x]->date.day < pciDa[x]->date.day) ? FALSE :
    697          (pciSa[x]->time.hours > pciDa[x]->time.hours) ? TRUE :
    698          (pciSa[x]->time.hours < pciDa[x]->time.hours) ? FALSE :
    699          (pciSa[x]->time.minutes > pciDa[x]->time.minutes) ? TRUE :
    700          (pciSa[x]->time.minutes < pciDa[x]->time.minutes) ? FALSE :
    701          (pciSa[x]->time.seconds > pciDa[x]->time.seconds) ? TRUE :
    702          (pciSa[x]->time.seconds < pciDa[x]->time.seconds) ? FALSE : FALSE) {
    703         pciSa[x]->flags |= CNRITEM_NEWER;
    704         pciDa[x]->flags |= CNRITEM_OLDER;
     676          (pciSa[x]->date.year < pciDa[x]->date.year) ? FALSE :
     677          (pciSa[x]->date.month > pciDa[x]->date.month) ? TRUE :
     678          (pciSa[x]->date.month < pciDa[x]->date.month) ? FALSE :
     679          (pciSa[x]->date.day > pciDa[x]->date.day) ? TRUE :
     680          (pciSa[x]->date.day < pciDa[x]->date.day) ? FALSE :
     681          (pciSa[x]->time.hours > pciDa[x]->time.hours) ? TRUE :
     682          (pciSa[x]->time.hours < pciDa[x]->time.hours) ? FALSE :
     683          (pciSa[x]->time.minutes > pciDa[x]->time.minutes) ? TRUE :
     684          (pciSa[x]->time.minutes < pciDa[x]->time.minutes) ? FALSE :
     685          (pciSa[x]->time.seconds > pciDa[x]->time.seconds) ? TRUE :
     686          (pciSa[x]->time.seconds < pciDa[x]->time.seconds) ? FALSE : FALSE) {
     687        pciSa[x]->flags |= CNRITEM_NEWER;
     688        pciDa[x]->flags |= CNRITEM_OLDER;
    705689      }
    706690      else if ((pciSa[x]->date.year < pciDa[x]->date.year) ? TRUE :
    707               (pciSa[x]->date.year > pciDa[x]->date.year) ? FALSE :
    708               (pciSa[x]->date.month < pciDa[x]->date.month) ? TRUE :
    709               (pciSa[x]->date.month > pciDa[x]->date.month) ? FALSE :
    710               (pciSa[x]->date.day < pciDa[x]->date.day) ? TRUE :
    711               (pciSa[x]->date.day > pciDa[x]->date.day) ? FALSE :
    712               (pciSa[x]->time.hours < pciDa[x]->time.hours) ? TRUE :
    713               (pciSa[x]->time.hours > pciDa[x]->time.hours) ? FALSE :
    714               (pciSa[x]->time.minutes < pciDa[x]->time.minutes) ? TRUE :
    715               (pciSa[x]->time.minutes > pciDa[x]->time.minutes) ? FALSE :
    716               (pciSa[x]->time.seconds < pciDa[x]->time.seconds) ? TRUE :
    717               (pciSa[x]->time.seconds > pciDa[x]->time.seconds) ? FALSE :
    718               FALSE) {
    719         pciSa[x]->flags |= CNRITEM_OLDER;
    720         pciDa[x]->flags |= CNRITEM_NEWER;
     691               (pciSa[x]->date.year > pciDa[x]->date.year) ? FALSE :
     692               (pciSa[x]->date.month < pciDa[x]->date.month) ? TRUE :
     693               (pciSa[x]->date.month > pciDa[x]->date.month) ? FALSE :
     694               (pciSa[x]->date.day < pciDa[x]->date.day) ? TRUE :
     695               (pciSa[x]->date.day > pciDa[x]->date.day) ? FALSE :
     696               (pciSa[x]->time.hours < pciDa[x]->time.hours) ? TRUE :
     697               (pciSa[x]->time.hours > pciDa[x]->time.hours) ? FALSE :
     698               (pciSa[x]->time.minutes < pciDa[x]->time.minutes) ? TRUE :
     699               (pciSa[x]->time.minutes > pciDa[x]->time.minutes) ? FALSE :
     700               (pciSa[x]->time.seconds < pciDa[x]->time.seconds) ? TRUE :
     701               (pciSa[x]->time.seconds > pciDa[x]->time.seconds) ? FALSE :
     702               FALSE) {
     703        pciSa[x]->flags |= CNRITEM_OLDER;
     704        pciDa[x]->flags |= CNRITEM_NEWER;
    721705      }
    722706      if (!(x % 500))
    723         DosSleep(1L);
     707        DosSleep(1L);
    724708      else if (!(x % 50))
    725         DosSleep(0L);
    726     }
    727   }
    728 
    729   switch(action) {
    730     case IDM_SELECTIDENTICAL:
    731       for (x = 0;x < numS;x++) {
    732         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED)) {
    733           if (*pciSa[x]->szFileName &&
    734              (pciSa[x]->flags & CNRITEM_EXISTS) &&
    735              !(pciSa[x]->flags & CNRITEM_SMALLER) &&
    736              !(pciSa[x]->flags & CNRITEM_LARGER) &&
    737              !(pciSa[x]->flags & CNRITEM_NEWER) &&
    738              !(pciSa[x]->flags & CNRITEM_OLDER)) {
    739             if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    740               WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    741                          MPFROM2SHORT(TRUE,CRA_SELECTED));
    742             if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    743               WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    744                          MPFROM2SHORT(TRUE,CRA_SELECTED));
    745           }
    746           if (!(x % 500))
    747             DosSleep(1L);
    748           else if (!(x % 50))
    749             DosSleep(0L);
    750         }
    751       }
    752       break;
    753 
    754     case IDM_SELECTSAME:
    755       for (x = 0;x < numS;x++) {
    756         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    757            *pciSa[x]->szFileName &&
    758            (pciSa[x]->flags & CNRITEM_EXISTS) &&
    759            !(pciSa[x]->flags & CNRITEM_SMALLER) &&
    760            !(pciSa[x]->flags & CNRITEM_LARGER)) {
    761           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    762             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    763                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    764           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    765             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    766                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    767         }
    768         if (!(x % 500))
    769           DosSleep(1L);
    770         else if (!(x % 50))
    771           DosSleep(0L);
    772       }
    773       break;
    774 
    775     case IDM_SELECTSAMECONTENT:
    776       // fixme
    777       for (x = 0;x < numS;x++) {
    778         if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
    779             *pciSa[x]->szFileName &&
    780             *pciDa[x]->szFileName &&
    781             pciSa[x]->flags & CNRITEM_EXISTS &&
    782             pciDa[x]->flags & CNRITEM_EXISTS) {
    783 
    784           FILE *fp1 = NULL;
    785           FILE *fp2 = NULL;
    786           BOOL gotMatch = FALSE;
    787           UINT errLineNo = 0;
    788           UINT compErrno = 0;
    789           CHAR buf1[1024];
    790           CHAR buf2[1024];
    791           HAB hab = WinQueryAnchorBlock(hwndCnrS);
    792 
    793           fp1 = _fsopen(pciSa[x]->szFileName,"rb",SH_DENYNO);
    794           if (!fp1) {
     709        DosSleep(0L);
     710    }
     711  }
     712
     713  switch (action) {
     714  case IDM_SELECTIDENTICAL:
     715    for (x = 0; x < numS; x++) {
     716      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED)) {
     717        if (*pciSa[x]->szFileName &&
     718            (pciSa[x]->flags & CNRITEM_EXISTS) &&
     719            !(pciSa[x]->flags & CNRITEM_SMALLER) &&
     720            !(pciSa[x]->flags & CNRITEM_LARGER) &&
     721            !(pciSa[x]->flags & CNRITEM_NEWER) &&
     722            !(pciSa[x]->flags & CNRITEM_OLDER)) {
     723          if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     724            WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     725                       MPFROM2SHORT(TRUE, CRA_SELECTED));
     726          if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     727            WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     728                       MPFROM2SHORT(TRUE, CRA_SELECTED));
     729        }
     730        if (!(x % 500))
     731          DosSleep(1L);
     732        else if (!(x % 50))
     733          DosSleep(0L);
     734      }
     735    }
     736    break;
     737
     738  case IDM_SELECTSAME:
     739    for (x = 0; x < numS; x++) {
     740      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     741          *pciSa[x]->szFileName &&
     742          (pciSa[x]->flags & CNRITEM_EXISTS) &&
     743          !(pciSa[x]->flags & CNRITEM_SMALLER) &&
     744          !(pciSa[x]->flags & CNRITEM_LARGER)) {
     745        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     746          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     747                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     748        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     749          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     750                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     751      }
     752      if (!(x % 500))
     753        DosSleep(1L);
     754      else if (!(x % 50))
     755        DosSleep(0L);
     756    }
     757    break;
     758
     759  case IDM_SELECTSAMECONTENT:
     760    // fixme
     761    for (x = 0; x < numS; x++) {
     762      if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
     763          *pciSa[x]->szFileName &&
     764          *pciDa[x]->szFileName &&
     765          pciSa[x]->flags & CNRITEM_EXISTS &&
     766          pciDa[x]->flags & CNRITEM_EXISTS) {
     767
     768        FILE *fp1 = NULL;
     769        FILE *fp2 = NULL;
     770        BOOL gotMatch = FALSE;
     771        UINT errLineNo = 0;
     772        UINT compErrno = 0;
     773        CHAR buf1[1024];
     774        CHAR buf2[1024];
     775        HAB hab = WinQueryAnchorBlock(hwndCnrS);
     776
     777        fp1 = _fsopen(pciSa[x]->szFileName, "rb", SH_DENYNO);
     778        if (!fp1) {
     779          errLineNo = __LINE__;
     780          compErrno = errno;
     781        }
     782        else {
     783          fp2 = _fsopen(pciDa[x]->szFileName, "rb", SH_DENYNO);
     784          if (!fp2) {
    795785            errLineNo = __LINE__;
    796786            compErrno = errno;
    797787          }
    798788          else {
    799             fp2 = _fsopen(pciDa[x]->szFileName,"rb",SH_DENYNO);
    800             if (!fp2) {
    801               errLineNo = __LINE__;
    802               compErrno = errno;
    803             }
    804             else {
    805               size_t len1 = filelength(fileno(fp1));
    806               size_t len2 = filelength(fileno(fp2));
    807               if (len1 == len2) {
    808                 setbuf(fp1, NULL);
    809                 setbuf(fp2, NULL);
    810                 while (WinIsWindow(hab,hwndCnrS)) {
    811                   size_t numread1 = fread(buf1,1,1024,fp1);
    812                   size_t numread2 = fread(buf2,1,1024,fp2);
    813                   if (!numread1 || !numread2 || numread1 != numread2) {
    814                     if (ferror(fp1) || ferror(fp2)) {
    815                       errLineNo = __LINE__;
    816                       compErrno = errno;
    817                     }
    818                     else if (feof(fp1) && feof(fp2))
    819                       gotMatch = TRUE;
    820                     break;
     789            size_t len1 = filelength(fileno(fp1));
     790            size_t len2 = filelength(fileno(fp2));
     791
     792            if (len1 == len2) {
     793              setbuf(fp1, NULL);
     794              setbuf(fp2, NULL);
     795              while (WinIsWindow(hab, hwndCnrS)) {
     796                size_t numread1 = fread(buf1, 1, 1024, fp1);
     797                size_t numread2 = fread(buf2, 1, 1024, fp2);
     798
     799                if (!numread1 || !numread2 || numread1 != numread2) {
     800                  if (ferror(fp1) || ferror(fp2)) {
     801                    errLineNo = __LINE__;
     802                    compErrno = errno;
    821803                  }
    822                   else if (memcmp(buf1,buf2,numread1))
    823                     break;
    824                 } // while
    825               } // same len
    826             }
    827           }
    828 
    829           if (fp1)
    830             fclose(fp1);
    831 
    832           if (fp2)
    833             fclose(fp2);
    834 
    835           if (errLineNo) {
    836             Runtime_Error(pszSrcFile, errLineNo,
    837                          "error %d while comparing", compErrno);
     804                  else if (feof(fp1) && feof(fp2))
     805                    gotMatch = TRUE;
     806                  break;
     807                }
     808                else if (memcmp(buf1, buf2, numread1))
     809                  break;
     810              }                         // while
     811            }                           // same len
    838812          }
    839           if (gotMatch) {
    840             if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    841               WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    842                          MPFROM2SHORT(TRUE,CRA_SELECTED));
    843             if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    844               WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    845                          MPFROM2SHORT(TRUE,CRA_SELECTED));
    846           }
    847         }
    848         if (!(x % 500))
    849           DosSleep(1L);
    850         else if (!(x % 50))
    851           DosSleep(0L);
    852       } // for records
    853       break;
    854 
    855     case IDM_SELECTBOTH:
    856       for (x = 0;x < numS;x++) {
    857         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    858            *pciSa[x]->szFileName &&
    859            (pciSa[x]->flags & CNRITEM_EXISTS)) {
    860           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    861             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    862                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    863           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    864             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    865                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    866         }
    867         if (!(x % 500))
    868           DosSleep(1L);
    869         else if (!(x % 50))
    870           DosSleep(0L);
    871       }
    872       break;
    873 
    874     case IDM_SELECTONE:
    875       for (x = 0;x < numS;x++) {
    876         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    877            *pciSa[x]->szFileName &&
    878            !(pciSa[x]->flags & CNRITEM_EXISTS)) {
    879           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    880             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    881                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    882         }
    883         else if (*pciDa[x]->szFileName &&
    884                 !(pciDa[x]->flags & CNRITEM_EXISTS)) {
    885           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    886             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    887                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    888         }
    889         if (!(x % 500))
    890           DosSleep(1L);
    891         else if (!(x % 50))
    892           DosSleep(0L);
    893       }
    894       break;
    895 
    896     case IDM_SELECTBIGGER:
    897       for (x = 0;x < numS;x++) {
    898         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    899            *pciSa[x]->szFileName &&
    900            (pciSa[x]->flags & CNRITEM_LARGER)) {
    901           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    902             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    903                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    904         }
    905         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    906                 *pciDa[x]->szFileName &&
    907                 (pciDa[x]->flags & CNRITEM_LARGER)) {
    908           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    909             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    910                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    911         }
    912         if (!(x % 500))
    913           DosSleep(1L);
    914         else if (!(x % 50))
    915           DosSleep(0L);
    916       }
    917       break;
    918 
    919     case IDM_SELECTSMALLER:
    920       for (x = 0;x < numS;x++) {
    921         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    922            *pciSa[x]->szFileName &&
    923            (pciSa[x]->flags & CNRITEM_SMALLER)) {
    924           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    925             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    926                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    927         }
    928         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    929                 *pciDa[x]->szFileName &&
    930                 (pciDa[x]->flags & CNRITEM_SMALLER)) {
    931           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    932             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    933                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    934         }
    935         if (!(x % 500))
    936           DosSleep(1L);
    937         else if (!(x % 50))
    938           DosSleep(0L);
    939       }
    940       break;
    941 
    942     case IDM_SELECTNEWER:
    943       for (x = 0;x < numS;x++) {
    944         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    945            *pciSa[x]->szFileName &&
    946            (pciSa[x]->flags & CNRITEM_NEWER)) {
    947           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    948             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    949                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    950         }
    951         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    952                 *pciDa[x]->szFileName &&
    953                 (pciDa[x]->flags & CNRITEM_NEWER)) {
    954           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    955             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    956                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    957         }
    958         if (!(x % 500))
    959           DosSleep(1L);
    960         else if (!(x % 50))
    961           DosSleep(0L);
    962       }
    963       break;
    964 
    965     case IDM_SELECTOLDER:
    966       for (x = 0;x < numS;x++) {
    967         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    968            *pciSa[x]->szFileName &&
    969            (pciSa[x]->flags & CNRITEM_OLDER)) {
    970           if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
    971             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    972                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    973         }
    974         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    975                 *pciDa[x]->szFileName &&
    976                 (pciDa[x]->flags & CNRITEM_OLDER)) {
    977           if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
    978             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    979                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    980         }
    981         if (!(x % 500))
    982           DosSleep(1L);
    983         else if (!(x % 50))
    984           DosSleep(0L);
    985       }
    986       break;
    987 
    988     case IDM_DESELECTBOTH:
    989       for (x = 0;x < numS;x++) {
    990         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    991            *pciSa[x]->szFileName &&
    992            (pciSa[x]->flags & CNRITEM_EXISTS)) {
    993           if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    994             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    995                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    996           if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    997             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    998                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    999         }
    1000         if (!(x % 500))
    1001           DosSleep(1L);
    1002         else if (!(x % 50))
    1003           DosSleep(0L);
    1004       }
    1005       break;
    1006 
    1007     case IDM_DESELECTONE:
    1008       for (x = 0;x < numS;x++) {
    1009         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1010            *pciSa[x]->szFileName &&
    1011            !(pciSa[x]->flags & CNRITEM_EXISTS)) {
    1012           if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    1013             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    1014                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1015         }
    1016         else if (*pciDa[x]->szFileName &&
    1017                 !(pciDa[x]->flags & CNRITEM_EXISTS)) {
    1018           if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    1019             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    1020                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1021         }
    1022         if (!(x % 500))
    1023           DosSleep(1L);
    1024         else if (!(x % 50))
    1025           DosSleep(0L);
    1026       }
    1027       break;
    1028 
    1029     case IDM_DESELECTBIGGER:
    1030       for (x = 0;x < numS;x++) {
    1031         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1032            *pciSa[x]->szFileName &&
    1033            (pciSa[x]->flags & CNRITEM_LARGER)) {
    1034           if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    1035             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    1036                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1037         }
    1038         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1039                 *pciDa[x]->szFileName &&
    1040                 (pciDa[x]->flags & CNRITEM_LARGER)) {
    1041           if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    1042             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    1043                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1044         }
    1045         if (!(x % 500))
    1046           DosSleep(1L);
    1047         else if (!(x % 50))
    1048           DosSleep(0L);
    1049       }
    1050       break;
    1051 
    1052     case IDM_DESELECTSMALLER:
    1053       for (x = 0;x < numS;x++) {
    1054         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1055            *pciSa[x]->szFileName &&
    1056            (pciSa[x]->flags & CNRITEM_SMALLER)) {
    1057           if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    1058             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    1059                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1060         }
    1061         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1062                 *pciDa[x]->szFileName &&
    1063                 (pciDa[x]->flags & CNRITEM_SMALLER)) {
    1064           if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    1065             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    1066                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1067         }
    1068         if (!(x % 500))
    1069           DosSleep(1L);
    1070         else if (!(x % 50))
    1071           DosSleep(0L);
    1072       }
    1073       break;
    1074 
    1075     case IDM_DESELECTNEWER:
    1076       for (x = 0;x < numS;x++) {
    1077         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1078            *pciSa[x]->szFileName &&
    1079            (pciSa[x]->flags & CNRITEM_NEWER)) {
    1080           if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    1081             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    1082                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1083         }
    1084         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1085                 *pciDa[x]->szFileName &&
    1086                 (pciDa[x]->flags & CNRITEM_NEWER)) {
    1087           if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    1088             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    1089                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1090         }
    1091         if (!(x % 500))
    1092           DosSleep(1L);
    1093         else if (!(x % 50))
    1094           DosSleep(0L);
    1095       }
    1096       break;
    1097 
    1098     case IDM_DESELECTOLDER:
    1099       for (x = 0;x < numS;x++) {
    1100         if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1101            *pciSa[x]->szFileName &&
    1102            (pciSa[x]->flags & CNRITEM_OLDER)) {
    1103           if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
    1104             WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pciSa[x]),
    1105                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1106         }
    1107         else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
    1108                 *pciDa[x]->szFileName &&
    1109                 (pciDa[x]->flags & CNRITEM_OLDER)) {
    1110           if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
    1111             WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciDa[x]),
    1112                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1113         }
    1114         if (!(x % 500))
    1115           DosSleep(1L);
    1116         else if (!(x % 50))
    1117           DosSleep(0L);
    1118       }
    1119       break;
    1120 
    1121     default:
    1122       break;
     813        }
     814
     815        if (fp1)
     816          fclose(fp1);
     817
     818        if (fp2)
     819          fclose(fp2);
     820
     821        if (errLineNo) {
     822          Runtime_Error(pszSrcFile, errLineNo,
     823                        "error %d while comparing", compErrno);
     824        }
     825        if (gotMatch) {
     826          if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     827            WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     828                       MPFROM2SHORT(TRUE, CRA_SELECTED));
     829          if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     830            WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     831                       MPFROM2SHORT(TRUE, CRA_SELECTED));
     832        }
     833      }
     834      if (!(x % 500))
     835        DosSleep(1L);
     836      else if (!(x % 50))
     837        DosSleep(0L);
     838    }                                   // for records
     839    break;
     840
     841  case IDM_SELECTBOTH:
     842    for (x = 0; x < numS; x++) {
     843      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     844          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
     845        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     846          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     847                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     848        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     849          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     850                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     851      }
     852      if (!(x % 500))
     853        DosSleep(1L);
     854      else if (!(x % 50))
     855        DosSleep(0L);
     856    }
     857    break;
     858
     859  case IDM_SELECTONE:
     860    for (x = 0; x < numS; x++) {
     861      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     862          *pciSa[x]->szFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
     863        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     864          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     865                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     866      }
     867      else if (*pciDa[x]->szFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
     868        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     869          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     870                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     871      }
     872      if (!(x % 500))
     873        DosSleep(1L);
     874      else if (!(x % 50))
     875        DosSleep(0L);
     876    }
     877    break;
     878
     879  case IDM_SELECTBIGGER:
     880    for (x = 0; x < numS; x++) {
     881      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     882          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
     883        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     884          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     885                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     886      }
     887      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     888               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
     889        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     890          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     891                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     892      }
     893      if (!(x % 500))
     894        DosSleep(1L);
     895      else if (!(x % 50))
     896        DosSleep(0L);
     897    }
     898    break;
     899
     900  case IDM_SELECTSMALLER:
     901    for (x = 0; x < numS; x++) {
     902      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     903          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
     904        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     905          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     906                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     907      }
     908      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     909               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
     910        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     911          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     912                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     913      }
     914      if (!(x % 500))
     915        DosSleep(1L);
     916      else if (!(x % 50))
     917        DosSleep(0L);
     918    }
     919    break;
     920
     921  case IDM_SELECTNEWER:
     922    for (x = 0; x < numS; x++) {
     923      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     924          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
     925        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     926          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     927                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     928      }
     929      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     930               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
     931        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     932          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     933                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     934      }
     935      if (!(x % 500))
     936        DosSleep(1L);
     937      else if (!(x % 50))
     938        DosSleep(0L);
     939    }
     940    break;
     941
     942  case IDM_SELECTOLDER:
     943    for (x = 0; x < numS; x++) {
     944      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     945          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
     946        if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
     947          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     948                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     949      }
     950      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     951               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
     952        if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
     953          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     954                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     955      }
     956      if (!(x % 500))
     957        DosSleep(1L);
     958      else if (!(x % 50))
     959        DosSleep(0L);
     960    }
     961    break;
     962
     963  case IDM_DESELECTBOTH:
     964    for (x = 0; x < numS; x++) {
     965      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     966          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
     967        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
     968          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     969                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     970        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
     971          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     972                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     973      }
     974      if (!(x % 500))
     975        DosSleep(1L);
     976      else if (!(x % 50))
     977        DosSleep(0L);
     978    }
     979    break;
     980
     981  case IDM_DESELECTONE:
     982    for (x = 0; x < numS; x++) {
     983      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     984          *pciSa[x]->szFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
     985        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
     986          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     987                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     988      }
     989      else if (*pciDa[x]->szFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
     990        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
     991          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     992                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     993      }
     994      if (!(x % 500))
     995        DosSleep(1L);
     996      else if (!(x % 50))
     997        DosSleep(0L);
     998    }
     999    break;
     1000
     1001  case IDM_DESELECTBIGGER:
     1002    for (x = 0; x < numS; x++) {
     1003      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1004          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
     1005        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
     1006          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     1007                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1008      }
     1009      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1010               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
     1011        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
     1012          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     1013                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1014      }
     1015      if (!(x % 500))
     1016        DosSleep(1L);
     1017      else if (!(x % 50))
     1018        DosSleep(0L);
     1019    }
     1020    break;
     1021
     1022  case IDM_DESELECTSMALLER:
     1023    for (x = 0; x < numS; x++) {
     1024      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1025          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
     1026        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
     1027          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     1028                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1029      }
     1030      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1031               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
     1032        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
     1033          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     1034                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1035      }
     1036      if (!(x % 500))
     1037        DosSleep(1L);
     1038      else if (!(x % 50))
     1039        DosSleep(0L);
     1040    }
     1041    break;
     1042
     1043  case IDM_DESELECTNEWER:
     1044    for (x = 0; x < numS; x++) {
     1045      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1046          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
     1047        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
     1048          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     1049                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1050      }
     1051      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1052               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
     1053        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
     1054          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     1055                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1056      }
     1057      if (!(x % 500))
     1058        DosSleep(1L);
     1059      else if (!(x % 50))
     1060        DosSleep(0L);
     1061    }
     1062    break;
     1063
     1064  case IDM_DESELECTOLDER:
     1065    for (x = 0; x < numS; x++) {
     1066      if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1067          *pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
     1068        if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
     1069          WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
     1070                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1071      }
     1072      else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
     1073               *pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
     1074        if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
     1075          WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
     1076                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1077      }
     1078      if (!(x % 500))
     1079        DosSleep(1L);
     1080      else if (!(x % 50))
     1081        DosSleep(0L);
     1082    }
     1083    break;
     1084
     1085  default:
     1086    break;
    11231087  }
    11241088
    11251089  if (reset) {
    11261090    while (numS) {
    1127       WinSendMsg(hwndCnrS,CM_INVALIDATERECORD,
    1128                  MPFROMP(pciSa),
    1129                  MPFROM2SHORT((min(numS,65535)),0));
    1130       DosSleep(0L);
    1131       WinSendMsg(hwndCnrD,CM_INVALIDATERECORD,
    1132                  MPFROMP(pciDa),
    1133                  MPFROM2SHORT((min(numD,65535)),0));
    1134       numS -= min(numS,65535);
     1091      WinSendMsg(hwndCnrS, CM_INVALIDATERECORD,
     1092                 MPFROMP(pciSa), MPFROM2SHORT((min(numS, 65535)), 0));
     1093      DosSleep(0L);
     1094      WinSendMsg(hwndCnrD, CM_INVALIDATERECORD,
     1095                 MPFROMP(pciDa), MPFROM2SHORT((min(numD, 65535)), 0));
     1096      numS -= min(numS, 65535);
    11351097      if (numS)
    1136         DosSleep(0L);
     1098        DosSleep(0L);
    11371099    }
    11381100  }
    … …  
    11431105}
    11441106
    1145 struct SS {
    1146   PCNRITEM  pci;
    1147   BOOL      unique,
    1148             all,
    1149             smallest,
    1150             largest,
    1151             newest,
    1152             oldest;
     1107struct SS
     1108{
     1109  PCNRITEM pci;
     1110  BOOL unique, all, smallest, largest, newest, oldest;
    11531111};
    11541112
    1155 struct Cnr {
    1156   HWND       hwndCnr;
    1157   ULONG      numfiles;
     1113struct Cnr
     1114{
     1115  HWND hwndCnr;
     1116  ULONG numfiles;
    11581117  struct SS *ss;
    11591118};
    11601119
    1161 static int CompSSNamesB (const void *s1,const void *s2)
     1120static int CompSSNamesB(const void *s1, const void *s2)
    11621121{
    11631122  struct SS *ss2 = (struct SS *)s2;
    11641123
    1165   return stricmp((CHAR *)s1,ss2->pci->pszFileName);
    1166 }
    1167 
    1168 static int CompSSNames (const void *s1,const void *s2)
     1124  return stricmp((CHAR *) s1, ss2->pci->pszFileName);
     1125}
     1126
     1127static int CompSSNames(const void *s1, const void *s2)
    11691128{
    11701129  struct SS *ss1 = (struct SS *)s1;
    11711130  struct SS *ss2 = (struct SS *)s2;
    11721131
    1173   return stricmp(ss1->pci->pszFileName,ss2->pci->pszFileName);
    1174 }
    1175 
    1176 VOID FreeCnrs (struct Cnr *Cnrs,INT numw)
     1132  return stricmp(ss1->pci->pszFileName, ss2->pci->pszFileName);
     1133}
     1134
     1135VOID FreeCnrs(struct Cnr * Cnrs, INT numw)
    11771136{
    11781137  register INT z;
    11791138
    1180   for (z = 0;z < numw;z++) {
     1139  for (z = 0; z < numw; z++) {
    11811140    if (Cnrs[z].ss)
    11821141      free(Cnrs[z].ss);
    … …  
    11861145}
    11871146
    1188 VOID SpecialSelect2 (HWND hwndParent,INT action)
    1189 {
    1190   PCNRITEM     pci;
    1191   HENUM        henum;
    1192   HWND         hwnd;
    1193   register INT numwindows = 0,w,x,z,cmp;
    1194   struct Cnr  *Cnrs = NULL;
    1195   struct SS  *bsres;
     1147VOID SpecialSelect2(HWND hwndParent, INT action)
     1148{
     1149  PCNRITEM pci;
     1150  HENUM henum;
     1151  HWND hwnd;
     1152  register INT numwindows = 0, w, x, z, cmp;
     1153  struct Cnr *Cnrs = NULL;
     1154  struct SS *bsres;
    11961155
    11971156  if (!hwndParent)
    … …  
    12011160  henum = WinBeginEnumWindows(hwndParent);
    12021161  while ((hwnd = WinGetNextWindow(henum)) != NULLHANDLE) {
    1203     if (WinWindowFromID(WinWindowFromID(hwnd,FID_CLIENT),DIR_CNR)) {
    1204       Cnrs = xrealloc(Cnrs,(numwindows + 1) * sizeof(struct Cnr),pszSrcFile,__LINE__);
     1162    if (WinWindowFromID(WinWindowFromID(hwnd, FID_CLIENT), DIR_CNR)) {
     1163      Cnrs =
     1164        xrealloc(Cnrs, (numwindows + 1) * sizeof(struct Cnr), pszSrcFile,
     1165                 __LINE__);
    12051166      if (!Cnrs) {
    1206         Notify(GetPString(IDS_OUTOFMEMORY));
    1207         return;
    1208       }
    1209       memset(&Cnrs[numwindows],0,sizeof(struct Cnr));
     1167        Notify(GetPString(IDS_OUTOFMEMORY));
     1168        return;
     1169      }
     1170      memset(&Cnrs[numwindows], 0, sizeof(struct Cnr));
    12101171      Cnrs[numwindows].hwndCnr = WinWindowFromID(WinWindowFromID(hwnd,
    1211                                                  FID_CLIENT),DIR_CNR);
     1172                                                                 FID_CLIENT),
     1173                                                 DIR_CNR);
    12121174      numwindows++;
    12131175    }
    … …  
    12151177  WinEndEnumWindows(henum);
    12161178  if (numwindows < 2) {
    1217     FreeCnrs(Cnrs,numwindows);
     1179    FreeCnrs(Cnrs, numwindows);
    12181180    Runtime_Error(pszSrcFile, __LINE__, "expected two windows");
    12191181    // fixme DosBeep(250,100);
    … …  
    12231185  if (numwindows > 4) {
    12241186    WinSendMsg(Cnrs[0].
    1225                hwndCnr,
    1226                UM_NOTIFY,
    1227                MPFROMP(GetPString(IDS_BUILDINGLISTSTEXT)),
    1228                MPVOID);
     1187               hwndCnr,
     1188               UM_NOTIFY, MPFROMP(GetPString(IDS_BUILDINGLISTSTEXT)), MPVOID);
    12291189    DosSleep(0L);
    12301190  }
    12311191
    12321192  /* count records, build array of pointers to records */
    1233   for (z = 0;z < numwindows;z++) {
    1234     pci = (PCNRITEM)WinSendMsg(Cnrs[z].hwndCnr,
    1235                                CM_QUERYRECORD,
    1236                                MPVOID,
    1237                                MPFROM2SHORT(CMA_FIRST,
    1238                                             CMA_ITEMORDER));
     1193  for (z = 0; z < numwindows; z++) {
     1194    pci = (PCNRITEM) WinSendMsg(Cnrs[z].hwndCnr,
     1195                                CM_QUERYRECORD,
     1196                                MPVOID,
     1197                                MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    12391198    x = 0;
    1240     while (pci && (INT)pci != -1) {
     1199    while (pci && (INT) pci != -1) {
    12411200      if (!(pci->rc.flRecordAttr & CRA_FILTERED) &&
    1242          !(pci->attrFile & FILE_DIRECTORY)) {
    1243         Cnrs[z].ss = xrealloc(Cnrs[z].ss,(x + 1) * sizeof(struct SS),pszSrcFile,__LINE__);
    1244         if (!Cnrs[z].ss) {
    1245           FreeCnrs(Cnrs,numwindows);
    1246           Notify(GetPString(IDS_OUTOFMEMORY));
    1247           return;
    1248         }
    1249         memset(&Cnrs[z].ss[x],0,sizeof(struct SS));
    1250         Cnrs[z].ss[x].pci = pci;
    1251         x++;
    1252       }
    1253       pci = (PCNRITEM)WinSendMsg(Cnrs[z].hwndCnr,
    1254                                  CM_QUERYRECORD,
    1255                                  MPFROMP(pci),
    1256                                  MPFROM2SHORT(CMA_NEXT,
    1257                                               CMA_ITEMORDER));
     1201          !(pci->attrFile & FILE_DIRECTORY)) {
     1202        Cnrs[z].ss =
     1203          xrealloc(Cnrs[z].ss, (x + 1) * sizeof(struct SS), pszSrcFile,
     1204                   __LINE__);
     1205        if (!Cnrs[z].ss) {
     1206          FreeCnrs(Cnrs, numwindows);
     1207          Notify(GetPString(IDS_OUTOFMEMORY));
     1208          return;
     1209        }
     1210        memset(&Cnrs[z].ss[x], 0, sizeof(struct SS));
     1211        Cnrs[z].ss[x].pci = pci;
     1212        x++;
     1213      }
     1214      pci = (PCNRITEM) WinSendMsg(Cnrs[z].hwndCnr,
     1215                                  CM_QUERYRECORD,
     1216                                  MPFROMP(pci),
     1217                                  MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    12581218    }
    12591219    DosSleep(0L);
    12601220    Cnrs[z].numfiles = x;
    12611221    if (Cnrs[z].numfiles)
    1262       qsort(Cnrs[z].ss,Cnrs[z].numfiles,sizeof(struct SS),CompSSNames);
    1263   }
    1264 
    1265   for (z = 0;z < numwindows;z++) {
    1266     for (x = 0;x < Cnrs[z].numfiles;x++) {
     1222      qsort(Cnrs[z].ss, Cnrs[z].numfiles, sizeof(struct SS), CompSSNames);
     1223  }
     1224
     1225  for (z = 0; z < numwindows; z++) {
     1226    for (x = 0; x < Cnrs[z].numfiles; x++) {
    12671227      Cnrs[z].ss[x].all = Cnrs[z].ss[x].unique = Cnrs[z].ss[x].newest =
    1268         Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].smallest =
    1269         Cnrs[z].ss[x].largest = TRUE;
    1270       for (w = 0;w < numwindows;w++) {
    1271         if (w != z && Cnrs[w].numfiles) {
    1272           bsres = (struct SS *)bsearch(Cnrs[z].ss[x].pci->pszFileName,
    1273                                         Cnrs[w].ss,Cnrs[w].numfiles,
    1274                                         sizeof(struct SS),CompSSNamesB);
    1275           if (bsres) {
    1276             Cnrs[z].ss[x].unique = FALSE;
    1277             if (Cnrs[z].ss[x].pci->cbFile + Cnrs[z].ss[x].pci->easize >
    1278                bsres->pci->cbFile + bsres->pci->easize)
    1279               Cnrs[z].ss[x].smallest = FALSE;
    1280             if (Cnrs[z].ss[x].pci->cbFile + Cnrs[z].ss[x].pci->easize <
    1281                bsres->pci->cbFile + bsres->pci->easize)
    1282               Cnrs[z].ss[x].largest = FALSE;
    1283             cmp = (Cnrs[z].ss[x].pci->date.year > bsres->pci->date.year) ? TRUE :
    1284                   (Cnrs[z].ss[x].pci->date.year < bsres->pci->date.year) ? FALSE :
    1285                   (Cnrs[z].ss[x].pci->date.month > bsres->pci->date.month) ? TRUE :
    1286                   (Cnrs[z].ss[x].pci->date.month < bsres->pci->date.month) ? FALSE :
    1287                   (Cnrs[z].ss[x].pci->date.day > bsres->pci->date.day) ? TRUE :
    1288                   (Cnrs[z].ss[x].pci->date.day < bsres->pci->date.day) ? FALSE :
    1289                   (Cnrs[z].ss[x].pci->time.hours > bsres->pci->time.hours) ? TRUE :
    1290                   (Cnrs[z].ss[x].pci->time.hours < bsres->pci->time.hours) ? FALSE :
    1291                   (Cnrs[z].ss[x].pci->time.minutes > bsres->pci->time.minutes) ? TRUE :
    1292                   (Cnrs[z].ss[x].pci->time.minutes < bsres->pci->time.minutes) ? FALSE :
    1293                   (Cnrs[z].ss[x].pci->time.seconds > bsres->pci->time.seconds) ? TRUE :
    1294                   (Cnrs[z].ss[x].pci->time.seconds < bsres->pci->time.seconds) ? FALSE :
    1295                    FALSE;
    1296             if (!cmp)
    1297               Cnrs[z].ss[x].newest = FALSE;
    1298             cmp = (Cnrs[z].ss[x].pci->date.year < bsres->pci->date.year) ? TRUE :
    1299                   (Cnrs[z].ss[x].pci->date.year > bsres->pci->date.year) ? FALSE :
    1300                   (Cnrs[z].ss[x].pci->date.month < bsres->pci->date.month) ? TRUE :
    1301                   (Cnrs[z].ss[x].pci->date.month > bsres->pci->date.month) ? FALSE :
    1302                   (Cnrs[z].ss[x].pci->date.day < bsres->pci->date.day) ? TRUE :
    1303                   (Cnrs[z].ss[x].pci->date.day > bsres->pci->date.day) ? FALSE :
    1304                   (Cnrs[z].ss[x].pci->time.hours < bsres->pci->time.hours) ? TRUE :
    1305                   (Cnrs[z].ss[x].pci->time.hours > bsres->pci->time.hours) ? FALSE :
    1306                   (Cnrs[z].ss[x].pci->time.minutes < bsres->pci->time.minutes) ? TRUE :
    1307                   (Cnrs[z].ss[x].pci->time.minutes > bsres->pci->time.minutes) ? FALSE :
    1308                   (Cnrs[z].ss[x].pci->time.seconds < bsres->pci->time.seconds) ? TRUE :
    1309                   (Cnrs[z].ss[x].pci->time.seconds > bsres->pci->time.seconds) ? FALSE :
    1310                    FALSE;
    1311             if (!cmp)
    1312               Cnrs[z].ss[x].oldest = FALSE;
    1313             cmp = 0;
    1314             break;
    1315           }
    1316           else
    1317             Cnrs[z].ss[x].all = FALSE;
    1318         }
     1228        Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].smallest =
     1229        Cnrs[z].ss[x].largest = TRUE;
     1230      for (w = 0; w < numwindows; w++) {
     1231        if (w != z && Cnrs[w].numfiles) {
     1232          bsres = (struct SS *)bsearch(Cnrs[z].ss[x].pci->pszFileName,
     1233                                       Cnrs[w].ss, Cnrs[w].numfiles,
     1234                                       sizeof(struct SS), CompSSNamesB);
     1235          if (bsres) {
     1236            Cnrs[z].ss[x].unique = FALSE;
     1237            if (Cnrs[z].ss[x].pci->cbFile + Cnrs[z].ss[x].pci->easize >
     1238                bsres->pci->cbFile + bsres->pci->easize)
     1239              Cnrs[z].ss[x].smallest = FALSE;
     1240            if (Cnrs[z].ss[x].pci->cbFile + Cnrs[z].ss[x].pci->easize <
     1241                bsres->pci->cbFile + bsres->pci->easize)
     1242              Cnrs[z].ss[x].largest = FALSE;
     1243            cmp =
     1244              (Cnrs[z].ss[x].pci->date.year >
     1245               bsres->pci->date.year) ? TRUE : (Cnrs[z].ss[x].pci->date.year <
     1246                                                bsres->pci->date.
     1247                                                year) ? FALSE : (Cnrs[z].
     1248                                                                 ss[x].pci->
     1249                                                                 date.month >
     1250                                                                 bsres->pci->
     1251                                                                 date.
     1252                                                                 month) ? TRUE
     1253              : (Cnrs[z].ss[x].pci->date.month <
     1254                 bsres->pci->date.month) ? FALSE : (Cnrs[z].ss[x].pci->date.
     1255                                                    day >
     1256                                                    bsres->pci->date.
     1257                                                    day) ? TRUE : (Cnrs[z].
     1258                                                                   ss[x].pci->
     1259                                                                   date.day <
     1260                                                                   bsres->
     1261                                                                   pci->date.
     1262                                                                   day) ?
     1263              FALSE : (Cnrs[z].ss[x].pci->time.hours >
     1264                       bsres->pci->time.hours) ? TRUE : (Cnrs[z].ss[x].pci->
     1265                                                         time.hours <
     1266                                                         bsres->pci->time.
     1267                                                         hours) ? FALSE
     1268              : (Cnrs[z].ss[x].pci->time.minutes >
     1269                 bsres->pci->time.minutes) ? TRUE : (Cnrs[z].ss[x].pci->time.
     1270                                                     minutes <
     1271                                                     bsres->pci->time.
     1272                                                     minutes) ? FALSE
     1273              : (Cnrs[z].ss[x].pci->time.seconds >
     1274                 bsres->pci->time.seconds) ? TRUE : (Cnrs[z].ss[x].pci->time.
     1275                                                     seconds <
     1276                                                     bsres->pci->time.
     1277                                                     seconds) ? FALSE : FALSE;
     1278            if (!cmp)
     1279              Cnrs[z].ss[x].newest = FALSE;
     1280            cmp =
     1281              (Cnrs[z].ss[x].pci->date.year <
     1282               bsres->pci->date.year) ? TRUE : (Cnrs[z].ss[x].pci->date.year >
     1283                                                bsres->pci->date.
     1284                                                year) ? FALSE : (Cnrs[z].
     1285                                                                 ss[x].pci->
     1286                                                                 date.month <
     1287                                                                 bsres->pci->
     1288                                                                 date.
     1289                                                                 month) ? TRUE
     1290              : (Cnrs[z].ss[x].pci->date.month >
     1291                 bsres->pci->date.month) ? FALSE : (Cnrs[z].ss[x].pci->date.
     1292                                                    day <
     1293                                                    bsres->pci->date.
     1294                                                    day) ? TRUE : (Cnrs[z].
     1295                                                                   ss[x].pci->
     1296                                                                   date.day >
     1297                                                                   bsres->
     1298                                                                   pci->date.
     1299                                                                   day) ?
     1300              FALSE : (Cnrs[z].ss[x].pci->time.hours <
     1301                       bsres->pci->time.hours) ? TRUE : (Cnrs[z].ss[x].pci->
     1302                                                         time.hours >
     1303                                                         bsres->pci->time.
     1304                                                         hours) ? FALSE
     1305              : (Cnrs[z].ss[x].pci->time.minutes <
     1306                 bsres->pci->time.minutes) ? TRUE : (Cnrs[z].ss[x].pci->time.
     1307                                                     minutes >
     1308                                                     bsres->pci->time.
     1309                                                     minutes) ? FALSE
     1310              : (Cnrs[z].ss[x].pci->time.seconds <
     1311                 bsres->pci->time.seconds) ? TRUE : (Cnrs[z].ss[x].pci->time.
     1312                                                     seconds >
     1313                                                     bsres->pci->time.
     1314                                                     seconds) ? FALSE : FALSE;
     1315            if (!cmp)
     1316              Cnrs[z].ss[x].oldest = FALSE;
     1317            cmp = 0;
     1318            break;
     1319          }
     1320          else
     1321            Cnrs[z].ss[x].all = FALSE;
     1322        }
    13191323      }
    13201324      if (Cnrs[z].ss[x].unique)
    1321         Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].newest = Cnrs[z].ss[x].all =
    1322           Cnrs[z].ss[x].largest = Cnrs[z].ss[x].smallest = FALSE;
     1325        Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].newest = Cnrs[z].ss[x].all =
     1326          Cnrs[z].ss[x].largest = Cnrs[z].ss[x].smallest = FALSE;
    13231327      DosSleep(0L);
    13241328    }
    … …  
    13261330  }
    13271331
    1328   switch(action) {
    1329     case IDM_SELECTBOTH:
    1330       for (z = 0;z < numwindows;z++) {
    1331         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1332           if (Cnrs[z].ss[x].all)
    1333             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1334                        MPFROMP(Cnrs[z].ss[x].pci),
    1335                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1336         }
    1337         DosSleep(0L);
    1338       }
    1339       break;
    1340     case IDM_SELECTMORE:
    1341       for (z = 0;z < numwindows;z++) {
    1342         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1343           if (!Cnrs[z].ss[x].unique)
    1344             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1345                        MPFROMP(Cnrs[z].ss[x].pci),
    1346                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1347         }
    1348         DosSleep(0L);
    1349       }
    1350       break;
    1351     case IDM_SELECTONE:
    1352       for (z = 0;z < numwindows;z++) {
    1353         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1354           if (Cnrs[z].ss[x].unique)
    1355             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1356                        MPFROMP(Cnrs[z].ss[x].pci),
    1357                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1358         }
    1359         DosSleep(0L);
    1360       }
    1361       break;
    1362     case IDM_SELECTNEWER:
    1363       for (z = 0;z < numwindows;z++) {
    1364         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1365           if (Cnrs[z].ss[x].newest)
    1366             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1367                        MPFROMP(Cnrs[z].ss[x].pci),
    1368                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1369         }
    1370         DosSleep(0L);
    1371       }
    1372       break;
    1373     case IDM_SELECTOLDER:
    1374       for (z = 0;z < numwindows;z++) {
    1375         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1376           if (Cnrs[z].ss[x].oldest)
    1377             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1378                        MPFROMP(Cnrs[z].ss[x].pci),
    1379                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1380         }
    1381         DosSleep(0L);
    1382       }
    1383       break;
    1384     case IDM_SELECTBIGGER:
    1385       for (z = 0;z < numwindows;z++) {
    1386         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1387           if (Cnrs[z].ss[x].largest)
    1388             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1389                        MPFROMP(Cnrs[z].ss[x].pci),
    1390                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1391         }
    1392         DosSleep(0L);
    1393       }
    1394       break;
    1395     case IDM_SELECTSMALLER:
    1396       for (z = 0;z < numwindows;z++) {
    1397         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1398           if (Cnrs[z].ss[x].smallest)
    1399             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1400                        MPFROMP(Cnrs[z].ss[x].pci),
    1401                        MPFROM2SHORT(TRUE,CRA_SELECTED));
    1402         }
    1403         DosSleep(0L);
    1404       }
    1405       break;
    1406 
    1407     case IDM_DESELECTBOTH:
    1408       for (z = 0;z < numwindows;z++) {
    1409         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1410           if (Cnrs[z].ss[x].all)
    1411             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1412                        MPFROMP(Cnrs[z].ss[x].pci),
    1413                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1414         }
    1415         DosSleep(0L);
    1416       }
    1417       break;
    1418     case IDM_DESELECTMORE:
    1419       for (z = 0;z < numwindows;z++) {
    1420         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1421           if (!Cnrs[z].ss[x].unique)
    1422             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1423                        MPFROMP(Cnrs[z].ss[x].pci),
    1424                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1425         }
    1426         DosSleep(0L);
    1427       }
    1428       break;
    1429     case IDM_DESELECTONE:
    1430       for (z = 0;z < numwindows;z++) {
    1431         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1432           if (Cnrs[z].ss[x].unique)
    1433             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1434                        MPFROMP(Cnrs[z].ss[x].pci),
    1435                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1436         }
    1437         DosSleep(0L);
    1438       }
    1439       break;
    1440     case IDM_DESELECTNEWER:
    1441       for (z = 0;z < numwindows;z++) {
    1442         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1443           if (Cnrs[z].ss[x].newest)
    1444             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1445                        MPFROMP(Cnrs[z].ss[x].pci),
    1446                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1447         }
    1448         DosSleep(0L);
    1449       }
    1450       break;
    1451     case IDM_DESELECTOLDER:
    1452       for (z = 0;z < numwindows;z++) {
    1453         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1454           if (Cnrs[z].ss[x].oldest)
    1455             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1456                        MPFROMP(Cnrs[z].ss[x].pci),
    1457                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1458         }
    1459         DosSleep(0L);
    1460       }
    1461       break;
    1462     case IDM_DESELECTBIGGER:
    1463       for (z = 0;z < numwindows;z++) {
    1464         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1465           if (Cnrs[z].ss[x].largest)
    1466             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1467                        MPFROMP(Cnrs[z].ss[x].pci),
    1468                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1469         }
    1470         DosSleep(0L);
    1471       }
    1472       break;
    1473     case IDM_DESELECTSMALLER:
    1474       for (z = 0;z < numwindows;z++) {
    1475         for (x = 0;x < Cnrs[z].numfiles;x++) {
    1476           if (Cnrs[z].ss[x].smallest)
    1477             WinSendMsg(Cnrs[z].hwndCnr,CM_SETRECORDEMPHASIS,
    1478                        MPFROMP(Cnrs[z].ss[x].pci),
    1479                        MPFROM2SHORT(FALSE,CRA_SELECTED));
    1480         }
    1481         DosSleep(0L);
    1482       }
    1483       break;
    1484   }
    1485 
    1486   FreeCnrs(Cnrs,numwindows);
    1487 }
     1332  switch (action) {
     1333  case IDM_SELECTBOTH:
     1334    for (z = 0; z < numwindows; z++) {
     1335      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1336        if (Cnrs[z].ss[x].all)
     1337          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1338                     MPFROMP(Cnrs[z].ss[x].pci),
     1339                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1340      }
     1341      DosSleep(0L);
     1342    }
     1343    break;
     1344  case IDM_SELECTMORE:
     1345    for (z = 0; z < numwindows; z++) {
     1346      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1347        if (!Cnrs[z].ss[x].unique)
     1348          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1349                     MPFROMP(Cnrs[z].ss[x].pci),
     1350                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1351      }
     1352      DosSleep(0L);
     1353    }
     1354    break;
     1355  case IDM_SELECTONE:
     1356    for (z = 0; z < numwindows; z++) {
     1357      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1358        if (Cnrs[z].ss[x].unique)
     1359          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1360                     MPFROMP(Cnrs[z].ss[x].pci),
     1361                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1362      }
     1363      DosSleep(0L);
     1364    }
     1365    break;
     1366  case IDM_SELECTNEWER:
     1367    for (z = 0; z < numwindows; z++) {
     1368      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1369        if (Cnrs[z].ss[x].newest)
     1370          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1371                     MPFROMP(Cnrs[z].ss[x].pci),
     1372                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1373      }
     1374      DosSleep(0L);
     1375    }
     1376    break;
     1377  case IDM_SELECTOLDER:
     1378    for (z = 0; z < numwindows; z++) {
     1379      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1380        if (Cnrs[z].ss[x].oldest)
     1381          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1382                     MPFROMP(Cnrs[z].ss[x].pci),
     1383                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1384      }
     1385      DosSleep(0L);
     1386    }
     1387    break;
     1388  case IDM_SELECTBIGGER:
     1389    for (z = 0; z < numwindows; z++) {
     1390      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1391        if (Cnrs[z].ss[x].largest)
     1392          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1393                     MPFROMP(Cnrs[z].ss[x].pci),
     1394                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1395      }
     1396      DosSleep(0L);
     1397    }
     1398    break;
     1399  case IDM_SELECTSMALLER:
     1400    for (z = 0; z < numwindows; z++) {
     1401      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1402        if (Cnrs[z].ss[x].smallest)
     1403          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1404                     MPFROMP(Cnrs[z].ss[x].pci),
     1405                     MPFROM2SHORT(TRUE, CRA_SELECTED));
     1406      }
     1407      DosSleep(0L);
     1408    }
     1409    break;
     1410
     1411  case IDM_DESELECTBOTH:
     1412    for (z = 0; z < numwindows; z++) {
     1413      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1414        if (Cnrs[z].ss[x].all)
     1415          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1416                     MPFROMP(Cnrs[z].ss[x].pci),
     1417                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1418      }
     1419      DosSleep(0L);
     1420    }
     1421    break;
     1422  case IDM_DESELECTMORE:
     1423    for (z = 0; z < numwindows; z++) {
     1424      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1425        if (!Cnrs[z].ss[x].unique)
     1426          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1427                     MPFROMP(Cnrs[z].ss[x].pci),
     1428                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1429      }
     1430      DosSleep(0L);
     1431    }
     1432    break;
     1433  case IDM_DESELECTONE:
     1434    for (z = 0; z < numwindows; z++) {
     1435      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1436        if (Cnrs[z].ss[x].unique)
     1437          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1438                     MPFROMP(Cnrs[z].ss[x].pci),
     1439                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1440      }
     1441      DosSleep(0L);
     1442    }
     1443    break;
     1444  case IDM_DESELECTNEWER:
     1445    for (z = 0; z < numwindows; z++) {
     1446      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1447        if (Cnrs[z].ss[x].newest)
     1448          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1449                     MPFROMP(Cnrs[z].ss[x].pci),
     1450                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1451      }
     1452      DosSleep(0L);
     1453    }
     1454    break;
     1455  case IDM_DESELECTOLDER:
     1456    for (z = 0; z < numwindows; z++) {
     1457      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1458        if (Cnrs[z].ss[x].oldest)
     1459          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1460                     MPFROMP(Cnrs[z].ss[x].pci),
     1461                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1462      }
     1463      DosSleep(0L);
     1464    }
     1465    break;
     1466  case IDM_DESELECTBIGGER:
     1467    for (z = 0; z < numwindows; z++) {
     1468      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1469        if (Cnrs[z].ss[x].largest)
     1470          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1471                     MPFROMP(Cnrs[z].ss[x].pci),
     1472                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1473      }
     1474      DosSleep(0L);
     1475    }
     1476    break;
     1477  case IDM_DESELECTSMALLER:
     1478    for (z = 0; z < numwindows; z++) {
     1479      for (x = 0; x < Cnrs[z].numfiles; x++) {
     1480        if (Cnrs[z].ss[x].smallest)
     1481          WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
     1482                     MPFROMP(Cnrs[z].ss[x].pci),
     1483                     MPFROM2SHORT(FALSE, CRA_SELECTED));
     1484      }
     1485      DosSleep(0L);
     1486    }
     1487    break;
     1488  }
     1489
     1490  FreeCnrs(Cnrs, numwindows);
     1491}
Note: See TracChangeset for help on using the changeset viewer.