Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

comp.c

Visit:

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

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

Context Navigation

source: trunk/dll/comp.c

Download in other formats: