source: trunk/dll/comp.c@ 924

Last change on this file since 924 was 924, checked in by Steven Levine, 17 years ago

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