source: trunk/dll/comp.c@ 517

Last change on this file since 517 was 517, checked in by root, 19 years ago

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