Context Navigation

source: trunk/dll/comp.c@ 1063

Visit:

Last change on this file since 1063 was 1063, checked in by Gregg Young, 17 years ago
Fortify ifdef reformat
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.5 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: