source: trunk/dll/comp.c @ 535

Last change on this file since 535 was 535, checked in by root, 14 years ago

Count thread usage

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 98.7 KB
Line 
1
2/***********************************************************************
3
4  $Id: comp.c 535 2006-11-04 21:08:42Z root $
5
6  Compare directories
7
8  Copyright (c) 1993-02 M. Kimes
9  Copyright (c) 2003, 2006 Steven H. Levine
10
11  16 Oct 02 MK Baseline
12  04 Nov 03 SHL Force window refresh after subdir toggle
13  01 Aug 04 SHL Rework lstrip/rstrip usage
14  24 May 05 SHL Rework Win_Error usage
15  24 May 05 SHL Rework for CNRITEM.szSubject
16  25 May 05 SHL Rework with ULONGLONG
17  06 Jun 05 SHL Drop unused
18  12 Jul 06 SHL Renames and comments
19  13 Jul 06 SHL Use Runtime_Error
20  26 Jul 06 SHL Drop unreachable CN_... code
21  29 Jul 06 SHL Use xfgets_bstripcr
22  15 Aug 06 SHL Turn off hide not selected on dir change
23  19 Oct 06 SHL Correct . and .. detect
24  03 Nov 06 SHL Count thread usage
25
26***********************************************************************/
27
28#define INCL_DOS
29#define INCL_WIN
30#define INCL_GPI
31#define INCL_LONGLONG
32#include <os2.h>
33
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <ctype.h>
38#include <share.h>
39#include <io.h>
40
41#include "fm3dll.h"
42#include "fm3dlg.h"
43#include "fm3str.h"
44
45#pragma alloc_text(COMPAREDIR,FillCnrsThread,FillDirList,CompNames)
46#pragma alloc_text(COMPAREDIR1,CompareDlgProc)
47#pragma alloc_text(COMPAREDIR2,SelectCnrsThread,ActionCnrThread)
48#pragma alloc_text(COMPAREFILE,CFileDlgProc,CompareFilesThread)
49#pragma alloc_text(SNAPSHOT,SnapShot,StartSnap)
50
51typedef struct {
52  CHAR  filename[CCHMAXPATH];
53  CHAR  dirname[CCHMAXPATH];
54  BOOL  recurse;
55} SNAPSTUFF;
56
57static PSZ pszSrcFile = __FILE__;
58
59//=== SnapShot() Write directory tree to file and recurse if requested ===
60
61static VOID SnapShot (char *path,FILE *fp,BOOL recurse)
62{
63  FILEFINDBUF4 *fb;
64  char         *mask,*enddir;
65  HDIR          hdir = HDIR_CREATE;
66  ULONG         nm = 1L;
67
68  fb = xmalloc(sizeof(FILEFINDBUF4),pszSrcFile,__LINE__);
69  if(fb) {
70    mask = xmalloc(CCHMAXPATH,pszSrcFile,__LINE__);
71    if(mask) {
72      sprintf(mask,
73              "%s%s*",
74              path,
75              (path[strlen(path) - 1] != '\\') ? "\\" : NullStr);
76      enddir = strrchr(mask,'\\');
77      enddir++;
78      if(!DosFindFirst(mask,
79                       &hdir,
80                       FILE_NORMAL | FILE_DIRECTORY |
81                       FILE_ARCHIVED | FILE_READONLY | FILE_HIDDEN |
82                       FILE_SYSTEM,
83                       fb,
84                       sizeof(FILEFINDBUF4),
85                       &nm,
86                       FIL_QUERYEASIZE)) {
87        do {
88          strcpy(enddir,fb->achName);
89          if(!(fb->attrFile & FILE_DIRECTORY))
90            fprintf(fp,
91                    "\"%s\",%u,%lu,%04u/%02u/%02u,%02u:%02u:%02u,%lu,%lu,N\n",
92                    mask,
93                    enddir - mask,
94                    fb->cbFile,
95                    (fb->fdateLastWrite.year + 1980),
96                    fb->fdateLastWrite.month,
97                    fb->fdateLastWrite.day,
98                    fb->ftimeLastWrite.hours,
99                    fb->ftimeLastWrite.minutes,
100                    fb->ftimeLastWrite.twosecs,
101                    fb->attrFile,
102                    (fb->cbList > 4L) ? (fb->cbList / 2L) : 0L);
103          // Skip . and ..
104          else if (recurse &&
105                   (fb->achName[0] != '.' ||
106                    (fb->achName[1] &&
107                     (fb->achName[1] != '.' || fb->achName[2])))) {
108            SnapShot(mask,fp,recurse);
109          }
110          nm = 1L;
111        } while(!DosFindNext(hdir,fb,sizeof(FILEFINDBUF4),&nm));
112        DosFindClose(hdir);
113      }
114      free(mask);
115    }
116    free(fb);
117  }
118}
119
120//=== StartSnap() Write directory tree to snapshot file ===
121
122static VOID StartSnap (VOID *dummy)
123{
124  SNAPSTUFF  *sf = (SNAPSTUFF *)dummy;
125  FILE       *fp;
126  CHAR       *p;
127
128  if(sf) {
129    if(*sf->dirname && *sf->filename) {
130      priority_normal();
131      p = sf->dirname;
132      while(*p) {
133        if(*p == '/')
134          *p = '\\';
135        p++;
136      }
137      if(*(p - 1) != '\\') {
138        *p = '\\';
139        p++;
140      }
141      fp = xfopen(sf->filename,"w",pszSrcFile,__LINE__);
142      if (fp) {
143        fprintf(fp,"\"%s\"\n",sf->dirname);
144        SnapShot(sf->dirname,fp,sf->recurse);
145        fclose(fp);
146      }
147    }
148    free(sf);
149  }
150}
151
152//=== CompareFilesThread() Compare files and update container select flags ===
153
154static VOID CompareFilesThread (VOID *args)
155{
156  FCOMPARE fc;
157  HAB      hab2;
158  HMQ      hmq2;
159  FILE    *fp1,*fp2;
160  ULONG    len1,len2,offset = 0L;
161  LONG     numread1,numread2;
162  CHAR     s[1024],ss[1024],*p1,*p2;
163
164  if(args) {
165    fc = *(FCOMPARE *)args;
166    hab2 = WinInitialize(0);
167    if(hab2) {
168      hmq2 = WinCreateMsgQueue(hab2,0);
169      if(hmq2) {
170        WinCancelShutdown(hmq2,TRUE);
171        IncrThreadUsage();
172        if(!IsFile(fc.file1) || IsRoot(fc.file1)) {
173          p1 = strrchr(fc.file2,'\\');
174          if(p1) {
175            if(fc.file1[strlen(fc.file1) - 1] == '\\')
176              p1++;
177            strcat(fc.file1,p1);
178          }
179        }
180        else if(!IsFile(fc.file2) || IsRoot(fc.file2)) {
181          p1 = strrchr(fc.file1,'\\');
182          if(p1) {
183            if(fc.file2[strlen(fc.file2) - 1] == '\\')
184              p1++;
185            strcat(fc.file2,p1);
186          }
187        }
188        sprintf(s,GetPString(IDS_COMPCOMPARETEXT),fc.file1);
189        AddToListboxBottom(fc.hwndList,s);
190        sprintf(s,GetPString(IDS_COMPTOTEXT),fc.file2);
191        AddToListboxBottom(fc.hwndList,s);
192        fp1 = _fsopen(fc.file1,"rb",SH_DENYNO);
193        if (!fp1) {
194          sprintf(s,GetPString(IDS_COMPCANTOPENTEXT),fc.file1);
195          AddToListboxBottom(fc.hwndList,s);
196          WinSetWindowText(fc.hwndHelp,GetPString(IDS_ERRORTEXT));
197        }
198        else {
199          fp2 = _fsopen(fc.file2,"rb",SH_DENYNO);
200          if (!fp2) {
201            sprintf(s,GetPString(IDS_COMPCANTOPENTEXT),fc.file2);
202            AddToListboxBottom(fc.hwndList,s);
203            WinSetWindowText(fc.hwndHelp,GetPString(IDS_ERRORTEXT));
204          }
205          else {
206            len1 = filelength(fileno(fp1));
207            len2 = filelength(fileno(fp2));
208            if(len1 != len2) {
209              strcpy(s,GetPString(IDS_COMPDIFSIZESTEXT));
210              AddToListboxBottom(fc.hwndList,s);
211              sprintf(s,GetPString(IDS_COMPVSBYTESTEXT),len1,len2);
212              AddToListboxBottom(fc.hwndList,s);
213              WinSetWindowText(fc.hwndHelp,GetPString(IDS_COMPDONTMATCHTEXT));
214            }
215            else {
216              WinSetWindowText(fc.hwndHelp,GetPString(IDS_COMPCOMPARINGTEXT));
217              while(WinIsWindow(hab2,fc.hwndList)) {
218                numread1 = fread(s,1,1024,fp1);
219                numread2 = fread(ss,1,1024,fp2);
220                if(numread1 != numread2 || feof(fp1) != feof(fp2)) {
221                  sprintf(s,GetPString(IDS_COMPREADERRORTEXT),
222                          offset,offset);
223                  AddToListboxBottom(fc.hwndList,s);
224                  WinSetWindowText(fc.hwndHelp,GetPString(IDS_ERRORTEXT));
225                  break;
226                }
227                else if(!numread1 && feof(fp1) && feof(fp2)) {
228                  AddToListboxBottom(fc.hwndList,
229                                     GetPString(IDS_COMPFILESMATCHTEXT));
230                  if(!stricmp(fc.file1,fc.file2))
231                    AddToListboxBottom(fc.hwndList,
232                                       GetPString(IDS_COMPWONDERWHYTEXT));
233                  WinSetWindowText(fc.hwndHelp,
234                                   GetPString(IDS_COMPCOMPLETETEXT));
235                  break;
236                }
237                else if(numread1 <= 0 || numread2 <= 0) {
238                  if(offset == len1)
239                    break;
240                  else {
241                    sprintf(s,GetPString(IDS_COMPMATCHREADERRORTEXT),
242                            offset,offset);
243                    WinSetWindowText(fc.hwndHelp,
244                                     GetPString(IDS_COMPODDERRORTEXT));
245                    AddToListboxBottom(fc.hwndList,s);
246                    break;
247                  }
248                }
249                else if(memcmp(s,ss,numread1)) {
250                  p1 = s;
251                  p2 = ss;
252                  while(p1 < s + numread1) {
253                    if(*p1 != *p2) {
254                      sprintf(s,GetPString(IDS_COMPMISMATCHERRORTEXT),
255                              offset + (p1 - s),offset + (p1 - s));
256                      AddToListboxBottom(fc.hwndList,s);
257                      WinSetWindowText(fc.hwndHelp,
258                                       GetPString(IDS_COMPDONTMATCHTEXT));
259                      break;
260                    }
261                    p1++;
262                    p2++;
263                  }
264                  break;
265                }
266                offset += numread1;
267              }
268            }
269            fclose(fp2);
270          }
271          fclose(fp1);
272        }
273        DecrThreadUsage();
274        WinDestroyMsgQueue(hmq2);
275      }
276      WinTerminate(hab2);
277    }
278  }
279}
280
281//=== CFileDlgProc() Select directories to compare dialog procedure ===
282
283MRESULT EXPENTRY CFileDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
284{
285  FCOMPARE *fc;
286
287  switch(msg) {
288    case WM_INITDLG:
289      if(!mp2)
290        WinDismissDlg(hwnd,0);
291      else {
292        WinSetWindowPtr(hwnd,0,mp2);
293        fc = (FCOMPARE *)mp2;
294        fc->hwndReport = hwnd;
295        fc->hwndList = WinWindowFromID(hwnd,FCMP_LISTBOX);
296        fc->hwndHelp = WinWindowFromID(hwnd,FCMP_HELP);
297        if(!*fc->file1 || !fc->file2) {
298          WinDismissDlg(hwnd,0);
299          break;
300        }
301        MakeFullName(fc->file1);
302        MakeFullName(fc->file2);
303        if(!stricmp(fc->file1,fc->file2)) {
304          saymsg(MB_CANCEL,hwnd,
305                 GetPString(IDS_COMPSILLYALERTTEXT),
306                 GetPString(IDS_COMPTOITSELFTEXT));
307          WinDismissDlg(hwnd,0);
308          break;
309        }
310        if (_beginthread(CompareFilesThread,NULL,65536,(PVOID)fc) == -1) {
311          Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
312          WinDismissDlg(hwnd,0);
313        }
314      }
315      break;
316
317    case WM_ADJUSTWINDOWPOS:
318      PostMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
319      break;
320
321    case UM_SETDIR:
322      PaintRecessedWindow(WinWindowFromID(hwnd,FCMP_HELP),
323                          (HPS)0,
324                          FALSE,
325                          TRUE);
326      return 0;
327
328    case WM_COMMAND:
329      switch(SHORT1FROMMP(mp1)) {
330        case DID_OK:
331          WinDismissDlg(hwnd,0);
332          break;
333        case DID_CANCEL:
334          WinDismissDlg(hwnd,1);
335          break;
336      }
337      return 0;
338
339    case WM_DESTROY:
340      DosSleep(100L);
341      break;
342  }
343  return WinDefDlgProc(hwnd,msg,mp1,mp2);
344}
345
346//=== ActionCnrThread() Do requested action on container contents ===
347
348static VOID ActionCnrThread (VOID *args)
349{
350  COMPARE *cmp = (COMPARE *)args;
351  HAB      hab;
352  HMQ      hmq;
353  HWND     hwndCnrS,hwndCnrD;
354  PCNRITEM pci,pciO,pcin,pciOn;
355  CHAR     newname[CCHMAXPATH],dirname[CCHMAXPATH],*p;
356  APIRET   rc;
357
358  if(!cmp)
359    return;
360
361  DosError(FERR_DISABLEHARDERR);
362
363  hab = WinInitialize(0);
364  if(hab) {
365    hmq = WinCreateMsgQueue(hab,0);
366    if(hmq) {
367      WinCancelShutdown(hmq,TRUE);
368      IncrThreadUsage();
369      priority_normal();
370      switch(cmp->action) {
371        case COMP_DELETELEFT:
372          hwndCnrS = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
373          hwndCnrD = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
374          cmp->action = IDM_DELETE;
375          break;
376        case COMP_DELETERIGHT:
377          hwndCnrS = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
378          hwndCnrD = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
379          cmp->action = IDM_DELETE;
380          break;
381        case COMP_MOVELEFT:
382          cmp->action = IDM_MOVE;
383          hwndCnrS = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
384          hwndCnrD = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
385          break;
386        case COMP_MOVERIGHT:
387          cmp->action = IDM_MOVE;
388          hwndCnrS = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
389          hwndCnrD = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
390          break;
391        case COMP_COPYLEFT:
392          cmp->action = IDM_COPY;
393          hwndCnrS = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
394          hwndCnrD = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
395          break;
396        case COMP_COPYRIGHT:
397          cmp->action = IDM_COPY;
398          hwndCnrS = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
399          hwndCnrD = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
400          break;
401        default:
402          Runtime_Error(pszSrcFile, __LINE__, "bad case %u", cmp->action);
403          goto Abort;
404      }
405
406      pci = WinSendMsg(hwndCnrS,CM_QUERYRECORD,MPVOID,
407                       MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
408      pciO = WinSendMsg(hwndCnrD,CM_QUERYRECORD,MPVOID,
409                        MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
410      while(pci && (INT)pci != -1 && pciO && (INT)pciO != -1) {
411
412        pcin = WinSendMsg(hwndCnrS,CM_QUERYRECORD,MPFROMP(pci),
413                          MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
414        pciOn = WinSendMsg(hwndCnrD,CM_QUERYRECORD,MPFROMP(pciO),
415                           MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
416        if(*pci->szFileName && (pci->rc.flRecordAttr & CRA_SELECTED)) {
417          switch(cmp->action) {
418            case IDM_DELETE:
419              if(!unlinkf("%s",pci->szFileName)) {
420                WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pci),
421                           MPFROM2SHORT(FALSE,CRA_SELECTED));
422                if(!*pciO->szFileName) {
423                  WinSendMsg(hwndCnrS,CM_REMOVERECORD,MPFROMP(&pci),
424                             MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
425                  if(pciO->rc.flRecordAttr & CRA_SELECTED)
426                    WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciO),
427                               MPFROM2SHORT(FALSE,CRA_SELECTED));
428                  WinSendMsg(hwndCnrD,CM_REMOVERECORD,MPFROMP(&pciO),
429                             MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
430                }
431                else {
432                  *pci->szFileName = 0;
433                  pci->pszFileName = pci->szFileName;
434                  pci->flags = 0;
435                  WinSendMsg(hwndCnrS,CM_INVALIDATERECORD,MPFROMP(&pci),
436                             MPFROM2SHORT(1,CMA_ERASE | CMA_TEXTCHANGED));
437                }
438                if(hwndCnrS == WinWindowFromID(cmp->hwnd,COMP_LEFTDIR))
439                  cmp->cmp->totalleft--;
440                else
441                  cmp->cmp->totalright--;
442                DosSleep(0L);
443              }
444              break;
445
446            case IDM_MOVE:
447              if(hwndCnrS == WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR))
448                sprintf(newname,"%s%s%s",cmp->leftdir,
449                        cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\' ? NullStr : "\\",
450                        pci->pszFileName);
451              else
452                sprintf(newname,"%s%s%s",cmp->rightdir,
453                        cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\' ? NullStr : "\\",
454                        pci->pszFileName);
455              /* make directory if required */
456              strcpy(dirname,newname);
457              p = strrchr(dirname,'\\');
458              if(p) {
459                if(p > dirname + 2)
460                  p++;
461                *p = 0;
462                if(IsFile(dirname) == -1)
463                  MassMkdir(hwndMain,dirname);
464              }
465              rc = docopyf(MOVE,pci->szFileName,"%s",newname);
466              if(!rc && stricmp(pci->szFileName,newname)) {
467                WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pci),
468                           MPFROM2SHORT(FALSE,CRA_SELECTED));
469                if(pciO->rc.flRecordAttr & CRA_SELECTED)
470                  WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciO),
471                             MPFROM2SHORT(FALSE,CRA_SELECTED));
472                strcpy(pciO->szFileName,newname);
473                if(hwndCnrS == WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR)) {
474                  pciO->pszFileName = pciO->szFileName + strlen(cmp->leftdir);
475                  if(cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
476                    pciO->pszFileName++;
477                }
478                else {
479                  pciO->pszFileName = pciO->szFileName + strlen(cmp->rightdir);
480                  if(cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
481                    pciO->pszFileName++;
482                }
483                strcpy(pciO->szDispAttr,pci->szDispAttr);
484                pciO->attrFile   = pci->attrFile;
485                pciO->flags      = 0;
486                pciO->date       = pci->date;
487                pciO->time       = pci->time;
488                pciO->ladate     = pci->ladate;
489                pciO->latime     = pci->latime;
490                pciO->crdate     = pci->crdate;
491                pciO->crtime     = pci->crtime;
492                pciO->cbFile     = pci->cbFile;
493                pciO->easize     = pci->easize;
494                *pciO->szSubject = 0;
495                *pci->szFileName = 0;
496                pci->pszFileName = pci->szFileName;
497                pci->flags = 0;
498                WinSendMsg(hwndCnrS,CM_INVALIDATERECORD,MPFROMP(&pci),
499                           MPFROM2SHORT(1,CMA_ERASE | CMA_TEXTCHANGED));
500                WinSendMsg(hwndCnrD,CM_INVALIDATERECORD,MPFROMP(&pciO),
501                           MPFROM2SHORT(1,CMA_ERASE | CMA_TEXTCHANGED));
502              }
503              else if (rc) {
504                rc = Dos_Error(MB_ENTERCANCEL,
505                               rc,
506                               HWND_DESKTOP,
507                               pszSrcFile,
508                               __LINE__,
509                               GetPString(IDS_COMPMOVEFAILEDTEXT),
510                               pci->szFileName,
511                               newname);
512                if(rc == MBID_CANCEL) /* cause loop to break */
513                  pcin = NULL;
514              }
515              break;
516
517            case IDM_COPY:
518              if(hwndCnrS == WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR))
519                sprintf(newname,"%s%s%s",cmp->leftdir,
520                        cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\' ? NullStr : "\\",
521                        pci->pszFileName);
522              else
523                sprintf(newname,"%s%s%s",cmp->rightdir,
524                        cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\' ? NullStr : "\\",
525                        pci->pszFileName);
526              /* make directory if required */
527              strcpy(dirname,newname);
528              p = strrchr(dirname,'\\');
529              if(p) {
530                if(p > dirname + 2)
531                  p++;
532                *p = 0;
533                if(IsFile(dirname) == -1)
534                  MassMkdir(hwndMain,dirname);
535              }
536              rc = docopyf(COPY,pci->szFileName,"%s",newname);
537              if (rc) {
538                rc = Dos_Error(MB_ENTERCANCEL,
539                               rc,
540                               HWND_DESKTOP,
541                               pszSrcFile,
542                               __LINE__,
543                               GetPString(IDS_COMPCOPYFAILEDTEXT),
544                               pci->szFileName,
545                               newname);
546                if(rc == MBID_CANCEL)
547                  pcin = NULL;           /* cause loop to break */
548              }
549              else {
550                WinSendMsg(hwndCnrS,CM_SETRECORDEMPHASIS,MPFROMP(pci),
551                           MPFROM2SHORT(FALSE,CRA_SELECTED));
552                if(pciO->rc.flRecordAttr & CRA_SELECTED)
553                  WinSendMsg(hwndCnrD,CM_SETRECORDEMPHASIS,MPFROMP(pciO),
554                             MPFROM2SHORT(FALSE,CRA_SELECTED));
555                strcpy(pciO->szFileName,newname);
556                if(hwndCnrS == WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR)) {
557                  pciO->pszFileName = pciO->szFileName + strlen(cmp->leftdir);
558                  if(cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
559                    pciO->pszFileName++;
560                }
561                else {
562                  pciO->pszFileName = pciO->szFileName + strlen(cmp->rightdir);
563                  if(cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
564                    pciO->pszFileName++;
565                }
566                strcpy(pciO->szDispAttr,pci->szDispAttr);
567                pciO->attrFile   = pci->attrFile;
568                pciO->flags      = CNRITEM_EXISTS;
569                pciO->date       = pci->date;
570                pciO->time       = pci->time;
571                pciO->ladate     = pci->ladate;
572                pciO->latime     = pci->latime;
573                pciO->crdate     = pci->crdate;
574                pciO->crtime     = pci->crtime;
575                pciO->cbFile     = pci->cbFile;
576                pciO->easize     = pci->easize;
577                *pci->szSubject  = 0;
578                pci->flags       = CNRITEM_EXISTS;
579                WinSendMsg(hwndCnrS,CM_INVALIDATERECORD,MPFROMP(&pci),
580                           MPFROM2SHORT(1,CMA_ERASE | CMA_TEXTCHANGED));
581                WinSendMsg(hwndCnrD,CM_INVALIDATERECORD,MPFROMP(&pciO),
582                           MPFROM2SHORT(1,CMA_ERASE | CMA_TEXTCHANGED));
583              }
584              break;
585
586            default:
587              break;
588          } // switch
589        }
590        pci = pcin;
591        pciO = pciOn;
592      } // while
593Abort:
594      WinDestroyMsgQueue(hmq);
595    }
596    DecrThreadUsage();
597    WinTerminate(hab);
598  }
599  PostMsg(cmp->hwnd,UM_CONTAINER_FILLED,MPFROMLONG(1L),MPVOID);
600  PostMsg(cmp->hwnd,WM_COMMAND,MPFROM2SHORT(IDM_DESELECTALL,0),MPVOID);
601  free(cmp);
602}
603
604//=== SelectCnrsThread() Update container selection flags thread ===
605
606static VOID SelectCnrsThread (VOID *args)
607{
608  COMPARE *cmp = (COMPARE *)args;
609  HAB      hab;
610  HMQ      hmq;
611
612  if(!cmp)
613    return;
614
615  DosError(FERR_DISABLEHARDERR);
616
617  hab = WinInitialize(0);
618  if(hab) {
619    hmq = WinCreateMsgQueue(hab,0);
620    if(hmq) {
621      WinCancelShutdown(hmq,TRUE);
622      IncrThreadUsage();
623      priority_normal();
624      switch(cmp->action) {
625        case IDM_INVERT:
626          InvertAll(WinWindowFromID(cmp->hwnd,COMP_LEFTDIR));
627          InvertAll(WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR));
628          break;
629
630        case IDM_DESELECTALL:
631          Deselect(WinWindowFromID(cmp->hwnd,COMP_LEFTDIR));
632          Deselect(WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR));
633          break;
634
635        default:
636          SpecialSelect(WinWindowFromID(cmp->hwnd,COMP_LEFTDIR),
637                        WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR),
638                        cmp->action,cmp->reset);
639          break;
640      }
641      if(!PostMsg(cmp->hwnd,UM_CONTAINER_FILLED,MPFROMLONG(1L),MPVOID))
642        WinSendMsg(cmp->hwnd,UM_CONTAINER_FILLED,MPFROMLONG(1L),MPVOID);
643      WinDestroyMsgQueue(hmq);
644    }
645    DecrThreadUsage();
646    WinTerminate(hab);
647  }
648  free(cmp);
649}
650
651static VOID FillDirList (CHAR *str,INT skiplen,BOOL recurse,
652                         FILELIST ***list,INT *numfiles,INT *numalloc) {
653
654  register BYTE *fb;
655  register CHAR *enddir;
656  register ULONG x;
657  CHAR          *maskstr;
658  FILEFINDBUF4  *ffb4,*pffb;
659  HDIR           hDir;
660  ULONG          nm,fl = 0,ulM = 64;
661  APIRET         rc;
662
663  if(!str || !*str)
664    return;
665  if(!recurse)
666    ulM = 128;
667  maskstr = xmalloc(CCHMAXPATH,pszSrcFile,__LINE__);
668  if(!maskstr)
669    return;
670  ffb4 = xmalloc(sizeof(FILEFINDBUF4) * ulM,pszSrcFile,__LINE__);
671  if(!ffb4) {
672    free(maskstr);
673    return;
674  }
675  x = strlen(str);
676  memcpy(maskstr,str,x + 1);
677  enddir = maskstr + x;
678  if(*(enddir - 1) != '\\') {
679    *enddir = '\\';
680    enddir++;
681    *enddir = 0;
682  }
683  *enddir = '*';
684  *(enddir + 1) = 0;
685  hDir = HDIR_CREATE;
686  nm = ulM;
687  if(recurse)
688    fl = FILE_DIRECTORY;
689  DosError(FERR_DISABLEHARDERR);
690  rc = DosFindFirst(maskstr, &hDir,
691                    (FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
692                     FILE_SYSTEM | FILE_HIDDEN) | fl,
693                    ffb4, sizeof(FILEFINDBUF4) * nm,
694                    &nm, FIL_QUERYEASIZE);
695  if(!rc) {
696    while(!rc) {
697      fb = (BYTE *)ffb4;
698      x = 0;
699      while(x < nm) {
700        pffb = (FILEFINDBUF4 *)fb;
701        if(pffb->attrFile & FILE_DIRECTORY) {
702          // Skip . and ..
703          if (recurse &&
704              (pffb->achName[0] != '.' ||
705               (pffb->achName[1] &&
706                (pffb->achName[1] != '.' || pffb->achName[2])))) {
707            if(fForceUpper)
708              strupr(pffb->achName);
709            else if(fForceLower)
710              strlwr(pffb->achName);
711            memcpy(enddir,pffb->achName,pffb->cchName + 1);
712            FillDirList(maskstr,skiplen,recurse,list,numfiles,numalloc);
713          }
714        }
715        else {
716          if(fForceUpper)
717            strupr(pffb->achName);
718          else if(fForceLower)
719            strlwr(pffb->achName);
720          memcpy(enddir,pffb->achName,pffb->cchName + 1);
721          if(AddToFileList(maskstr + skiplen,pffb,list,numfiles,numalloc))
722            goto Abort;
723        }
724        fb += pffb->oNextEntryOffset;
725        x++;
726      }
727      nm = ulM;
728      DosError(FERR_DISABLEHARDERR);
729      rc = DosFindNext(hDir,ffb4,sizeof(FILEFINDBUF4) * nm,&nm);
730    }
731Abort:
732    DosFindClose(hDir);
733    DosSleep(0L);
734  }
735  free(maskstr);
736  free(ffb4);
737}
738
739//=== CompNames() Compare names for qsort ===
740
741static int CompNames (const void *n1,const void *n2)
742{
743  FILELIST *fl1 = *(FILELIST **)n1;
744  FILELIST *fl2 = *(FILELIST **)n2;
745
746  return stricmp(fl1->fname,fl2->fname);
747}
748
749//=== FillCnrsThread() Fill left and right containers ===
750
751static VOID FillCnrsThread (VOID *args)
752{
753  COMPARE    *cmp = (COMPARE *)args;
754  HAB         hab;
755  HMQ         hmq;
756  BOOL        notified = FALSE;
757  static CHAR attrstring[] = "RHS\0DA";
758  HWND        hwndLeft,hwndRight;
759
760  if(!cmp)
761    _endthread();
762
763  DosError(FERR_DISABLEHARDERR);
764
765  hab = WinInitialize(0);
766  if(!hab)
767    Win_Error(NULLHANDLE,NULLHANDLE,pszSrcFile,__LINE__,"WinInitialize");
768  else {
769    hmq = WinCreateMsgQueue(hab,0);
770    if(!hmq)
771      Win_Error(NULLHANDLE,NULLHANDLE,pszSrcFile,__LINE__,"WinCreateMsgQueue");
772    else {
773      INT             x;
774      INT             l;
775      INT             r;
776      INT             y;
777      ULONG           cntr;
778      FILELIST        **filesl = NULL;
779      FILELIST        **filesr = NULL;
780      INT             numfilesl = 0;
781      INT             numfilesr = 0;
782      INT             numallocl = 0;
783      INT             numallocr = 0;
784      INT             lenl;                     // Directory prefix length
785      INT             lenr;
786      UINT            recsNeeded;               // fixme to check ovf
787      PCNRITEM        pcilFirst;
788      PCNRITEM        pcirFirst;
789      PCNRITEM        pcil;
790      PCNRITEM        pcir;
791      PCNRITEM        pcit;
792      RECORDINSERT    ri;
793      CHAR            *pch;
794
795      WinCancelShutdown(hmq,TRUE);
796      IncrThreadUsage();
797      hwndLeft = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
798      hwndRight = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
799      lenl = strlen(cmp->leftdir);
800      if(cmp->leftdir[strlen(cmp->leftdir) - 1] != '\\')
801        lenl++;
802      lenr = strlen(cmp->rightdir);
803      if(cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\')
804        lenr++;
805      priority_normal();
806      /* clear containers */
807      WinSendMsg(hwndRight,CM_REMOVERECORD,
808                 MPVOID,MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE));
809      WinSendMsg(hwndLeft,CM_REMOVERECORD,
810                 MPVOID,MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE));
811      cmp->cmp->totalleft = cmp->cmp->totalright = 0;
812
813      /* build list of all files in left directory */
814      if(fForceLower)
815        strlwr(cmp->leftdir);
816      else if(fForceUpper)
817        strupr(cmp->leftdir);
818      FillDirList(cmp->leftdir,lenl,cmp->includesubdirs,
819                  &filesl,&numfilesl,&numallocl);
820
821      if(filesl)
822        qsort(filesl,numfilesl,sizeof(CHAR *),CompNames);
823      /* build list of all files in right directory */
824      if(!*cmp->rightlist) {
825        if(fForceLower)
826          strlwr(cmp->rightdir);
827        else if(fForceUpper)
828          strupr(cmp->rightdir);
829        FillDirList(cmp->rightdir,lenr,cmp->includesubdirs,
830                    &filesr,&numfilesr,&numallocr);
831      }
832      else
833      {
834        /* use snapshot file */
835        FILE        *fp;
836        FILEFINDBUF4 fb4;
837        CHAR         str[CCHMAXPATH * 2],*p;
838
839        memset(&fb4,0,sizeof(fb4));
840        fp = fopen(cmp->rightlist,"r");
841        if(!fp)
842          Runtime_Error(pszSrcFile, __LINE__, "can not open %s (%d)", cmp->rightlist, errno);
843        else {
844          while (!feof(fp)) {
845            /* first get name of directory */
846            if (!xfgets_bstripcr(str,sizeof(str),fp,pszSrcFile,__LINE__))
847              break;            // EOF
848            p = str;
849            if(*p == '\"') {
850              /* Quoted */
851              p++;
852              if(*p && *p != '\"') {
853                p = strchr(p,'\"');
854                if(p) {
855                  *p = 0;
856                  if(*(str + 1)) {
857                    strcpy(cmp->rightdir,str + 1);
858                    if(fForceUpper)
859                      strupr(cmp->rightdir);
860                      else if(fForceLower)
861                      strlwr(cmp->rightdir);
862                    p = cmp->rightdir + (strlen(cmp->rightdir) - 1);
863                    if(p - cmp->rightdir > 3 && *p == '\\')
864                      *p = 0;           // Chop trailing slash
865                    break;
866                  }
867                }
868              }
869            }
870          } // while !EOF
871          {
872            CNRINFO cnri;
873
874            memset(&cnri,0,sizeof(cnri));
875            cnri.cb = sizeof(cnri);
876            cnri.pszCnrTitle = cmp->rightdir;
877            WinSendMsg(hwndRight,CM_SETCNRINFO,
878                       MPFROMP(&cnri),
879                       MPFROMLONG(CMA_CNRTITLE));
880          }
881          if(*cmp->rightdir) {
882            lenr = strlen(cmp->rightdir) +
883                     (cmp->rightdir[strlen(cmp->rightdir) - 1] != '\\');
884            while (!feof(fp)) {
885              if (!xfgets_bstripcr(str,sizeof(str),fp,pszSrcFile,__LINE__))
886                break;
887              p = str;
888              if(*p == '\"') {
889                p++;
890                if(*p && *p != '\"') {
891                  p = strchr(p,'\"');
892                  if(p) {
893                    *p = 0;
894                    p++;
895                    if(*p == ',') {
896                      p++;
897                      if(!cmp->includesubdirs && atol(p) > lenr)
898                        continue;
899                      p = strchr(p,',');
900                      if(p) {
901                        p++;
902                        fb4.cbFile = atol(p);
903                        p = strchr(p,',');
904                        if(p) {
905                          p++;
906                          fb4.fdateLastWrite.year = atol(p) - 1980;
907                          p = strchr(p,'/');
908                          if(p) {
909                            p++;
910                            fb4.fdateLastWrite.month = atol(p);
911                            p = strchr(p,'/');
912                            if(p) {
913                              p++;
914                              fb4.fdateLastWrite.day = atol(p);
915                              p = strchr(p,',');
916                              if(p) {
917                                p++;
918                                fb4.ftimeLastWrite.hours = atol(p);
919                                p = strchr(p,':');
920                                if(p) {
921                                  p++;
922                                  fb4.ftimeLastWrite.minutes = atol(p);
923                                  p = strchr(p,':');
924                                  if(p) {
925                                    p++;
926                                    fb4.ftimeLastWrite.twosecs = atol(p);
927                                    p = strchr(p,',');
928                                    if(p) {
929                                      p++;
930                                      fb4.attrFile = atol(p);
931                                      p = strchr(p,',');
932                                      if(p) {
933                                        p++;
934                                        fb4.cbList = atol(p) * 2;
935                                        if(fForceUpper)
936                                          strupr(str + 1);
937                                        else if(fForceLower)
938                                          strlwr(str + 1);
939                                        if(AddToFileList((str + 1) + lenr,
940                                                         &fb4,
941                                                         &filesr,
942                                                         &numfilesr,
943                                                         &numallocr))
944                                          break;
945                                      }
946                                    }
947                                  }
948                                }
949                              }
950                            }
951                          }
952                        }
953                      }
954                    }
955                  }
956                }
957              }
958            } // while
959          } // if have rightdir
960          fclose(fp);
961        }
962      } // if snapshot file
963
964      if(filesr)
965        qsort(filesr,numfilesr,sizeof(CHAR *),CompNames);
966
967      /* we now have two lists of files, both sorted. */
968      /* first, count total number of container entries required */
969      l = r = 0;
970      recsNeeded = 0;
971      while((filesl && filesl[l]) || (filesr && filesr[r])) {
972        if((filesl && filesl[l]) && (filesr && filesr[r])) {
973          x = stricmp(filesl[l]->fname,filesr[r]->fname);
974          if(!x) {
975            l++;                        // In both
976            r++;
977          }
978          else if(x < 0)
979            l++;                        // In left only
980          else
981            r++;                        // In right only
982        }
983        else if(filesl && filesl[l])
984          l++;                          // In left only
985        else    /* filesr && filesr[r] */
986          r++;                          // In right only
987        recsNeeded++; /* keep count of how many entries req'd */
988      }
989      WinSendMsg(cmp->hwnd,UM_CONTAINERHWND,MPVOID,MPVOID);
990      /* now insert records into the containers */
991      cntr = 0;
992      l = r = 0;
993      if(recsNeeded) {
994        pcilFirst = WinSendMsg(hwndLeft,
995                               CM_ALLOCRECORD,
996                               MPFROMLONG(EXTRA_RECORD_BYTES2),
997                               MPFROMLONG(recsNeeded));
998        if (!pcilFirst) {
999          Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD %u failed", recsNeeded);
1000          recsNeeded = 0;
1001        }
1002      }
1003      if (recsNeeded) {
1004        pcirFirst = WinSendMsg(hwndRight,CM_ALLOCRECORD,
1005                               MPFROMLONG(EXTRA_RECORD_BYTES2),
1006                               MPFROMLONG(recsNeeded));
1007        if (!pcirFirst) {
1008          Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD %u failed", recsNeeded);
1009          recsNeeded = 0;
1010          pcil = pcilFirst;
1011          while(pcil) {
1012            pcit = (PCNRITEM)pcil->rc.preccNextRecord;
1013            WinSendMsg(hwndLeft,CM_FREERECORD,
1014                       MPFROMP(&pcil),MPFROMSHORT(1));
1015            pcil = pcit;
1016          }
1017        }
1018      }
1019      if (recsNeeded) {
1020        pcil = pcilFirst;
1021        pcir = pcirFirst;
1022        while((filesl && filesl[l]) || (filesr && filesr[r])) {
1023          pcir->hwndCnr = hwndRight;
1024          pcir->pszFileName = pcir->szFileName;
1025          pcir->rc.pszIcon = pcir->pszFileName;
1026          pcir->rc.hptrIcon = (HPOINTER)0;
1027          pcir->pszSubject = pcir->szSubject;
1028          pcir->pszLongname = pcir->szLongname;
1029          pcir->pszDispAttr = pcir->szDispAttr;
1030          pcil->hwndCnr = hwndLeft;
1031          pcil->pszFileName = pcil->szFileName;
1032          pcil->rc.pszIcon = pcil->pszFileName;
1033          pcil->rc.hptrIcon = (HPOINTER)0;
1034          pcil->pszDispAttr = pcil->szDispAttr;
1035          pcil->pszSubject = pcil->szSubject;
1036          pcil->pszLongname = pcil->szLongname;
1037          if((filesl && filesl[l]) && (filesr && filesr[r])) {
1038            x = stricmp(filesl[l]->fname,filesr[r]->fname);
1039            if(!x) {
1040              // Same
1041              sprintf(pcil->szFileName,"%s%s%s",cmp->leftdir,
1042                      (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
1043                      NullStr : "\\",filesl[l]->fname);
1044              // pcil->rc.hptrIcon    = hptrFile;
1045              pcil->pszFileName    = pcil->szFileName + lenl;
1046              pcil->attrFile       = filesl[l]->attrFile;
1047              y = 0;
1048              for(x = 0;x < 6;x++) {
1049                if(attrstring[x])
1050                  pcil->szDispAttr[y++] = (CHAR)((pcil->attrFile & (1 << x)) ?
1051                                                 attrstring[x] : '-');
1052              }
1053              pcil->szDispAttr[5]  = 0;
1054              pcil->cbFile         = filesl[l]->cbFile;
1055              pcil->easize         = filesl[l]->easize;
1056              pcil->date.day       = filesl[l]->date.day;
1057              pcil->date.month     = filesl[l]->date.month;
1058              pcil->date.year      = filesl[l]->date.year + 1980;
1059              pcil->time.seconds   = filesl[l]->time.twosecs * 2;
1060              pcil->time.minutes   = filesl[l]->time.minutes;
1061              pcil->time.hours     = filesl[l]->time.hours;
1062              pcil->ladate.day     = filesl[l]->ladate.day;
1063              pcil->ladate.month   = filesl[l]->ladate.month;
1064              pcil->ladate.year    = filesl[l]->ladate.year + 1980;
1065              pcil->latime.seconds = filesl[l]->latime.twosecs * 2;
1066              pcil->latime.minutes = filesl[l]->latime.minutes;
1067              pcil->latime.hours   = filesl[l]->latime.hours;
1068              pcil->crdate.day     = filesl[l]->crdate.day;
1069              pcil->crdate.month   = filesl[l]->crdate.month;
1070              pcil->crdate.year    = filesl[l]->crdate.year + 1980;
1071              pcil->crtime.seconds = filesl[l]->crtime.twosecs * 2;
1072              pcil->crtime.minutes = filesl[l]->crtime.minutes;
1073              pcil->crtime.hours   = filesl[l]->crtime.hours;
1074              if (*cmp->dcd.mask.szMask) {
1075                if(!Filter((PMINIRECORDCORE)pcil,(PVOID)&cmp->dcd.mask)) {
1076                  pcil->rc.flRecordAttr |= CRA_FILTERED;
1077                  pcir->rc.flRecordAttr |= CRA_FILTERED;
1078                }
1079              }
1080              sprintf(pcir->szFileName,"%s%s%s",cmp->rightdir,
1081                      (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
1082                      NullStr : "\\",filesr[r]->fname);
1083              pcir->pszFileName    = pcir->szFileName + lenr;
1084              pcir->attrFile       = filesr[r]->attrFile;
1085              // pcir->rc.hptrIcon    = hptrFile;
1086              y = 0;
1087              for(x = 0;x < 6;x++)
1088                if(attrstring[x])
1089                  pcir->szDispAttr[y++] = (CHAR)((pcir->attrFile & (1 << x)) ?
1090                                                 attrstring[x] : '-');
1091              pcir->szDispAttr[5]  = 0;
1092              pcir->cbFile         = filesr[r]->cbFile;
1093              pcir->easize         = filesr[r]->easize;
1094              pcir->date.day       = filesr[r]->date.day;
1095              pcir->date.month     = filesr[r]->date.month;
1096              pcir->date.year      = filesr[r]->date.year + 1980;
1097              pcir->time.seconds   = filesr[r]->time.twosecs * 2;
1098              pcir->time.minutes   = filesr[r]->time.minutes;
1099              pcir->time.hours     = filesr[r]->time.hours;
1100              pcir->ladate.day     = filesr[r]->ladate.day;
1101              pcir->ladate.month   = filesr[r]->ladate.month;
1102              pcir->ladate.year    = filesr[r]->ladate.year + 1980;
1103              pcir->latime.seconds = filesr[r]->latime.twosecs * 2;
1104              pcir->latime.minutes = filesr[r]->latime.minutes;
1105              pcir->latime.hours   = filesr[r]->latime.hours;
1106              pcir->crdate.day     = filesr[r]->crdate.day;
1107              pcir->crdate.month   = filesr[r]->crdate.month;
1108              pcir->crdate.year    = filesr[r]->crdate.year + 1980;
1109              pcir->crtime.seconds = filesr[r]->crtime.twosecs * 2;
1110              pcir->crtime.minutes = filesr[r]->crtime.minutes;
1111              pcir->crtime.hours   = filesr[r]->crtime.hours;
1112              pcil->flags |= CNRITEM_EXISTS;
1113              pcir->flags |= CNRITEM_EXISTS;
1114              pch = pcil->szSubject;
1115              if(pcil->cbFile + pcil->easize >
1116                 pcir->cbFile + pcir->easize) {
1117                pcil->flags |= CNRITEM_LARGER;
1118                pcir->flags |= CNRITEM_SMALLER;
1119                strcpy(pch,GetPString(IDS_LARGERTEXT));
1120                pch += 6;
1121              }
1122              else if(pcil->cbFile + pcil->easize <
1123                      pcir->cbFile + pcir->easize) {
1124                pcil->flags |= CNRITEM_SMALLER;
1125                pcir->flags |= CNRITEM_LARGER;
1126                strcpy(pch,GetPString(IDS_SMALLERTEXT));
1127                pch += 7;
1128              }
1129              if((pcil->date.year > pcir->date.year) ? TRUE :
1130                 (pcil->date.year < pcir->date.year) ? FALSE :
1131                 (pcil->date.month > pcir->date.month) ? TRUE :
1132                 (pcil->date.month < pcir->date.month) ? FALSE :
1133                 (pcil->date.day > pcir->date.day) ? TRUE :
1134                 (pcil->date.day < pcir->date.day) ? FALSE :
1135                 (pcil->time.hours > pcir->time.hours) ? TRUE :
1136                 (pcil->time.hours < pcir->time.hours) ? FALSE :
1137                 (pcil->time.minutes > pcir->time.minutes) ? TRUE :
1138                 (pcil->time.minutes < pcir->time.minutes) ? FALSE :
1139                 (pcil->time.seconds > pcir->time.seconds) ? TRUE :
1140                 (pcil->time.seconds < pcir->time.seconds) ? FALSE : FALSE) {
1141                pcil->flags |= CNRITEM_NEWER;
1142                pcir->flags |= CNRITEM_OLDER;
1143                if(pch != pcil->szSubject) {
1144                  strcpy(pch,", ");
1145                  pch += 2;
1146                }
1147                strcpy(pch,GetPString(IDS_NEWERTEXT));
1148                pch += 5;
1149              }
1150              else if((pcil->date.year < pcir->date.year) ? TRUE :
1151                      (pcil->date.year > pcir->date.year) ? FALSE :
1152                      (pcil->date.month < pcir->date.month) ? TRUE :
1153                      (pcil->date.month > pcir->date.month) ? FALSE :
1154                      (pcil->date.day < pcir->date.day) ? TRUE :
1155                      (pcil->date.day > pcir->date.day) ? FALSE :
1156                      (pcil->time.hours < pcir->time.hours) ? TRUE :
1157                      (pcil->time.hours > pcir->time.hours) ? FALSE :
1158                      (pcil->time.minutes < pcir->time.minutes) ? TRUE :
1159                      (pcil->time.minutes > pcir->time.minutes) ? FALSE :
1160                      (pcil->time.seconds < pcir->time.seconds) ? TRUE :
1161                      (pcil->time.seconds > pcir->time.seconds) ? FALSE :
1162                      FALSE) {
1163                pcil->flags |= CNRITEM_OLDER;
1164                pcir->flags |= CNRITEM_NEWER;
1165                if(pch != pcil->szSubject) {
1166                  strcpy(pch,", ");
1167                  pch += 2;
1168                }
1169                strcpy(pch,GetPString(IDS_OLDERTEXT));
1170                pch += 5;
1171              }
1172              *pch = 0;
1173              r++;
1174              l++;
1175            }
1176            else if(x < 0) {
1177              // Just on left
1178              sprintf(pcil->szFileName,"%s%s%s",cmp->leftdir,
1179                      (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
1180                      NullStr : "\\",filesl[l]->fname);
1181              pcil->pszFileName = pcil->szFileName + lenl;
1182              pcil->attrFile       = filesl[l]->attrFile;
1183              // pcil->rc.hptrIcon    = hptrFile;
1184              y = 0;
1185              for(x = 0;x < 6;x++)
1186                if(attrstring[x])
1187                  pcil->szDispAttr[y++] = (CHAR)((pcil->attrFile & (1 << x)) ?
1188                                                 attrstring[x] : '-');
1189              pcil->szDispAttr[5]  = 0;
1190              pcil->cbFile         = filesl[l]->cbFile;
1191              pcil->easize         = filesl[l]->easize;
1192              pcil->date.day       = filesl[l]->date.day;
1193              pcil->date.month     = filesl[l]->date.month;
1194              pcil->date.year      = filesl[l]->date.year + 1980;
1195              pcil->time.seconds   = filesl[l]->time.twosecs * 2;
1196              pcil->time.minutes   = filesl[l]->time.minutes;
1197              pcil->time.hours     = filesl[l]->time.hours;
1198              pcil->ladate.day     = filesl[l]->ladate.day;
1199              pcil->ladate.month   = filesl[l]->ladate.month;
1200              pcil->ladate.year    = filesl[l]->ladate.year + 1980;
1201              pcil->latime.seconds = filesl[l]->latime.twosecs * 2;
1202              pcil->latime.minutes = filesl[l]->latime.minutes;
1203              pcil->latime.hours   = filesl[l]->latime.hours;
1204              pcil->crdate.day     = filesl[l]->crdate.day;
1205              pcil->crdate.month   = filesl[l]->crdate.month;
1206              pcil->crdate.year    = filesl[l]->crdate.year + 1980;
1207              pcil->crtime.seconds = filesl[l]->crtime.twosecs * 2;
1208              pcil->crtime.minutes = filesl[l]->crtime.minutes;
1209              pcil->crtime.hours   = filesl[l]->crtime.hours;
1210              if (*cmp->dcd.mask.szMask) {
1211                if (!Filter((PMINIRECORDCORE)pcil,(PVOID)&cmp->dcd.mask)) {
1212                  pcil->rc.flRecordAttr |= CRA_FILTERED;
1213                  pcir->rc.flRecordAttr |= CRA_FILTERED;
1214                }
1215              }
1216              free(filesl[l]);
1217              l++;
1218            }
1219            else {
1220              // Just on right
1221              sprintf(pcir->szFileName,"%s%s%s",cmp->rightdir,
1222                      (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
1223                      NullStr : "\\",filesr[r]->fname);
1224              pcir->pszFileName    = pcir->szFileName + lenr;
1225              pcir->attrFile       = filesr[r]->attrFile;
1226              // pcir->rc.hptrIcon    = hptrFile;
1227              y = 0;
1228              for (x = 0;x < 6;x++) {
1229                if (attrstring[x])
1230                  pcir->szDispAttr[y++] = (CHAR)((pcir->attrFile & (1 << x)) ?
1231                                                 attrstring[x] : '-');
1232              }
1233              pcir->szDispAttr[5]  = 0;
1234              pcir->cbFile         = filesr[r]->cbFile;
1235              pcir->easize         = filesr[r]->easize;
1236              pcir->date.day       = filesr[r]->date.day;
1237              pcir->date.month     = filesr[r]->date.month;
1238              pcir->date.year      = filesr[r]->date.year + 1980;
1239              pcir->time.seconds   = filesr[r]->time.twosecs * 2;
1240              pcir->time.minutes   = filesr[r]->time.minutes;
1241              pcir->time.hours     = filesr[r]->time.hours;
1242              pcir->ladate.day     = filesr[r]->ladate.day;
1243              pcir->ladate.month   = filesr[r]->ladate.month;
1244              pcir->ladate.year    = filesr[r]->ladate.year + 1980;
1245              pcir->latime.seconds = filesr[r]->latime.twosecs * 2;
1246              pcir->latime.minutes = filesr[r]->latime.minutes;
1247              pcir->latime.hours   = filesr[r]->latime.hours;
1248              pcir->crdate.day     = filesr[r]->crdate.day;
1249              pcir->crdate.month   = filesr[r]->crdate.month;
1250              pcir->crdate.year    = filesr[r]->crdate.year + 1980;
1251              pcir->crtime.seconds = filesr[r]->crtime.twosecs * 2;
1252              pcir->crtime.minutes = filesr[r]->crtime.minutes;
1253              pcir->crtime.hours   = filesr[r]->crtime.hours;
1254              if(*cmp->dcd.mask.szMask) {
1255                if(!Filter((PMINIRECORDCORE)pcir,(PVOID)&cmp->dcd.mask)) {
1256                  pcir->rc.flRecordAttr |= CRA_FILTERED;
1257                  pcil->rc.flRecordAttr |= CRA_FILTERED;
1258                }
1259              }
1260              free(filesr[r]);
1261              r++;
1262            }
1263          }
1264          else if(filesl && filesl[l]) {
1265            // Just on left
1266            sprintf(pcil->szFileName,"%s%s%s",cmp->leftdir,
1267                    (cmp->leftdir[strlen(cmp->leftdir) - 1] == '\\') ?
1268                    NullStr : "\\",filesl[l]->fname);
1269            pcil->pszFileName = pcil->szFileName + lenl;
1270            pcil->attrFile       = filesl[l]->attrFile;
1271            // pcil->rc.hptrIcon    = hptrFile;
1272            y = 0;
1273            for(x = 0;x < 6;x++)
1274              if(attrstring[x])
1275                pcil->szDispAttr[y++] = (CHAR)((pcil->attrFile & (1 << x)) ?
1276                                               attrstring[x] : '-');
1277            pcil->szDispAttr[5]  = 0;
1278            pcil->cbFile         = filesl[l]->cbFile;
1279            pcil->easize         = filesl[l]->easize;
1280            pcil->date.day       = filesl[l]->date.day;
1281            pcil->date.month     = filesl[l]->date.month;
1282            pcil->date.year      = filesl[l]->date.year + 1980;
1283            pcil->time.seconds   = filesl[l]->time.twosecs * 2;
1284            pcil->time.minutes   = filesl[l]->time.minutes;
1285            pcil->time.hours     = filesl[l]->time.hours;
1286            pcil->ladate.day     = filesl[l]->ladate.day;
1287            pcil->ladate.month   = filesl[l]->ladate.month;
1288            pcil->ladate.year    = filesl[l]->ladate.year + 1980;
1289            pcil->latime.seconds = filesl[l]->latime.twosecs * 2;
1290            pcil->latime.minutes = filesl[l]->latime.minutes;
1291            pcil->latime.hours   = filesl[l]->latime.hours;
1292            pcil->crdate.day     = filesl[l]->crdate.day;
1293            pcil->crdate.month   = filesl[l]->crdate.month;
1294            pcil->crdate.year    = filesl[l]->crdate.year + 1980;
1295            pcil->crtime.seconds = filesl[l]->crtime.twosecs * 2;
1296            pcil->crtime.minutes = filesl[l]->crtime.minutes;
1297            pcil->crtime.hours   = filesl[l]->crtime.hours;
1298            if(*cmp->dcd.mask.szMask) {
1299              if(!Filter((PMINIRECORDCORE)pcil,(PVOID)&cmp->dcd.mask)) {
1300                pcil->rc.flRecordAttr |= CRA_FILTERED;
1301                pcir->rc.flRecordAttr |= CRA_FILTERED;
1302              }
1303            }
1304            free(filesl[l]);
1305            l++;
1306          }
1307          else {
1308            /* filesr && filesr[r] */
1309            // Just on right
1310            sprintf(pcir->szFileName,"%s%s%s",cmp->rightdir,
1311                    (cmp->rightdir[strlen(cmp->rightdir) - 1] == '\\') ?
1312                    NullStr : "\\",filesr[r]->fname);
1313            pcir->pszFileName    = pcir->szFileName + lenr;
1314            pcir->attrFile       = filesr[r]->attrFile;
1315            // pcir->rc.hptrIcon    = hptrFile;
1316            y = 0;
1317            for (x = 0;x < 6;x++) {
1318              if(attrstring[x])
1319                pcir->szDispAttr[y++] = (CHAR)((pcir->attrFile & (1 << x)) ?
1320                                               attrstring[x] : '-');
1321            }
1322            pcir->szDispAttr[5]  = 0;
1323            pcir->cbFile         = filesr[r]->cbFile;
1324            pcir->easize         = filesr[r]->easize;
1325            pcir->date.day       = filesr[r]->date.day;
1326            pcir->date.month     = filesr[r]->date.month;
1327            pcir->date.year      = filesr[r]->date.year + 1980;
1328            pcir->time.seconds   = filesr[r]->time.twosecs * 2;
1329            pcir->time.minutes   = filesr[r]->time.minutes;
1330            pcir->time.hours     = filesr[r]->time.hours;
1331            pcir->ladate.day     = filesr[r]->ladate.day;
1332            pcir->ladate.month   = filesr[r]->ladate.month;
1333            pcir->ladate.year    = filesr[r]->ladate.year + 1980;
1334            pcir->latime.seconds = filesr[r]->latime.twosecs * 2;
1335            pcir->latime.minutes = filesr[r]->latime.minutes;
1336            pcir->latime.hours   = filesr[r]->latime.hours;
1337            pcir->crdate.day     = filesr[r]->crdate.day;
1338            pcir->crdate.month   = filesr[r]->crdate.month;
1339            pcir->crdate.year    = filesr[r]->crdate.year + 1980;
1340            pcir->crtime.seconds = filesr[r]->crtime.twosecs * 2;
1341            pcir->crtime.minutes = filesr[r]->crtime.minutes;
1342            pcir->crtime.hours   = filesr[r]->crtime.hours;
1343            if (*cmp->dcd.mask.szMask) {
1344              if (!Filter((PMINIRECORDCORE)pcir,(PVOID)&cmp->dcd.mask)) {
1345                pcir->rc.flRecordAttr |= CRA_FILTERED;
1346                pcil->rc.flRecordAttr |= CRA_FILTERED;
1347              }
1348            }
1349            free(filesr[r]);
1350            r++;
1351          }
1352          if(!(cntr % 500))
1353            DosSleep(1L);
1354          else if(!(cntr % 50))
1355            DosSleep(0L);
1356          cntr++;
1357          pcil = (PCNRITEM)pcil->rc.preccNextRecord;
1358          pcir = (PCNRITEM)pcir->rc.preccNextRecord;
1359        } // while
1360        if(filesl)
1361          free(filesl);                 // Free header - have already freed elements
1362        filesl = NULL;
1363        if(filesr)
1364          free(filesr);
1365        filesr = NULL;
1366        /* insert 'em */
1367        WinSendMsg(cmp->hwnd,UM_CONTAINERDIR,MPVOID,MPVOID);
1368        memset(&ri, 0, sizeof(RECORDINSERT));
1369        ri.cb                 = sizeof(RECORDINSERT);
1370        ri.pRecordOrder       = (PRECORDCORE)CMA_END;
1371        ri.pRecordParent      = (PRECORDCORE)NULL;
1372        ri.zOrder             = (ULONG)CMA_TOP;
1373        ri.cRecordsInsert     = recsNeeded;
1374        ri.fInvalidateRecord  = FALSE;
1375        if (!WinSendMsg(hwndLeft,CM_INSERTRECORD,
1376                       MPFROMP(pcilFirst),MPFROMP(&ri))) {
1377          pcil = pcilFirst;
1378          while (pcil) {
1379            pcit = (PCNRITEM)pcil->rc.preccNextRecord;
1380            WinSendMsg(hwndLeft,CM_FREERECORD,
1381                       MPFROMP(&pcil),MPFROMSHORT(1));
1382            pcil = pcit;
1383          }
1384          numfilesl = 0;
1385        }
1386        memset(&ri, 0, sizeof(RECORDINSERT));
1387        ri.cb                 = sizeof(RECORDINSERT);
1388        ri.pRecordOrder       = (PRECORDCORE)CMA_END;
1389        ri.pRecordParent      = (PRECORDCORE)NULL;
1390        ri.zOrder             = (ULONG)CMA_TOP;
1391        ri.cRecordsInsert     = recsNeeded;
1392        ri.fInvalidateRecord  = FALSE;
1393        if (!WinSendMsg(hwndRight,CM_INSERTRECORD,
1394                       MPFROMP(pcirFirst),MPFROMP(&ri))) {
1395          WinSendMsg(hwndLeft,CM_REMOVERECORD,
1396                     MPVOID,MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE));
1397          pcir = pcirFirst;
1398          while (pcir) {
1399            pcit = (PCNRITEM)pcir->rc.preccNextRecord;
1400            WinSendMsg(hwndRight,CM_FREERECORD,
1401                       MPFROMP(&pcir),MPFROMSHORT(1));
1402            pcir = pcit;
1403          }
1404          numfilesr = 0;
1405        }
1406        cmp->cmp->totalleft = numfilesl;
1407        cmp->cmp->totalright = numfilesr;
1408      } // if recsNeeded
1409      Deselect(hwndLeft);
1410      Deselect(hwndRight);
1411      if (!PostMsg(cmp->hwnd,UM_CONTAINER_FILLED,MPVOID,MPVOID))
1412        WinSendMsg (cmp->hwnd,UM_CONTAINER_FILLED,MPVOID,MPVOID);
1413      notified = TRUE;
1414      if (filesl)
1415        FreeList((CHAR **)filesl);      // Must have failed to create container
1416      if (filesr)
1417        FreeList((CHAR **)filesr);
1418      WinDestroyMsgQueue(hmq);
1419    }
1420    DecrThreadUsage();
1421    WinTerminate(hab);
1422  }
1423  if (!notified)
1424    PostMsg(cmp->hwnd,UM_CONTAINER_FILLED,MPVOID,MPVOID);
1425  free(cmp);
1426  DosPostEventSem(CompactSem);
1427}
1428
1429#define hwndLeft  (WinWindowFromID(hwnd,COMP_LEFTDIR))
1430#define hwndRight (WinWindowFromID(hwnd,COMP_RIGHTDIR))
1431
1432//=== CompareDlgProc() Compare directories dialog procedure ===
1433
1434MRESULT EXPENTRY CompareDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
1435{
1436  COMPARE        *cmp;
1437
1438  static HPOINTER hptr = (HPOINTER)0;
1439
1440  switch(msg) {
1441    case WM_INITDLG:
1442      cmp = (COMPARE *)mp2;
1443      if (!cmp) {
1444        Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1445        WinDismissDlg(hwnd,0);
1446      }
1447      else {
1448        if (!hptr)
1449          hptr = WinLoadPointer(HWND_DESKTOP,FM3ModHandle,COMPARE_ICON);
1450        WinDefDlgProc(hwnd,WM_SETICON,MPFROMLONG(hptr),MPVOID);
1451        cmp->hwnd = hwnd;
1452        WinSetWindowPtr(hwnd,QWL_USER,(PVOID)cmp);
1453        SetCnrCols(hwndLeft,TRUE);
1454        SetCnrCols(hwndRight,TRUE);
1455        WinSendMsg(hwnd,UM_SETUP,MPVOID,MPVOID);
1456        WinSendMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
1457        PostMsg(hwnd,UM_STRETCH,MPVOID,MPVOID);
1458        {
1459          USHORT       ids[] = {COMP_LEFTDIR,COMP_RIGHTDIR,COMP_TOTALLEFT,
1460                                COMP_TOTALRIGHT,COMP_SELLEFT,COMP_SELRIGHT,
1461                                0};
1462          register INT x;
1463
1464          for(x = 0;ids[x];x++)
1465            SetPresParams(WinWindowFromID(hwnd,ids[x]),
1466                          &RGBGREY,
1467                          &RGBBLACK,
1468                          &RGBBLACK,
1469                          GetPString(IDS_8HELVTEXT));
1470        }
1471      }
1472      break;
1473
1474    case UM_STRETCH:
1475      {
1476        SWP  swp,swpC;
1477        LONG titl,szbx,szby,sz;
1478        HWND hwndActive;
1479
1480        WinQueryWindowPos(hwnd,&swp);
1481        if(!(swp.fl & (SWP_HIDE | SWP_MINIMIZE))) {
1482          hwndActive = WinQueryFocus(HWND_DESKTOP);
1483          szbx = SysVal(SV_CXSIZEBORDER);
1484          szby = SysVal(SV_CYSIZEBORDER);
1485          titl = SysVal(SV_CYTITLEBAR);
1486          titl += 26;
1487          swp.cx -= (szbx * 2);
1488          sz = (swp.cx / 8);
1489          WinQueryWindowPos(WinWindowFromID(hwnd,COMP_LEFTDIR),&swpC);
1490          WinSetWindowPos(WinWindowFromID(hwnd,COMP_LEFTDIR),HWND_TOP,
1491                          szbx + 6,
1492                          swpC.y,
1493                          (swp.cx / 2) - (szbx + 6),
1494                          ((swp.cy - swpC.y) - titl) - szby,
1495                          SWP_MOVE | SWP_SIZE);
1496          WinSetWindowPos(WinWindowFromID(hwnd,COMP_RIGHTDIR),HWND_TOP,
1497                          (swp.cx / 2) + (szbx + 6),
1498                          swpC.y,
1499                          (swp.cx / 2) - (szbx + 6),
1500                          ((swp.cy - swpC.y) - titl) - szby,
1501                          SWP_MOVE | SWP_SIZE);
1502          WinSetWindowPos(WinWindowFromID(hwnd,COMP_TOTALLEFTHDR),HWND_TOP,
1503                          szbx + 6,
1504                          ((swp.cy - titl) - szby) + 4,
1505                          sz - (szbx + 6),
1506                          20,
1507                          SWP_MOVE | SWP_SIZE);
1508          WinSetWindowPos(WinWindowFromID(hwnd,COMP_TOTALLEFT),HWND_TOP,
1509                          sz + (szbx + 6),
1510                          ((swp.cy - titl) - szby) + 4,
1511                          sz - (szbx + 6),
1512                          20,
1513                          SWP_MOVE | SWP_SIZE);
1514          WinSetWindowPos(WinWindowFromID(hwnd,COMP_SELLEFTHDR),HWND_TOP,
1515                          (sz * 2) + (szbx + 6),
1516                          ((swp.cy - titl) - szby) + 4,
1517                          sz - (szbx + 6),
1518                          20,
1519                          SWP_MOVE | SWP_SIZE);
1520          WinSetWindowPos(WinWindowFromID(hwnd,COMP_SELLEFT),HWND_TOP,
1521                          (sz * 3) + (szbx + 6),
1522                          ((swp.cy - titl) - szby) + 4,
1523                          sz - (szbx + 6),
1524                          20,
1525                          SWP_MOVE | SWP_SIZE);
1526          WinSetWindowPos(WinWindowFromID(hwnd,COMP_TOTALRIGHTHDR),HWND_TOP,
1527                          (sz * 4) + (szbx + 6),
1528                          ((swp.cy - titl) - szby) + 4,
1529                          sz - (szbx + 6),
1530                          20,
1531                          SWP_MOVE | SWP_SIZE);
1532          WinSetWindowPos(WinWindowFromID(hwnd,COMP_TOTALRIGHT),HWND_TOP,
1533                          (sz * 5) + (szbx + 6),
1534                          ((swp.cy - titl) - szby) + 4,
1535                          sz - (szbx + 6),
1536                          20,
1537                          SWP_MOVE | SWP_SIZE);
1538          WinSetWindowPos(WinWindowFromID(hwnd,COMP_SELRIGHTHDR),HWND_TOP,
1539                          (sz * 6) + (szbx + 6),
1540                          ((swp.cy - titl) - szby) + 4,
1541                          sz - (szbx + 6),
1542                          20,
1543                          SWP_MOVE | SWP_SIZE);
1544          WinSetWindowPos(WinWindowFromID(hwnd,COMP_SELRIGHT),HWND_TOP,
1545                          (sz * 7) + (szbx + 6),
1546                          ((swp.cy - titl) - szby) + 4,
1547                          sz - (szbx + 6),
1548                          20,
1549                          SWP_MOVE | SWP_SIZE);
1550          PaintRecessedWindow(WinWindowFromID(hwnd,COMP_TOTALLEFT),
1551                              (HPS)0,FALSE,FALSE);
1552          PaintRecessedWindow(WinWindowFromID(hwnd,COMP_SELLEFT),
1553                              (HPS)0,FALSE,FALSE);
1554          PaintRecessedWindow(WinWindowFromID(hwnd,COMP_TOTALRIGHT),
1555                              (HPS)0,FALSE,FALSE);
1556          PaintRecessedWindow(WinWindowFromID(hwnd,COMP_SELRIGHT),
1557                              (HPS)0,FALSE,FALSE);
1558          PaintRecessedWindow(hwndLeft,(HPS)0,
1559                              (hwndActive == hwndLeft),
1560                              TRUE);
1561          PaintRecessedWindow(hwndRight,(HPS)0,
1562                              (hwndActive == hwndRight),
1563                              TRUE);
1564        }
1565      }
1566      return 0;
1567
1568    case WM_ADJUSTWINDOWPOS:
1569      PostMsg(hwnd,UM_STRETCH,MPVOID,MPVOID);
1570      break;
1571
1572    case UM_SETUP:
1573      {
1574        CNRINFO cnri;
1575        BOOL    tempsubj;
1576
1577        cmp = INSTDATA(hwnd);
1578        if(cmp) {
1579          cmp->dcd.size = sizeof(DIRCNRDATA);
1580          cmp->dcd.type = DIR_FRAME;
1581          cmp->dcd.hwndFrame = hwnd;
1582          cmp->dcd.hwndClient = hwnd;
1583          cmp->dcd.mask.attrFile = (FILE_DIRECTORY | FILE_ARCHIVED |
1584                                    FILE_READONLY  | FILE_SYSTEM   |
1585                                    FILE_HIDDEN);
1586          LoadDetailsSwitches("DirCmp",&cmp->dcd);
1587          cmp->dcd.detailslongname = FALSE;
1588          cmp->dcd.detailsicon     = FALSE; /* TRUE; */
1589        }
1590        memset(&cnri,0,sizeof(CNRINFO));
1591        cnri.cb = sizeof(CNRINFO);
1592        WinSendDlgItemMsg(hwnd,COMP_LEFTDIR,CM_QUERYCNRINFO,
1593                          MPFROMP(&cnri),MPFROMLONG(sizeof(CNRINFO)));
1594        cnri.flWindowAttr |= (CA_OWNERDRAW | CV_MINI);
1595        cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 68;
1596        WinSendDlgItemMsg(hwnd,COMP_LEFTDIR,CM_SETCNRINFO,MPFROMP(&cnri),
1597                          MPFROMLONG(CMA_FLWINDOWATTR | CMA_XVERTSPLITBAR));
1598        memset(&cnri,0,sizeof(CNRINFO));
1599        cnri.cb = sizeof(CNRINFO);
1600        WinSendDlgItemMsg(hwnd,COMP_RIGHTDIR,CM_QUERYCNRINFO,
1601                          MPFROMP(&cnri),MPFROMLONG(sizeof(CNRINFO)));
1602        cnri.flWindowAttr |= (CA_OWNERDRAW | CV_MINI);
1603        cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 54;
1604        WinSendDlgItemMsg(hwnd,COMP_RIGHTDIR,CM_SETCNRINFO,MPFROMP(&cnri),
1605                          MPFROMLONG(CMA_FLWINDOWATTR | CMA_XVERTSPLITBAR));
1606        AdjustCnrColRO(hwndLeft,GetPString(IDS_FILENAMECOLTEXT),
1607                       TRUE,FALSE);
1608        AdjustCnrColRO(hwndLeft,GetPString(IDS_LONGNAMECOLTEXT),
1609                       TRUE,FALSE);
1610        AdjustCnrColRO(hwndRight,GetPString(IDS_FILENAMECOLTEXT),
1611                       TRUE,FALSE);
1612        AdjustCnrColRO(hwndRight,GetPString(IDS_LONGNAMECOLTEXT),
1613                       TRUE,FALSE);
1614        AdjustCnrColsForPref(hwndLeft,
1615                             cmp->leftdir,&cmp->dcd,TRUE);
1616        tempsubj = cmp->dcd.detailssubject;
1617        cmp->dcd.detailssubject = FALSE;
1618        AdjustCnrColsForPref(hwndRight,
1619                             cmp->rightdir,&cmp->dcd,TRUE);
1620        if(*cmp->rightlist) {
1621          AdjustCnrColVis(hwndRight,GetPString(IDS_LADATECOLTEXT),FALSE,FALSE);
1622          AdjustCnrColVis(hwndRight,GetPString(IDS_LATIMECOLTEXT),FALSE,FALSE);
1623          AdjustCnrColVis(hwndRight,GetPString(IDS_CRDATECOLTEXT),FALSE,FALSE);
1624          AdjustCnrColVis(hwndRight,GetPString(IDS_CRTIMECOLTEXT),FALSE,FALSE);
1625        }
1626        cmp->dcd.detailssubject = tempsubj;
1627      }
1628      return 0;
1629
1630    case WM_DRAWITEM:
1631      if(mp2) {
1632
1633        POWNERITEM       pown = (POWNERITEM)mp2;
1634        PCNRDRAWITEMINFO pcown;
1635        PCNRITEM         pci;
1636
1637        pcown = (PCNRDRAWITEMINFO)pown->hItem;
1638        if(pcown) {
1639          pci = (PCNRITEM)pcown->pRecord;
1640          if(pci && (INT)pci != -1 && !*pci->szFileName)
1641            return MRFROMLONG(TRUE);
1642        }
1643      }
1644      return 0;
1645
1646    case UM_CONTAINERHWND:
1647      WinSetDlgItemText(hwnd,COMP_NOTE,
1648                        GetPString(IDS_COMPHOLDBLDLISTTEXT));
1649      return 0;
1650
1651    case UM_CONTAINERDIR:
1652      WinSetDlgItemText(hwnd,COMP_NOTE,
1653                        GetPString(IDS_COMPHOLDFILLCNRTEXT));
1654      return 0;
1655
1656    case UM_CONTAINER_FILLED:
1657      cmp = INSTDATA(hwnd);
1658      if (!cmp) {
1659        Runtime_Error(pszSrcFile, __LINE__, "pCompare NULL");
1660        WinDismissDlg(hwnd,0);
1661      }
1662      else {
1663        CHAR s[81];
1664        cmp->filling = FALSE;
1665        WinEnableWindow(hwndLeft,TRUE);
1666        WinEnableWindow(hwndRight,TRUE);
1667        WinEnableWindowUpdate(hwndLeft,TRUE);
1668        WinEnableWindowUpdate(hwndRight,TRUE);
1669        sprintf(s," %d",cmp->totalleft);
1670        WinSetDlgItemText(hwnd,COMP_TOTALLEFT,s);
1671        sprintf(s," %d",cmp->totalright);
1672        WinSetDlgItemText(hwnd,COMP_TOTALRIGHT,s);
1673        sprintf(s," %d",cmp->selleft);
1674        WinSetDlgItemText(hwnd,COMP_SELLEFT,s);
1675        sprintf(s," %d",cmp->selright);
1676        WinSetDlgItemText(hwnd,COMP_SELRIGHT,s);
1677        WinEnableWindow(WinWindowFromID(hwnd,DID_OK),TRUE);
1678        WinEnableWindow(WinWindowFromID(hwnd,DID_CANCEL),TRUE);
1679        WinEnableWindow(WinWindowFromID(hwnd,COMP_COLLECT),TRUE);
1680        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBOTH),TRUE);
1681        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTONE),TRUE);
1682        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTNEWER),TRUE);
1683        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTOLDER),TRUE);
1684        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBIGGER),TRUE);
1685        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSMALLER),TRUE);
1686        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBOTH),TRUE);
1687        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTONE),TRUE);
1688        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTNEWER),TRUE);
1689        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTOLDER),TRUE);
1690        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBIGGER),TRUE);
1691        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTSMALLER),TRUE);
1692        WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTALL),TRUE);
1693        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAMECONTENT),TRUE);
1694        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTIDENTICAL),TRUE);
1695        WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAME),TRUE);
1696        WinEnableWindow(WinWindowFromID(hwnd,IDM_INVERT),TRUE);
1697        WinEnableWindow(WinWindowFromID(hwnd,COMP_SETDIRS),TRUE);
1698        WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETELEFT),TRUE);
1699        WinEnableWindow(WinWindowFromID(hwnd,COMP_FILTER),TRUE);
1700        if(!*cmp->rightlist) {
1701          WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYLEFT),TRUE);
1702          WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVELEFT),TRUE);
1703          WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETERIGHT),TRUE);
1704          WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYRIGHT),TRUE);
1705          WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVERIGHT),TRUE);
1706        }
1707        WinEnableWindow(WinWindowFromID(hwnd,COMP_INCLUDESUBDIRS),TRUE);
1708        if(*cmp->dcd.mask.szMask)
1709          WinSetDlgItemText(hwnd,COMP_NOTE,
1710                            GetPString(IDS_COMPREADYFILTEREDTEXT));
1711        else
1712          WinSetDlgItemText(hwnd,COMP_NOTE,
1713                            GetPString(IDS_COMPREADYTEXT));
1714      }
1715      break;
1716
1717    case WM_INITMENU:
1718      cmp = INSTDATA(hwnd);
1719      if(cmp) {
1720        switch(SHORT1FROMMP(mp1)) {
1721          case IDM_COMMANDSMENU:
1722            SetupCommandMenu(cmp->dcd.hwndLastMenu,hwnd);
1723            break;
1724        }
1725      }
1726      break;
1727
1728    case WM_MENUEND:
1729      cmp = INSTDATA(hwnd);
1730      if(cmp) {
1731        if((HWND)mp2 == cmp->dcd.hwndLastMenu) {
1732          MarkAll(hwndLeft,TRUE,FALSE,TRUE);
1733          MarkAll(hwndRight,TRUE,FALSE,TRUE);
1734          WinDestroyWindow(cmp->dcd.hwndLastMenu);
1735          cmp->dcd.hwndLastMenu = (HWND)0;
1736        }
1737      }
1738      break;
1739
1740    case WM_CONTROL:
1741      switch(SHORT1FROMMP(mp1)) {
1742        case COMP_INCLUDESUBDIRS:
1743          switch(SHORT2FROMMP(mp1)) {
1744            case BN_CLICKED:
1745              cmp = INSTDATA(hwnd);
1746              if (cmp)
1747                *cmp->rightlist = 0;
1748              PostMsg(hwnd,UM_SETUP,MPVOID,MPVOID);
1749              PostMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
1750              break;
1751          }
1752          break;
1753        case COMP_HIDENOTSELECTED:
1754          switch(SHORT2FROMMP(mp1)) {
1755            case BN_CLICKED:
1756              WinSendMsg(hwnd,UM_HIDENOTSELECTED,MPVOID,MPVOID);
1757              break;
1758          }
1759          break;
1760
1761        case COMP_LEFTDIR:
1762        case COMP_RIGHTDIR:
1763          switch(SHORT2FROMMP(mp1)) {
1764            case CN_KILLFOCUS:
1765              PaintRecessedWindow(WinWindowFromID(hwnd,SHORT1FROMMP(mp1)),
1766                                  (HPS)0,FALSE,TRUE);
1767              break;
1768
1769            case CN_SETFOCUS:
1770              PaintRecessedWindow(WinWindowFromID(hwnd,SHORT1FROMMP(mp1)),
1771                                  (HPS)0,TRUE,TRUE);
1772              break;
1773
1774            case CN_ENTER:
1775              if(mp2) {
1776
1777                PCNRITEM pci = (PCNRITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
1778                HWND     hwndCnr = WinWindowFromID(hwnd,SHORT1FROMMP(mp1));
1779
1780                SetShiftState();
1781                if(pci) {
1782                  if((pci->rc.flRecordAttr & CRA_INUSE) || !*pci->szFileName)
1783                    break;
1784                  WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
1785                             MPFROM2SHORT(TRUE,CRA_INUSE));
1786                  if(pci->attrFile & FILE_DIRECTORY) {
1787                    if((shiftstate & (KC_CTRL | KC_SHIFT)) ==
1788                       (KC_CTRL | KC_SHIFT))
1789                      OpenObject(pci->szFileName,Settings,hwnd);
1790                    else
1791                      OpenObject(pci->szFileName,Default,hwnd);
1792                  }
1793                  else
1794                    DefaultViewKeys(hwnd,hwnd,HWND_DESKTOP,NULL,
1795                                    pci->szFileName);
1796                  WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,
1797                             MPFROMP(pci),
1798                             MPFROM2SHORT(FALSE,CRA_INUSE |
1799                                          ((fUnHilite) ? CRA_SELECTED : 0)));
1800                }
1801              }
1802              break;
1803
1804            case CN_CONTEXTMENU:
1805              cmp = INSTDATA(hwnd);
1806              if(cmp) {
1807
1808                PCNRITEM pci = (PCNRITEM)mp2;
1809                USHORT   id = COMP_CNRMENU;
1810
1811                if(cmp->dcd.hwndLastMenu)
1812                  WinDestroyWindow(cmp->dcd.hwndLastMenu);
1813                cmp->dcd.hwndLastMenu = (HWND)0;
1814                cmp->hwndCalling = WinWindowFromID(hwnd,SHORT1FROMMP(mp1));
1815                if(pci) {
1816                  if(!*pci->szFileName || *cmp->rightlist)
1817                    break;
1818                  id = COMP_MENU;
1819                  WinSendMsg(cmp->hwndCalling,CM_SETRECORDEMPHASIS,
1820                             MPFROMP(pci),MPFROM2SHORT(TRUE,CRA_CURSORED));
1821                }
1822                cmp->dcd.hwndLastMenu = WinLoadMenu(HWND_DESKTOP,FM3ModHandle,
1823                                                    id);
1824                if(cmp->dcd.hwndLastMenu) {
1825                  if(id == COMP_CNRMENU) {
1826                    if(SHORT1FROMMP(mp1) == COMP_RIGHTDIR)
1827                      WinSendMsg(cmp->dcd.hwndLastMenu,MM_DELETEITEM,
1828                                 MPFROM2SHORT(IDM_SHOWSUBJECT,FALSE),MPVOID);
1829                    SetDetailsSwitches(cmp->dcd.hwndLastMenu,&cmp->dcd);
1830                    if(SHORT1FROMMP(mp1) == COMP_LEFTDIR)
1831                      WinSendMsg(cmp->dcd.hwndLastMenu,MM_DELETEITEM,
1832                                 MPFROM2SHORT(IDM_LOADLISTFILE,0),MPVOID);
1833                    else if(*cmp->rightlist)
1834                      WinSendMsg(cmp->dcd.hwndLastMenu,MM_DELETEITEM,
1835                                 MPFROM2SHORT(IDM_SAVELISTFILE,0),MPVOID);
1836                  }
1837                  PopupMenu(hwnd,hwnd,cmp->dcd.hwndLastMenu);
1838                }
1839              }
1840              break;
1841
1842            case CN_INITDRAG:
1843              cmp = INSTDATA(hwnd);
1844              if(*cmp->rightlist && SHORT1FROMMP(mp1) == COMP_RIGHTDIR)
1845                break;
1846              DoFileDrag(WinWindowFromID(hwnd,SHORT1FROMMP(mp1)),
1847                         (HWND)0,
1848                         mp2,
1849                         NULL,
1850                         NULL,
1851                         TRUE);
1852              break;
1853
1854            case CN_BEGINEDIT:
1855            case CN_REALLOCPSZ:
1856              // fixme to be gone - field edits not allowed
1857              Runtime_Error(pszSrcFile, __LINE__, "CN_BEGINEDIT/CN_REALLOCPSZ unexpected");
1858              break;
1859
1860            case CN_EMPHASIS:
1861              {
1862                PNOTIFYRECORDEMPHASIS pre = mp2;
1863                PCNRITEM              pci;
1864
1865                if(pre->fEmphasisMask & CRA_SELECTED) {
1866                  pci = (PCNRITEM)pre->pRecord;
1867                  if(pci) {
1868                    if(!*pci->szFileName) {
1869                      if(pci->rc.flRecordAttr & CRA_SELECTED)
1870                        WinSendDlgItemMsg(hwnd,SHORT1FROMMP(mp1),
1871                                          CM_SETRECORDEMPHASIS,
1872                                          MPFROMP(pci),
1873                                          MPFROM2SHORT(FALSE,CRA_SELECTED));
1874                    }
1875                    else {
1876
1877                      CHAR s[81];
1878
1879                      cmp = INSTDATA(hwnd);
1880                      if(pci->rc.flRecordAttr & CRA_SELECTED) {
1881                        if(SHORT1FROMMP(mp1) == COMP_LEFTDIR)
1882                          cmp->selleft++;
1883                        else
1884                          cmp->selright++;
1885                      }
1886                      else {
1887                        if(SHORT1FROMMP(mp1) == COMP_LEFTDIR) {
1888                          if(cmp->selleft)
1889                            cmp->selleft--;
1890                        }
1891                        else {
1892                          if(cmp->selright)
1893                            cmp->selright--;
1894                        }
1895                      }
1896                      if(SHORT1FROMMP(mp1) == COMP_LEFTDIR) {
1897                        if(WinIsWindowEnabled(hwndLeft) ||
1898                           !(cmp->selleft % 50)) {
1899                          sprintf(s," %d",cmp->selleft);
1900                          WinSetDlgItemText(hwnd,COMP_SELLEFT,s);
1901                        }
1902                      }
1903                      else {
1904                        if(WinIsWindowEnabled(hwndRight) ||
1905                           !(cmp->selright % 50)) {
1906                          sprintf(s," %d",cmp->selright);
1907                          WinSetDlgItemText(hwnd,COMP_SELRIGHT,s);
1908                        }
1909                      }
1910                    }
1911                  }
1912                }
1913              }
1914              break;
1915
1916            case CN_SCROLL:
1917              cmp = INSTDATA(hwnd);
1918              if(!cmp->forcescroll) {
1919
1920                PNOTIFYSCROLL pns = mp2;
1921
1922                if(pns->fScroll & CMA_VERTICAL) {
1923                  cmp->forcescroll = TRUE;
1924                  WinSendDlgItemMsg(hwnd,(SHORT1FROMMP(mp1) == COMP_LEFTDIR) ?
1925                                    COMP_RIGHTDIR : COMP_LEFTDIR,
1926                                    CM_SCROLLWINDOW,MPFROMSHORT(CMA_VERTICAL),
1927                                    MPFROMLONG(pns->lScrollInc));
1928                  cmp->forcescroll = FALSE;
1929                }
1930              }
1931              break;
1932          }
1933          break;                        // COMP_RIGHTDIR
1934      }
1935      return 0;                         // WM_CONTROL
1936
1937    case UM_SETDIR:
1938      cmp = INSTDATA(hwnd);
1939      if(cmp) {
1940
1941        COMPARE *forthread;
1942        CNRINFO  cnri;
1943
1944        cmp->includesubdirs = WinQueryButtonCheckstate(hwnd,
1945                                                       COMP_INCLUDESUBDIRS);
1946        memset(&cnri,0,sizeof(CNRINFO));
1947        cnri.cb = sizeof(CNRINFO);
1948        cnri.pszCnrTitle = cmp->leftdir;
1949        cnri.flWindowAttr = CV_DETAIL | CV_MINI |
1950                            CA_CONTAINERTITLE | CA_TITLESEPARATOR |
1951                            CA_DETAILSVIEWTITLES | CA_OWNERDRAW;
1952        WinSendDlgItemMsg(hwnd,COMP_LEFTDIR,CM_SETCNRINFO,MPFROMP(&cnri),
1953                          MPFROMLONG(CMA_CNRTITLE | CMA_FLWINDOWATTR));
1954        cnri.pszCnrTitle = cmp->rightdir;
1955        WinSendDlgItemMsg(hwnd,COMP_RIGHTDIR,CM_SETCNRINFO,MPFROMP(&cnri),
1956                          MPFROMLONG(CMA_CNRTITLE | CMA_FLWINDOWATTR));
1957        WinCheckButton(hwnd,COMP_HIDENOTSELECTED,0);
1958        cmp->filling = TRUE;
1959        forthread = xmalloc(sizeof(COMPARE),pszSrcFile,__LINE__);
1960        if(!forthread)
1961          WinDismissDlg(hwnd,0);
1962        else {
1963          *forthread = *cmp;
1964          forthread->cmp = cmp;
1965          if (_beginthread(FillCnrsThread,NULL,122880,(PVOID)forthread) == -1) {
1966            Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
1967            WinDismissDlg(hwnd,0);
1968            free(forthread);
1969          }
1970          else {
1971            WinEnableWindowUpdate(hwndLeft,FALSE);
1972            WinEnableWindowUpdate(hwndRight,FALSE);
1973            cmp->selleft = cmp->selright = 0;
1974            WinSetDlgItemText(hwnd,COMP_SELLEFT,"0");
1975            WinSetDlgItemText(hwnd,COMP_SELRIGHT,"0");
1976            WinSetDlgItemText(hwnd,COMP_TOTALLEFT,"0");
1977            WinSetDlgItemText(hwnd,COMP_TOTALRIGHT,"0");
1978            WinSetDlgItemText(hwnd,COMP_NOTE,
1979                              GetPString(IDS_COMPHOLDREADDISKTEXT));
1980            WinEnableWindow(hwndRight,FALSE);
1981            WinEnableWindow(hwndLeft,FALSE);
1982            WinEnableWindow(WinWindowFromID(hwnd,DID_OK),FALSE);
1983            WinEnableWindow(WinWindowFromID(hwnd,DID_CANCEL),FALSE);
1984            WinEnableWindow(WinWindowFromID(hwnd,COMP_COLLECT),FALSE);
1985            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBOTH),FALSE);
1986            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTONE),FALSE);
1987            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTNEWER),FALSE);
1988            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTOLDER),FALSE);
1989            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBIGGER),FALSE);
1990            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSMALLER),FALSE);
1991            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBOTH),FALSE);
1992            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTONE),FALSE);
1993            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTNEWER),FALSE);
1994            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTOLDER),FALSE);
1995            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBIGGER),FALSE);
1996            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTSMALLER),FALSE);
1997            WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTALL),FALSE);
1998            WinEnableWindow(WinWindowFromID(hwnd,COMP_INCLUDESUBDIRS),FALSE);
1999            WinEnableWindow(WinWindowFromID(hwnd,COMP_SETDIRS),FALSE);
2000            WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETELEFT),FALSE);
2001            WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETERIGHT),FALSE);
2002            WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYLEFT),FALSE);
2003            WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVELEFT),FALSE);
2004            WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYRIGHT),FALSE);
2005            WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVERIGHT),FALSE);
2006            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAMECONTENT),FALSE);
2007            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTIDENTICAL),FALSE);
2008            WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAME),FALSE);
2009            WinEnableWindow(WinWindowFromID(hwnd,IDM_INVERT),FALSE);
2010            WinEnableWindow(WinWindowFromID(hwnd,COMP_FILTER),FALSE);
2011          }
2012        }
2013      }
2014      return 0;
2015
2016    case UM_FILTER:
2017      cmp = INSTDATA(hwnd);
2018      if (cmp) {
2019        if (mp1) {
2020          DosEnterCritSec();
2021           SetMask((CHAR *)mp1,&cmp->dcd.mask);
2022          DosExitCritSec();
2023        }
2024        cmp->dcd.suspendview = 1;
2025        WinSendMsg(hwndLeft,CM_FILTER,MPFROMP(Filter),MPFROMP(&cmp->dcd.mask));
2026        WinSendMsg(hwndRight,CM_FILTER,MPFROMP(Filter),MPFROMP(&cmp->dcd.mask));
2027        cmp->dcd.suspendview = 0;
2028        if (*cmp->dcd.mask.szMask)
2029          WinSetDlgItemText(hwnd,COMP_NOTE,
2030                            GetPString(IDS_COMPREADYFILTEREDTEXT));
2031        else
2032          WinSetDlgItemText(hwnd,COMP_NOTE,
2033                            GetPString(IDS_COMPREADYTEXT));
2034      }
2035      return 0;
2036
2037    case UM_HIDENOTSELECTED:
2038      cmp = INSTDATA(hwnd);
2039      if(cmp) {
2040        USHORT wantHide = WinQueryButtonCheckstate(hwnd,
2041                                                   COMP_HIDENOTSELECTED);
2042
2043        cmp->dcd.suspendview = 1;
2044        if (wantHide) {
2045          BOOL needRefresh = FALSE;
2046          HWND hwndl = WinWindowFromID(cmp->hwnd,COMP_LEFTDIR);
2047          HWND hwndr = WinWindowFromID(cmp->hwnd,COMP_RIGHTDIR);
2048          PCNRITEM pcil = WinSendMsg(hwndl,CM_QUERYRECORD,MPVOID,
2049                                     MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
2050          PCNRITEM pcir = WinSendMsg(hwndr,CM_QUERYRECORD,MPVOID,
2051                                     MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
2052          while(pcil && (INT)pcil != -1 && pcir && (INT)pcir != -1) {
2053            if (~pcil->rc.flRecordAttr & CRA_SELECTED &&
2054                ~pcir->rc.flRecordAttr & CRA_SELECTED) {
2055              pcil->rc.flRecordAttr |= CRA_FILTERED;
2056              pcir->rc.flRecordAttr |= CRA_FILTERED;
2057              needRefresh = TRUE;
2058            }
2059            pcil = WinSendMsg(hwndl,CM_QUERYRECORD,MPFROMP(pcil),
2060                              MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
2061            pcir = WinSendMsg(hwndr,CM_QUERYRECORD,MPFROMP(pcir),
2062                              MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
2063          } // while
2064          if (needRefresh) {
2065            WinSendMsg(hwndl,CM_INVALIDATERECORD,
2066                     MPVOID,MPFROM2SHORT(0,CMA_REPOSITION));
2067            WinSendMsg(hwndr,CM_INVALIDATERECORD,
2068                     MPVOID,MPFROM2SHORT(0,CMA_REPOSITION));
2069          }
2070        }
2071        else {
2072          WinSendMsg(hwndLeft,CM_FILTER,MPFROMP(Filter),MPFROMP(&cmp->dcd.mask));
2073          WinSendMsg(hwndRight,CM_FILTER,MPFROMP(Filter),MPFROMP(&cmp->dcd.mask));
2074        }
2075        cmp->dcd.suspendview = 0;
2076        if (*cmp->dcd.mask.szMask)
2077          WinSetDlgItemText(hwnd,COMP_NOTE,
2078                            GetPString(IDS_COMPREADYFILTEREDTEXT));
2079        else
2080          WinSetDlgItemText(hwnd,COMP_NOTE,
2081                            GetPString(IDS_COMPREADYTEXT));
2082      }
2083      return 0;
2084
2085    case WM_COMMAND:
2086      switch(SHORT1FROMMP(mp1)) {
2087        case IDM_COMPARE:
2088          cmp = INSTDATA(hwnd);
2089          if(cmp) {
2090
2091            PCNRITEM pci;
2092            CHAR     ofile[CCHMAXPATH];
2093
2094            pci = (PCNRITEM)WinSendMsg(cmp->hwndCalling,
2095                                       CM_QUERYRECORDEMPHASIS,
2096                                       MPFROMLONG(CMA_FIRST),
2097                                       MPFROMSHORT(CRA_CURSORED));
2098            if(pci) {
2099              if(cmp->hwndCalling == hwndLeft)
2100                strcpy(ofile,cmp->rightdir);
2101              else
2102                strcpy(ofile,cmp->leftdir);
2103              if(ofile[strlen(ofile) - 1] != '\\')
2104                strcat(ofile,"\\");
2105              strcat(ofile,pci->pszFileName);
2106              if(*compare) {
2107
2108                CHAR *fakelist[3];
2109
2110                fakelist[0] = pci->szFileName;
2111                fakelist[1] = ofile;
2112                fakelist[2] = NULL;
2113                ExecOnList(hwnd,compare,
2114                           WINDOWED | SEPARATEKEEP,
2115                           NULL,fakelist,NULL);
2116              }
2117              else {
2118
2119                FCOMPARE fc;
2120
2121                memset(&fc,0,sizeof(fc));
2122                fc.size = sizeof(fc);
2123                fc.hwndParent = hwnd;
2124                strcpy(fc.file1,pci->szFileName);
2125                strcpy(fc.file2,ofile);
2126                WinDlgBox(HWND_DESKTOP,hwnd,
2127                          CFileDlgProc,FM3ModHandle,
2128                          FCMP_FRAME,(PVOID)&fc);
2129              }
2130            }
2131          }
2132          break;
2133
2134        case COMP_FILTER:
2135        case IDM_FILTER:
2136          cmp = INSTDATA(hwnd);
2137          if(cmp) {
2138
2139            BOOL     empty = FALSE;
2140            PCNRITEM pci;
2141            CHAR    *p;
2142            BOOL temp;
2143
2144            if(!*cmp->dcd.mask.szMask) {
2145              empty = TRUE;
2146              temp = fSelectedAlways;
2147              fSelectedAlways = TRUE;
2148              pci = (PCNRITEM)CurrentRecord(hwnd);
2149              fSelectedAlways = temp;
2150              if(pci && !(pci->attrFile & FILE_DIRECTORY)) {
2151                p = strrchr(pci->szFileName,'\\');
2152                if(p) {
2153                  p++;
2154                  strcpy(cmp->dcd.mask.szMask,p);
2155                }
2156              }
2157            }
2158            cmp->dcd.mask.fNoAttribs = TRUE;
2159            cmp->dcd.mask.attrFile = ALLATTRS;
2160            cmp->dcd.mask.antiattr = 0;
2161            if(WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
2162                         FM3ModHandle,MSK_FRAME,MPFROMP(&cmp->dcd.mask))) {
2163              cmp->dcd.mask.attrFile = ALLATTRS;
2164              cmp->dcd.mask.antiattr = 0;
2165              WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
2166            }
2167            else if(empty) {
2168              *cmp->dcd.mask.szMask = 0;
2169              cmp->dcd.mask.attrFile = ALLATTRS;
2170              cmp->dcd.mask.antiattr = 0;
2171            }
2172          }
2173          break;
2174
2175        case IDM_SHOWSUBJECT:
2176        case IDM_SHOWEAS:
2177        case IDM_SHOWSIZE:
2178        case IDM_SHOWLWDATE:
2179        case IDM_SHOWLWTIME:
2180        case IDM_SHOWLADATE:
2181        case IDM_SHOWLATIME:
2182        case IDM_SHOWCRDATE:
2183        case IDM_SHOWCRTIME:
2184        case IDM_SHOWATTR:
2185          cmp = INSTDATA(hwnd);
2186          if(cmp) {
2187
2188            DIRCNRDATA dcd1;
2189            BOOL       tempsubj;
2190
2191            dcd1 = cmp->dcd;
2192            AdjustDetailsSwitches(hwndLeft,
2193                                  (HWND)0,SHORT1FROMMP(mp1),
2194                                  cmp->leftdir,"DirCmp",&cmp->dcd,
2195                                  TRUE);
2196            tempsubj = cmp->dcd.detailssubject;
2197            cmp->dcd = dcd1;
2198            cmp->dcd.detailssubject = FALSE;
2199            AdjustDetailsSwitches(hwndRight,
2200                                  cmp->dcd.hwndLastMenu,SHORT1FROMMP(mp1),
2201                                  cmp->rightdir,"DirCmp",&cmp->dcd,TRUE);
2202            cmp->dcd.detailssubject = tempsubj;
2203          }
2204          break;
2205
2206        case IDM_LOADLISTFILE:
2207          cmp = INSTDATA(hwnd);
2208          if(cmp) {
2209
2210            CHAR fullname[CCHMAXPATH];
2211
2212            strcpy(fullname,"*.PMD");
2213            if(insert_filename(HWND_DESKTOP,fullname,TRUE,FALSE) &&
2214               *fullname && !strchr(fullname,'*') && !strchr(fullname,'?')) {
2215              strcpy(cmp->rightlist,fullname);
2216              PostMsg(hwnd,UM_SETUP,MPVOID,MPVOID);
2217              PostMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
2218            }
2219          }
2220          break;
2221
2222        case IDM_SAVELISTFILE:
2223          cmp = INSTDATA(hwnd);
2224          if(cmp) {
2225
2226            SNAPSTUFF *sf;
2227            CHAR       fullname[CCHMAXPATH];
2228
2229            strcpy(fullname,"*.PMD");
2230            if(export_filename(HWND_DESKTOP,fullname,1) && *fullname &&
2231               !strchr(fullname,'*') && !strchr(fullname,'?')) {
2232              sf = xmallocz(sizeof(SNAPSTUFF),pszSrcFile,__LINE__);
2233              if (sf) {
2234                strcpy(sf->filename,fullname);
2235                if(hwndLeft == cmp->hwndCalling)
2236                  strcpy(sf->dirname,cmp->leftdir);
2237                else
2238                  strcpy(sf->dirname,cmp->rightdir);
2239                sf->recurse = cmp->includesubdirs;
2240                if (_beginthread(StartSnap,NULL,65536,(PVOID)sf) == -1) {
2241                  Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
2242                  free(sf);
2243                }
2244              }
2245            }
2246          }
2247          break;
2248
2249        case COMP_SETDIRS:
2250          cmp = INSTDATA(hwnd);
2251          if(cmp) {
2252
2253            WALK2 wa;
2254
2255            memset(&wa,0,sizeof(wa));
2256            wa.size = sizeof(wa);
2257            strcpy(wa.szCurrentPath1,cmp->leftdir);
2258            strcpy(wa.szCurrentPath2,cmp->rightdir);
2259            if(WinDlgBox(HWND_DESKTOP,hwnd,WalkTwoCmpDlgProc,
2260                         FM3ModHandle,WALK2_FRAME,
2261                         MPFROMP(&wa)) &&
2262               !IsFile(wa.szCurrentPath1) &&
2263               !IsFile(wa.szCurrentPath2)) {
2264              strcpy(cmp->leftdir,wa.szCurrentPath1);
2265              strcpy(cmp->rightdir,wa.szCurrentPath2);
2266              *cmp->rightlist = 0;
2267              PostMsg(hwnd,UM_SETUP,MPVOID,MPVOID);
2268              PostMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
2269            }
2270          }
2271          break;
2272
2273        case COMP_COPYLEFT:
2274        case COMP_MOVELEFT:
2275        case COMP_COPYRIGHT:
2276        case COMP_MOVERIGHT:
2277        case COMP_DELETELEFT:
2278        case COMP_DELETERIGHT:
2279          cmp = INSTDATA(hwnd);
2280          if(cmp) {
2281
2282            COMPARE *forthread;
2283
2284            cmp->filling = TRUE;
2285            forthread = xmalloc(sizeof(COMPARE),pszSrcFile,__LINE__);
2286            if (forthread) {
2287              *forthread = *cmp;
2288              forthread->cmp = cmp;
2289              forthread->action = SHORT1FROMMP(mp1);
2290              if (_beginthread(ActionCnrThread,NULL,122880,(PVOID)forthread) == -1) {
2291                Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
2292                free(forthread);
2293              }
2294              else {
2295                WinEnableWindowUpdate(hwndLeft,FALSE);
2296                WinEnableWindowUpdate(hwndRight,FALSE);
2297                switch(SHORT1FROMMP(mp1)) {
2298                  case COMP_DELETELEFT:
2299                  case COMP_DELETERIGHT:
2300                    WinSetDlgItemText(hwnd,COMP_NOTE,
2301                                      GetPString(IDS_COMPHOLDDELETINGTEXT));
2302                    break;
2303                  case COMP_MOVELEFT:
2304                  case COMP_MOVERIGHT:
2305                    WinSetDlgItemText(hwnd,COMP_NOTE,
2306                                      GetPString(IDS_COMPHOLDMOVINGTEXT));
2307                    break;
2308                  case COMP_COPYLEFT:
2309                  case COMP_COPYRIGHT:
2310                    WinSetDlgItemText(hwnd,COMP_NOTE,
2311                                      GetPString(IDS_COMPHOLDCOPYINGTEXT));
2312                    break;
2313                  default:
2314                    WinSetDlgItemText(hwnd,COMP_NOTE,
2315                                      GetPString(IDS_COMPHOLDDUNNOTEXT));
2316                    break;
2317                }
2318                WinEnableWindow(hwndRight,FALSE);
2319                WinEnableWindow(hwndLeft,FALSE);
2320                WinEnableWindow(WinWindowFromID(hwnd,DID_OK),FALSE);
2321                WinEnableWindow(WinWindowFromID(hwnd,DID_CANCEL),FALSE);
2322                WinEnableWindow(WinWindowFromID(hwnd,COMP_COLLECT),FALSE);
2323                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBOTH),FALSE);
2324                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTONE),FALSE);
2325                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTNEWER),FALSE);
2326                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTOLDER),FALSE);
2327                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBIGGER),FALSE);
2328                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSMALLER),FALSE);
2329                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBOTH),FALSE);
2330                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTONE),FALSE);
2331                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTNEWER),FALSE);
2332                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTOLDER),FALSE);
2333                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBIGGER),FALSE);
2334                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTSMALLER),FALSE);
2335                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTALL),FALSE);
2336                WinEnableWindow(WinWindowFromID(hwnd,COMP_INCLUDESUBDIRS),FALSE);
2337                WinEnableWindow(WinWindowFromID(hwnd,COMP_SETDIRS),FALSE);
2338                WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETELEFT),FALSE);
2339                WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETERIGHT),FALSE);
2340                WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYLEFT),FALSE);
2341                WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVELEFT),FALSE);
2342                WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYRIGHT),FALSE);
2343                WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVERIGHT),FALSE);
2344                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAMECONTENT),FALSE);
2345                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTIDENTICAL),FALSE);
2346                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAME),FALSE);
2347                WinEnableWindow(WinWindowFromID(hwnd,IDM_INVERT),FALSE);
2348                WinEnableWindow(WinWindowFromID(hwnd,COMP_FILTER),FALSE);
2349              }
2350            }
2351          }
2352          break;
2353
2354        case DID_OK:
2355          WinDismissDlg(hwnd,0);
2356          break;
2357        case DID_CANCEL:
2358          WinDismissDlg(hwnd,1);
2359          break;
2360
2361        case IDM_HELP:
2362          if(hwndHelp)
2363            WinSendMsg(hwndHelp,HM_DISPLAY_HELP,
2364                       MPFROM2SHORT(HELP_COMPARE,0),
2365                       MPFROMSHORT(HM_RESOURCEID));
2366          break;
2367
2368        case IDM_DESELECTALL:
2369        case IDM_SELECTNEWER:
2370        case IDM_SELECTOLDER:
2371        case IDM_SELECTBIGGER:
2372        case IDM_SELECTSMALLER:
2373        case IDM_DESELECTNEWER:
2374        case IDM_DESELECTOLDER:
2375        case IDM_DESELECTBIGGER:
2376        case IDM_DESELECTSMALLER:
2377        case IDM_DESELECTONE:
2378        case IDM_DESELECTBOTH:
2379        case IDM_SELECTBOTH:
2380        case IDM_SELECTONE:
2381        case IDM_SELECTSAMECONTENT:
2382        case IDM_SELECTIDENTICAL:               // name, size and time
2383        case IDM_SELECTSAME:                    // name and size
2384        case IDM_INVERT:
2385          cmp = INSTDATA(hwnd);
2386          if (!cmp)
2387              Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2388          else {
2389            COMPARE *forthread;
2390
2391            cmp->filling = TRUE;
2392            forthread = xmalloc(sizeof(COMPARE),pszSrcFile,__LINE__);
2393            if (forthread) {
2394              *forthread = *cmp;
2395              forthread->cmp = cmp;
2396              forthread->action = SHORT1FROMMP(mp1);
2397              if (_beginthread(SelectCnrsThread,NULL,65536,(PVOID)forthread) == -1) {
2398                Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
2399                free(forthread);
2400              }
2401              else {
2402                WinEnableWindowUpdate(hwndLeft,FALSE);
2403                WinEnableWindowUpdate(hwndRight,FALSE);
2404                switch(SHORT1FROMMP(mp1)) {
2405                  case IDM_DESELECTALL:
2406                  case IDM_DESELECTNEWER:
2407                  case IDM_DESELECTOLDER:
2408                  case IDM_DESELECTBIGGER:
2409                  case IDM_DESELECTSMALLER:
2410                  case IDM_DESELECTONE:
2411                  case IDM_DESELECTBOTH:
2412                    WinSetDlgItemText(hwnd,COMP_NOTE,
2413                                      GetPString(IDS_COMPHOLDDESELTEXT));
2414                    break;
2415                  case IDM_INVERT:
2416                    WinSetDlgItemText(hwnd,COMP_NOTE,
2417                                      GetPString(IDS_COMPHOLDINVERTTEXT));
2418                    break;
2419                  default:
2420                    WinSetDlgItemText(hwnd,COMP_NOTE,
2421                                      GetPString(IDS_COMPHOLDSELTEXT));
2422                    break;
2423                }
2424                WinEnableWindow(hwndRight,FALSE);
2425                WinEnableWindow(hwndLeft,FALSE);
2426                WinEnableWindow(WinWindowFromID(hwnd,DID_OK),FALSE);
2427                WinEnableWindow(WinWindowFromID(hwnd,DID_CANCEL),FALSE);
2428                WinEnableWindow(WinWindowFromID(hwnd,COMP_COLLECT),FALSE);
2429                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBOTH),FALSE);
2430                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTONE),FALSE);
2431                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTNEWER),FALSE);
2432                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTOLDER),FALSE);
2433                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTBIGGER),FALSE);
2434                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSMALLER),FALSE);
2435                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBOTH),FALSE);
2436                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTONE),FALSE);
2437                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTNEWER),FALSE);
2438                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTOLDER),FALSE);
2439                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTBIGGER),FALSE);
2440                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTSMALLER),FALSE);
2441                WinEnableWindow(WinWindowFromID(hwnd,IDM_DESELECTALL),FALSE);
2442                WinEnableWindow(WinWindowFromID(hwnd,COMP_INCLUDESUBDIRS),FALSE);
2443                WinEnableWindow(WinWindowFromID(hwnd,COMP_SETDIRS),FALSE);
2444                WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETELEFT),FALSE);
2445                WinEnableWindow(WinWindowFromID(hwnd,COMP_DELETERIGHT),FALSE);
2446                WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYLEFT),FALSE);
2447                WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVELEFT),FALSE);
2448                WinEnableWindow(WinWindowFromID(hwnd,COMP_COPYRIGHT),FALSE);
2449                WinEnableWindow(WinWindowFromID(hwnd,COMP_MOVERIGHT),FALSE);
2450                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAMECONTENT),FALSE);
2451                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTIDENTICAL),FALSE);
2452                WinEnableWindow(WinWindowFromID(hwnd,IDM_SELECTSAME),FALSE);
2453                WinEnableWindow(WinWindowFromID(hwnd,IDM_INVERT),FALSE);
2454                WinEnableWindow(WinWindowFromID(hwnd,COMP_FILTER),FALSE);
2455              }
2456            }
2457          }
2458          break;
2459
2460        case COMP_COLLECT:
2461          cmp = INSTDATA(hwnd);
2462          if(cmp) {
2463
2464            CHAR **listl,**listr = NULL;
2465
2466            if(!Collector) {
2467
2468              SWP  swp;
2469              HWND hwndC;
2470
2471              if(!fAutoTile && !ParentIsDesktop(hwnd,cmp->hwndParent) &&
2472                 (!fExternalCollector && !strcmp(realappname,FM3Str)))
2473                GetNextWindowPos(cmp->hwndParent,&swp,NULL,NULL);
2474              hwndC = StartCollector((fExternalCollector ||
2475                                      strcmp(realappname,FM3Str)) ?
2476                                     HWND_DESKTOP :
2477                                     cmp->hwndParent,4);
2478              if(hwndC) {
2479                if(!fAutoTile && !ParentIsDesktop(hwnd,cmp->hwndParent) &&
2480                   (!fExternalCollector && !strcmp(realappname,FM3Str)))
2481                  WinSetWindowPos(hwndC,HWND_TOP,swp.x,swp.y,
2482                                  swp.cx,swp.cy,SWP_MOVE | SWP_SIZE |
2483                                  SWP_SHOW | SWP_ZORDER);
2484                else if(!ParentIsDesktop(hwnd,cmp->hwndParent) && fAutoTile &&
2485                        !strcmp(realappname,FM3Str))
2486                  TileChildren(cmp->hwndParent,TRUE);
2487                DosSleep(64L);
2488                PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(COMP_COLLECT,0),
2489                           MPVOID);
2490                break;
2491              }
2492            }
2493            else
2494              StartCollector(cmp->hwndParent,4);
2495            {
2496              BOOL temp;
2497
2498              temp = fSelectedAlways;
2499              fSelectedAlways = TRUE;
2500              listl = BuildList(hwndLeft);
2501              if(!*cmp->rightlist)
2502                listr = BuildList(hwndRight);
2503              fSelectedAlways = temp;
2504            }
2505            if(listl || listr) {
2506              if(Collector) {
2507                if(listl) {
2508                  if(!PostMsg(Collector,WM_COMMAND,
2509                                 MPFROM2SHORT(IDM_COLLECTOR,0),
2510                                 MPFROMP(listl)))
2511                    FreeList(listl);
2512                }
2513                if(listr) {
2514                  if(!PostMsg(Collector,WM_COMMAND,
2515                                 MPFROM2SHORT(IDM_COLLECTOR,0),
2516                                 MPFROMP(listr)))
2517                    FreeList(listr);
2518                }
2519                WinSetWindowPos(WinQueryWindow(WinQueryWindow(Collector,
2520                                QW_PARENT),QW_PARENT),HWND_TOP,
2521                                0,0,0,0,SWP_ACTIVATE);
2522              }
2523              else {
2524                FreeList(listl);
2525                FreeList(listr);
2526              }
2527            }
2528          }
2529          break;
2530      }
2531      return 0;
2532
2533    case WM_CLOSE:
2534      WinDismissDlg(hwnd,0);
2535      return 0;
2536
2537    case WM_DESTROY:
2538      cmp = INSTDATA(hwnd);
2539      if(cmp) {
2540        if(cmp->dcd.hwndLastMenu)
2541          WinDestroyWindow(cmp->dcd.hwndLastMenu);
2542        if(cmp->dcd.hwndObject) {
2543          WinSetWindowPtr(cmp->dcd.hwndObject,0,(PVOID)NULL);
2544          if(!PostMsg(cmp->dcd.hwndObject,WM_CLOSE,MPVOID,MPVOID))
2545            WinSendMsg(cmp->dcd.hwndObject,WM_CLOSE,MPVOID,MPVOID);
2546        }
2547        free(cmp);
2548      }
2549      EmptyCnr(hwndLeft);
2550      EmptyCnr(hwndRight);
2551      DosPostEventSem(CompactSem);
2552      break;
2553  }
2554  return WinDefDlgProc(hwnd,msg,mp1,mp2);
2555}
Note: See TracBrowser for help on using the repository browser.