Context Navigation

source: trunk/dll/comp.c@ 1521

Visit:

Last change on this file since 1521 was 1505, checked in by Gregg Young, 16 years ago
Remove unnecessary type casts; minor formating cleanup.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 94.0 KB

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

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

Download in other formats: