Context Navigation

source: trunk/dll/comp.c@ 795

Visit:

Last change on this file since 795 was 790, checked in by Steven Levine, 18 years ago
Correct remaining pcil/pcir typos (we hope) Revert to DosSleep(0) Use GetMSecTimer for timing
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 75.3 KB

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

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

Download in other formats: