source: trunk/dll/comp.c@ 757

Last change on this file since 757 was 756, checked in by Gregg Young, 18 years ago

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