source: trunk/dll/comp.c@ 145

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

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