Context Navigation

source: trunk/dll/comp.c@ 1670

Visit:

Last change on this file since 1670 was 1670, checked in by Gregg Young, 13 years ago
Add ability to change and save PresParam to compare dialog (Ticket 443) Fix loading of a list file in the right compare container (Ticket 489) Allow for selection of include subdirectories or a list file on initial startup of compare dirs (Ticket 145)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 97.8 KB

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

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

Download in other formats: