Context Navigation

source: trunk/dll/comp.c@ 1682

Visit:

Last change on this file since 1682 was 1682, checked in by Gregg Young, 13 years ago
Added optional confirmation dialogs for delete move and copy to compare dir Ticket 277; Added EA compare option to compare dir Ticket 80; Minor code cleanup.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 103.6 KB

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

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

Download in other formats: