Context Navigation

source: trunk/dll/comp.c@ 748

Visit:

Last change on this file since 748 was 748, checked in by Steven Levine, 18 years ago
Rework comp.c to to sync with CNRITEM mods Rework comp.c to remove vast amount of duplicate code Clean up select.c while auditing for CNRITEM sync Sync fm3dll.h with comp.c mods
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 86.4 KB

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

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

Download in other formats: