Context Navigation

source: trunk/dll/comp.c@ 1892

Visit:

Last change on this file since 1892 was 1891, checked in by Steven Levine, 6 years ago
Rework FreeCnrItem to ensure all CNRITEMs deleted. Use WinSendMsg CMA_NEXT. Was using preccNextRecord which is not recommended because control does not maintain linkage after inserts and deletes. Note: arccnrs.c still needs to be reworked to use common functions from filldir.c.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 103.5 KB

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

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

Download in other formats: