source: trunk/dll/comp.c@ 284

Last change on this file since 284 was 199, checked in by root, 20 years ago

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