Context Navigation

source: trunk/dll/select.c@ 551

Visit:

Last change on this file since 551 was 551, checked in by Gregg Young, 18 years ago
Indentation cleanup
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 42.1 KB

Rev	Line
[123]	1
	2	/***********************************************************************
	3
	4	$Id: select.c 551 2007-02-28 01:33:51Z gyoung $
	5
[362]	6	Container item selection support routines
	7
[123]	8	Copyright (c) 1993-98 M. Kimes
[317]	9	Copyright (c) 2004, 2006 Steven H. Levine
[123]	10
[158]	11	01 Aug 04 SHL Rework lstrip/rstrip usage
	12	25 May 05 SHL Rework for ULONGLONG
[204]	13	06 Jun 05 SHL Drop unused code
[317]	14	06 Jul 06 SHL Support compare content (IDM_SELECTSAMECONTENT)
[362]	15	13 Jul 06 SHL Use Runtime_Error
[406]	16	29 Jul 06 SHL Use xfgets_bstripcr
[442]	17	15 Aug 06 SHL Rework SetMask args and logic
[123]	18
	19	***********************************************************************/
	20
[2]	21	#define INCL_DOS
	22	#define INCL_WIN
[158]	23	#define INCL_LONGLONG
	24	#include <os2.h>
[2]	25
	26	#include <stdio.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <share.h>
[317]	30	#include <io.h>
[158]	31
[2]	32	#include "fm3dll.h"
	33	#include "fm3str.h"
	34
	35	#pragma alloc_text(SELECT,UnHilite,SelectAll,DeselectAll,MarkAll,SetMask)
	36	#pragma alloc_text(SELECT,SelectList)
	37	#pragma alloc_text(SELECT1,Deselect,HideAll,RemoveAll,ExpandAll,InvertAll)
	38
[362]	39	static PSZ pszSrcFile = __FILE__;
	40
[551]	41	VOID UnHilite(HWND hwndCnr, BOOL all, CHAR *** list)
[317]	42	{
[2]	43	PCNRITEM pci;
[551]	44	INT numfiles = 0, numalloc = 0;
	45	INT attribute = CRA_CURSORED;
[2]	46
[362]	47	if (all && list && *list) {
[2]	48	FreeList(*list);
	49	*list = NULL;
	50	}
[551]	51	pci = (PCNRITEM) CurrentRecord(hwndCnr);
	52	if (pci && (INT) pci != -1) {
[362]	53	if (pci->rc.flRecordAttr & CRA_SELECTED) {
[2]	54	attribute = CRA_SELECTED;
[551]	55	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
	56	MPFROMSHORT(attribute));
[2]	57	}
[551]	58	while (pci && (INT) pci != -1) {
	59	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	60	MPFROM2SHORT(FALSE, CRA_SELECTED));
[362]	61	if (!all)
[551]	62	break;
[362]	63	if (list)
[551]	64	AddToList(pci->szFileName, list, &numfiles, &numalloc);
	65	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
	66	MPFROMP(pci), MPFROMSHORT(CRA_SELECTED));
[2]	67	}
	68	}
	69	}
	70
[551]	71	VOID SelectList(HWND hwndCnr, BOOL partial, BOOL deselect, BOOL clearfirst,
	72	PCNRITEM pciParent, CHAR * filename, CHAR ** list)
[362]	73	{
[2]	74
[551]	75	PCNRITEM pci;
[2]	76	register INT x;
[551]	77	BOOL foundone = FALSE;
	78	ULONG errs = 0L;
[2]	79
[362]	80	if (clearfirst && !deselect)
[551]	81	UnHilite(hwndCnr, TRUE, NULL);
[362]	82	if (list && list[0]) {
[551]	83	for (x = 0; list[x]; x++) {
[2]	84	pci = FindCnrRecord(hwndCnr,
[551]	85	list[x], pciParent, partial, partial, TRUE);
[362]	86	if (pci) {
[551]	87	WinSendMsg(hwndCnr,
	88	CM_SETRECORDEMPHASIS,
	89	MPFROMP(pci),
	90	MPFROM2SHORT((SHORT) ((deselect) ? FALSE : TRUE),
	91	CRA_SELECTED));
	92	foundone = TRUE;
[2]	93	}
	94	}
[362]	95	if (!foundone)
	96	Runtime_Error(pszSrcFile, __LINE__, "select failed");
[2]	97	}
[362]	98	else if (filename && *filename) {
[2]	99
	100	FILE *fp;
[551]	101	CHAR input[1024], *p;
[2]	102
[551]	103	fp = _fsopen(filename, "r", SH_DENYNO);
[362]	104	if (fp) {
	105	while (!feof(fp)) {
[551]	106	if (!xfgets_bstripcr(input, sizeof(input), fp, pszSrcFile, __LINE__))
	107	break;
	108	if (*input == '\"') {
	109	memmove(input, input + 1, strlen(input) + 1);
	110	lstrip(input);
	111	p = strchr(input, '\"');
	112	if (p)
	113	*p = 0;
	114	rstrip(input);
	115	}
	116	else {
	117	p = strchr(input, ' ');
	118	if (p)
	119	*p = 0;
	120	}
	121	/* input now contains name of file to select */
	122	pci = FindCnrRecord(hwndCnr,
	123	input, pciParent, partial, partial, TRUE);
	124	if (pci) /* found it? */
	125	WinSendMsg(hwndCnr,
	126	CM_SETRECORDEMPHASIS,
	127	MPFROMP(pci),
	128	MPFROM2SHORT((SHORT) ((deselect) ? FALSE : TRUE),
	129	CRA_SELECTED));
	130	else
	131	errs++;
	132	if (errs > 50L) { /* prevent runaway on bad file */
[2]	133
[551]	134	APIRET ret;
[2]	135
[551]	136	ret = saymsg(MB_YESNO,
	137	hwndCnr,
	138	GetPString(IDS_POSSIBLEERRORTEXT),
	139	GetPString(IDS_MAYNOTBELISTTEXT), filename);
	140	if (ret == MBID_NO)
	141	break;
	142	errs = 0L;
	143	}
[2]	144	}
	145	fclose(fp);
	146	}
	147	}
	148	}
	149
[551]	150	VOID SelectAll(HWND hwndCnr, BOOL files, BOOL dirs, CHAR * maskstr,
	151	CHAR * text, BOOL is_arc)
[362]	152	{
[2]	153
[551]	154	PCNRITEM pci;
	155	BOOL markit;
[2]	156	register CHAR *file;
[551]	157	MASK Mask;
	158	register INT x;
	159	ULONG textlen = 0;
[2]	160
[362]	161	if (text)
[2]	162	textlen = strlen(text);
[551]	163	memset(&Mask, 0, sizeof(Mask));
[442]	164	if (maskstr)
[551]	165	SetMask(maskstr, &Mask);
	166	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
	167	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
	168	while (pci && (INT) pci != -1) {
[2]	169	markit = FALSE;
[362]	170	if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
	171	if (!is_arc) {
[551]	172	if (files && !(pci->attrFile & FILE_DIRECTORY))
	173	markit = TRUE;
	174	if (dirs && (pci->attrFile & FILE_DIRECTORY))
	175	markit = TRUE;
[2]	176	}
	177	else
[551]	178	markit = TRUE;
[442]	179	if (maskstr && *maskstr && markit) {
[551]	180	markit = FALSE;
	181	file = strrchr(pci->szFileName, '\\');
	182	if (!file)
	183	file = strrchr(pci->szFileName, ':');
	184	if (file)
	185	file++;
	186	else
	187	file = pci->szFileName;
	188	for (x = 0; Mask.pszMasks[x]; x++) {
	189	if (*Mask.pszMasks[x]) {
	190	if (*Mask.pszMasks[x] != '/') {
	191	if (wildcard((strchr(Mask.pszMasks[x], '\\') \|\|
	192	strchr(Mask.pszMasks[x], ':')) ?
	193	pci->szFileName : file, Mask.pszMasks[x], FALSE))
	194	markit = TRUE;
	195	}
	196	else {
	197	if (wildcard((strchr(Mask.pszMasks[x], '\\') \|\| //fixme always true?
	198	strchr(Mask.pszMasks[x], ':'), FALSE) ?
	199	pci->szFileName : file, Mask.pszMasks[x] + 1,
	200	FALSE)) {
	201	markit = FALSE;
	202	break;
	203	}
	204	}
	205	}
	206	}
[2]	207	}
	208	}
[362]	209	if (markit && text && *text && !(pci->attrFile & FILE_DIRECTORY)) {
[2]	210
	211	CHAR *input;
	212
	213	markit = FALSE;
[551]	214	input = xmalloc(65537, pszSrcFile, __LINE__);
[362]	215	if (input) {
[551]	216	ULONG pos;
	217	LONG len;
	218	FILE *inputFile;
[2]	219
[551]	220	if ((inputFile = _fsopen(pci->szFileName, "rb", SH_DENYNO)) != NULL) {
	221	pos = ftell(inputFile);
	222	while (!feof(inputFile)) {
	223	if (pos)
	224	fseek(inputFile, pos - 256, SEEK_SET);
	225	len = fread(input, 1, 65536, inputFile);
	226	if (len >= 0) {
	227	if (findstring(text, textlen, input, len, FALSE)) {
	228	markit = TRUE;
	229	break;
	230	}
	231	}
	232	else
	233	break;
	234	}
	235	fclose(inputFile);
	236	}
	237	free(input);
	238	DosSleep(1L);
[2]	239	}
	240	}
[362]	241	else if (markit && text && *text && (pci->attrFile & FILE_DIRECTORY))
[2]	242	markit = FALSE;
[362]	243	if (markit)
[551]	244	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	245	MPFROM2SHORT(TRUE, CRA_SELECTED));
	246	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
	247	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
	248	} // while
[2]	249	}
	250
[551]	251	VOID DeselectAll(HWND hwndCnr, BOOL files, BOOL dirs, CHAR * maskstr,
	252	CHAR * text, BOOL is_arc)
[362]	253	{
[551]	254	PCNRITEM pci;
	255	BOOL unmarkit;
[2]	256	register CHAR *file;
[551]	257	MASK Mask;
	258	register INT x;
	259	ULONG textlen = 0;
[2]	260
[362]	261	if (text)
[2]	262	textlen = strlen(text);
[551]	263	memset(&Mask, 0, sizeof(Mask));
[442]	264	if (maskstr && *maskstr)
[551]	265	SetMask(maskstr, &Mask);
	266	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
	267	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
	268	while (pci && (INT) pci != -1) {
[2]	269	unmarkit = FALSE;
[362]	270	if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
	271	if (!is_arc) {
[551]	272	if (files && !(pci->attrFile & FILE_DIRECTORY))
	273	unmarkit = TRUE;
	274	if (dirs && (pci->attrFile & FILE_DIRECTORY))
	275	unmarkit = TRUE;
[2]	276	}
	277	else
[551]	278	unmarkit = TRUE;
[442]	279	if (maskstr && *maskstr && unmarkit) {
[551]	280	unmarkit = FALSE;
	281	file = strrchr(pci->szFileName, '\\');
	282	if (!file)
	283	file = strrchr(pci->szFileName, ':');
	284	if (file)
	285	file++;
	286	else
	287	file = pci->szFileName;
	288	for (x = 0; Mask.pszMasks[x]; x++) {
	289	if (*Mask.pszMasks[x]) {
	290	if (*Mask.pszMasks[x] != '/') {
	291	if (wildcard((strchr(Mask.pszMasks[x], '\\') \|\|
	292	strchr(Mask.pszMasks[x], ':')) ?
	293	pci->szFileName : file, Mask.pszMasks[x], FALSE))
	294	unmarkit = TRUE;
	295	}
	296	else {
	297	if (wildcard((strchr(Mask.pszMasks[x], '\\') \|\|
	298	strchr(Mask.pszMasks[x], ':')) ?
	299	pci->szFileName : file, Mask.pszMasks[x] + 1,
	300	FALSE)) {
	301	unmarkit = FALSE;
	302	break;
	303	}
	304	}
	305	}
	306	}
[2]	307	}
	308	}
[362]	309	if (unmarkit && text && *text && !(pci->attrFile & FILE_DIRECTORY)) {
[2]	310
	311	CHAR *input;
	312
	313	unmarkit = FALSE;
[551]	314	input = xmalloc(65537, pszSrcFile, __LINE__);
[362]	315	if (input) {
[551]	316	ULONG pos;
	317	LONG len;
	318	FILE *inputFile;
[2]	319
[551]	320	if ((inputFile = _fsopen(pci->szFileName, "rb", SH_DENYNO)) != NULL) {
	321	pos = ftell(inputFile);
	322	while (!feof(inputFile)) {
	323	if (pos)
	324	fseek(inputFile, pos - 256, SEEK_SET);
	325	len = fread(input, 1, 65536, inputFile);
	326	if (len >= 0) {
	327	if (findstring(text, textlen, input, len, FALSE)) {
	328	unmarkit = TRUE;
	329	break;
	330	}
	331	}
	332	else
	333	break;
	334	}
	335	fclose(inputFile);
	336	}
	337	free(input);
	338	DosSleep(1L);
[2]	339	}
	340	}
[362]	341	else if (unmarkit && text && *text && (pci->attrFile & FILE_DIRECTORY))
[2]	342	unmarkit = FALSE;
[362]	343	if (unmarkit)
[551]	344	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pci,
	345	MPFROM2SHORT(FALSE, CRA_SELECTED \| CRA_CURSORED \|
	346	CRA_INUSE \| CRA_SOURCE));
	347	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
	348	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[2]	349	}
	350	}
	351
[551]	352	VOID Deselect(HWND hwndCnr)
[317]	353	{
[2]	354	PCNRITEM pcil;
	355
[551]	356	pcil = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
	357	MPFROMLONG(CMA_FIRST),
	358	MPFROMSHORT(CRA_SELECTED));
	359	while (pcil && (INT) pcil != -1) {
	360	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pcil),
	361	MPFROM2SHORT(FALSE, CRA_SELECTED));
	362	pcil = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pcil),
	363	MPFROMSHORT(CRA_SELECTED));
[2]	364	}
	365	}
	366
[317]	367	//=== HideAll() Hide all selected records ===
[2]	368
[551]	369	VOID HideAll(HWND hwndCnr)
[317]	370	{
[551]	371	PCNRITEM pci, pciH;
	372	INT attribute = CRA_CURSORED;
	373	CNRINFO cnri;
	374	BOOL didone = FALSE;
[2]	375
[551]	376	memset(&cnri, 0, sizeof(CNRINFO));
[2]	377	cnri.cb = sizeof(CNRINFO);
[551]	378	WinSendMsg(hwndCnr, CM_QUERYCNRINFO, MPFROMP(&cnri),
	379	MPFROMLONG(sizeof(CNRINFO)));
	380	pci = (PCNRITEM) CurrentRecord(hwndCnr);
	381	if (pci && (INT) pci != -1) {
[362]	382	if (pci->rc.flRecordAttr & CRA_SELECTED) {
[2]	383	attribute = CRA_SELECTED;
[551]	384	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
	385	MPFROMSHORT(attribute));
[2]	386	}
	387	}
[551]	388	while (pci && (INT) pci != -1) {
	389	pciH = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
	390	MPFROMSHORT(attribute));
	391	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	392	MPFROM2SHORT(FALSE, CRA_CURSORED \| CRA_SELECTED \|
	393	CRA_INUSE \| CRA_SOURCE));
[2]	394	pci->rc.flRecordAttr \|= CRA_FILTERED;
	395	didone = TRUE;
[362]	396	if (fSyncUpdates) {
	397	if (cnri.flWindowAttr & CV_DETAIL)
[551]	398	WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPVOID,
	399	MPFROM2SHORT(0, CMA_REPOSITION \| CMA_ERASE));
[2]	400	else
[551]	401	WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPFROMP(&pci),
	402	MPFROM2SHORT(1, CMA_REPOSITION \| CMA_ERASE));
[2]	403	}
	404	pci = pciH;
	405	}
[362]	406	if (didone && !fSyncUpdates)
[551]	407	WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPVOID,
	408	MPFROM2SHORT(0, CMA_ERASE \| CMA_REPOSITION));
[2]	409	}
	410
[551]	411	VOID MarkAll(HWND hwndCnr, BOOL quitit, BOOL target, BOOL source)
[317]	412	{
[2]	413	PCNRITEM pci;
[551]	414	INT attribute = CRA_CURSORED;
[2]	415
[362]	416	if (quitit)
[2]	417	attribute = (target) ? CRA_TARGET : (source) ? CRA_SOURCE : CRA_INUSE;
[551]	418	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
	419	MPFROMLONG(CMA_FIRST), MPFROMSHORT(attribute));
	420	if (pci && (INT) pci != -1) {
[362]	421	if (attribute == CRA_CURSORED) {
	422	if (pci->rc.flRecordAttr & CRA_SELECTED) {
[551]	423	attribute = CRA_SELECTED;
	424	pci =
	425	WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
	426	MPFROMSHORT(attribute));
[2]	427	}
	428	}
	429	}
[551]	430	while (pci && (INT) pci != -1) {
	431	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	432	MPFROM2SHORT(!quitit,
	433	((target) ? CRA_TARGET : (source) ? CRA_SOURCE :
	434	CRA_INUSE)));
	435	pci =
	436	WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
	437	MPFROMSHORT(attribute));
[2]	438	}
	439	}
	440
[551]	441	VOID RemoveAll(HWND hwndCnr, ULONGLONG * pullTotalBytes,
	442	ULONG * pulTotalFiles)
[317]	443	{
[2]	444	PCNRITEM pci;
[551]	445	INT attribute = CRA_CURSORED;
	446	BOOL didone = FALSE;
[2]	447
[551]	448	pci = (PCNRITEM) CurrentRecord(hwndCnr);
	449	if (pci && (INT) pci != -1) {
[362]	450	if (pci->rc.flRecordAttr & CRA_SELECTED) {
[2]	451	attribute = CRA_SELECTED;
[551]	452	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
	453	MPFROMSHORT(attribute));
[2]	454	}
	455	}
[551]	456	while (pci && (INT) pci != -1) {
	457	if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
[2]	458	didone = TRUE;
[158]	459	if (pulTotalFiles)
[551]	460	*pulTotalFiles--;
[158]	461	if (pullTotalBytes)
[551]	462	*pullTotalBytes -= (pci->cbFile + pci->easize);
	463	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	464	MPFROM2SHORT(0, CRA_SELECTED));
[362]	465	if (fSyncUpdates)
[551]	466	WinSendMsg(hwndCnr, CM_REMOVERECORD, MPFROMP(&pci),
	467	MPFROM2SHORT(1, CMA_FREE \| CMA_INVALIDATE));
[2]	468	else
[551]	469	WinSendMsg(hwndCnr, CM_REMOVERECORD, MPFROMP(&pci),
	470	MPFROM2SHORT(1, CMA_FREE));
[362]	471	if (attribute == CRA_CURSORED)
[551]	472	break;
	473	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
	474	MPFROMSHORT(attribute));
[2]	475	}
	476	else
[551]	477	pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
	478	MPFROMSHORT(attribute));
[2]	479	}
[362]	480	if (didone && !fSyncUpdates)
[551]	481	WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPVOID,
	482	MPFROM2SHORT(0, CMA_REPOSITION));
[2]	483	}
	484
[442]	485	//== SetMask() Convert mask string to array of pointers to masks ==
	486
[551]	487	VOID SetMask(PSZ maskstr, MASK * mask)
[317]	488	{
[442]	489	UINT x;
	490	PSZ p;
[2]	491
[442]	492	if (maskstr)
[551]	493	strcpy(mask->szMask, maskstr); // Got new mask string
[442]	494	// Build array of pointers
	495	p = mask->szMaskCopy;
[551]	496	strcpy(p, mask->szMask);
	497	// memset(mask->pszMasks,0,sizeof(mask->pszMasks); // fixme to be gone
[442]	498	// Allow up to 25 masks - ignore extras
	499	for (x = 0; *p && x < 25; x++) {
	500	mask->pszMasks[x] = p;
[362]	501	while (p && p != ';')
[442]	502	p++; // Find separator
[362]	503	if (*p) {
[442]	504	*p = 0; // Replace ;
[2]	505	p++;
	506	}
[551]	507	} // for
[442]	508	mask->pszMasks[x] = NULL; // Mark end
[2]	509	}
	510
[551]	511	VOID ExpandAll(HWND hwndCnr, BOOL expand, PCNRITEM pciParent)
[317]	512	{
[2]	513	PCNRITEM pci;
	514
[362]	515	if (!pciParent)
[551]	516	pciParent = WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(NULL),
	517	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
[362]	518	if (pciParent) {
	519	if (expand && !(pciParent->rc.flRecordAttr & CRA_EXPANDED))
[551]	520	WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciParent), MPVOID);
[362]	521	else if (!expand && (pciParent->rc.flRecordAttr & CRA_EXPANDED))
[551]	522	WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciParent), MPVOID);
	523	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pciParent),
	524	MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
[362]	525	if (pci)
[2]	526	DosSleep(1L);
[551]	527	while (pci && (INT) pci != -1) {
	528	ExpandAll(hwndCnr, expand, pci);
	529	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
	530	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[2]	531	}
	532	}
	533	DosSleep(0L);
	534	}
	535
[551]	536	VOID InvertAll(HWND hwndCnr)
[317]	537	{
[2]	538	PCNRITEM pci;
	539
[551]	540	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPVOID,
	541	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
	542	while (pci && (INT) pci != -1) {
[362]	543	if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
	544	if (!(pci->rc.flRecordAttr & CRA_SELECTED))
[551]	545	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	546	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	547	else
[551]	548	WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	549	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	550	}
[551]	551	pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
	552	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[2]	553	}
	554	}
	555
[204]	556	#pragma alloc_text (SELECT3,SpecialSelect)
[2]	557	#pragma alloc_text(SELECT4,FreeCnrs,SpecialSelect2,CompSSNames,CompSSNamesB)
	558
[551]	559	VOID SpecialSelect(HWND hwndCnrS, HWND hwndCnrD, INT action, BOOL reset)
[317]	560	{
[551]	561	PCNRITEM pciS, pciD, pciSa = NULL, pciDa = NULL;
	562	CNRINFO cnri;
	563	BOOL slow = FALSE;
	564	register INT x, numD, numS;
[2]	565
[362]	566	if (!hwndCnrS \|\| !hwndCnrD)
[2]	567	return;
	568
[551]	569	memset(&cnri, 0, sizeof(CNRINFO));
[2]	570	cnri.cb = sizeof(CNRINFO);
[551]	571	WinSendMsg(hwndCnrD, CM_QUERYCNRINFO, MPFROMP(&cnri),
	572	MPFROMLONG(sizeof(CNRINFO)));
	573	numD = (INT) cnri.cRecords;
	574	memset(&cnri, 0, sizeof(CNRINFO));
[2]	575	cnri.cb = sizeof(CNRINFO);
[551]	576	WinSendMsg(hwndCnrS, CM_QUERYCNRINFO, MPFROMP(&cnri),
	577	MPFROMLONG(sizeof(CNRINFO)));
	578	numS = (INT) cnri.cRecords;
[362]	579	if (!numD \|\| numS != numD) {
[2]	580	saymsg(MB_ENTER,
[551]	581	HWND_DESKTOP,
	582	DEBUG_STRING, "numD (%lu) != numS (%lu)", numD, numS);
[2]	583	return;
	584	}
[551]	585	pciDa = xmalloc(sizeof(PCNRITEM) * numD, pszSrcFile, __LINE__);
[362]	586	if (!pciDa)
[2]	587	return;
	588
[551]	589	pciSa = xmalloc(sizeof(PCNRITEM) * numS, pszSrcFile, __LINE__);
[362]	590	if (!pciSa) {
	591	free(pciDa);
[2]	592	return;
	593	}
	594
	595	Restart:
	596
[551]	597	memset(pciDa, 0, sizeof(PCNRITEM) * numD);
	598	memset(pciSa, 0, sizeof(PCNRITEM) * numS);
[2]	599
[551]	600	pciD = (PCNRITEM) WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPVOID,
	601	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
[2]	602	x = 0;
[551]	603	while (pciD && (INT) pciD != -1 && x < numD) {
[362]	604	if (reset)
[2]	605	pciD->flags = 0;
	606	pciDa[x] = pciD;
	607	x++;
[362]	608	if (!slow)
[551]	609	pciD = (PCNRITEM) pciD->rc.preccNextRecord;
[2]	610	else
[551]	611	pciD = (PCNRITEM) WinSendMsg(hwndCnrD, CM_QUERYRECORD, MPFROMP(pciD),
	612	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[362]	613	if (!(x % 500))
[2]	614	DosSleep(1L);
[362]	615	else if (!(x % 50))
[2]	616	DosSleep(0L);
	617	}
[362]	618	if (numD != x) {
	619	if (!slow) {
[2]	620	slow = TRUE;
	621	goto Restart;
	622	}
	623	free(pciDa);
	624	free(pciSa);
	625	saymsg(MB_ENTER,
[551]	626	HWND_DESKTOP, DEBUG_STRING, "numD (%lu) != x (%lu)", numD, x);
[2]	627	return;
	628	}
	629
[551]	630	pciS = (PCNRITEM) WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPVOID,
	631	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
[2]	632	x = 0;
[551]	633	while (pciS && (INT) pciS != -1 && x < numS) {
[362]	634	if (reset)
[2]	635	pciS->flags = 0;
	636	pciSa[x] = pciS;
	637	x++;
[362]	638	if (!slow)
[551]	639	pciS = (PCNRITEM) pciS->rc.preccNextRecord;
[2]	640	else
[551]	641	pciS = (PCNRITEM) WinSendMsg(hwndCnrS, CM_QUERYRECORD, MPFROMP(pciS),
	642	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[362]	643	if (!(x % 500))
[2]	644	DosSleep(1L);
[362]	645	else if (!(x % 50))
[2]	646	DosSleep(0L);
	647	}
[362]	648	if (numS != x) {
	649	if (!slow) {
[2]	650	slow = TRUE;
	651	goto Restart;
	652	}
	653	free(pciSa);
	654	free(pciDa);
[551]	655	Runtime_Error(pszSrcFile, __LINE__, "numS (%lu) != x (%lu)", numS, x);
[2]	656	return;
	657	}
	658
[362]	659	if (reset) {
[551]	660	for (x = 0; x < numS; x++) {
[362]	661	if (!pciSa[x]->szFileName \|\| !pciDa[x]->szFileName)
[551]	662	continue;
[2]	663	pciSa[x]->flags \|= CNRITEM_EXISTS;
	664	pciDa[x]->flags \|= CNRITEM_EXISTS;
[362]	665	if (pciSa[x]->cbFile + pciSa[x]->easize >
[551]	666	pciDa[x]->cbFile + pciDa[x]->easize) {
	667	pciSa[x]->flags \|= CNRITEM_LARGER;
	668	pciDa[x]->flags \|= CNRITEM_SMALLER;
[2]	669	}
[362]	670	else if (pciSa[x]->cbFile + pciSa[x]->easize <
[551]	671	pciDa[x]->cbFile + pciDa[x]->easize) {
	672	pciSa[x]->flags \|= CNRITEM_SMALLER;
	673	pciDa[x]->flags \|= CNRITEM_LARGER;
[2]	674	}
[362]	675	if ((pciSa[x]->date.year > pciDa[x]->date.year) ? TRUE :
[551]	676	(pciSa[x]->date.year < pciDa[x]->date.year) ? FALSE :
	677	(pciSa[x]->date.month > pciDa[x]->date.month) ? TRUE :
	678	(pciSa[x]->date.month < pciDa[x]->date.month) ? FALSE :
	679	(pciSa[x]->date.day > pciDa[x]->date.day) ? TRUE :
	680	(pciSa[x]->date.day < pciDa[x]->date.day) ? FALSE :
	681	(pciSa[x]->time.hours > pciDa[x]->time.hours) ? TRUE :
	682	(pciSa[x]->time.hours < pciDa[x]->time.hours) ? FALSE :
	683	(pciSa[x]->time.minutes > pciDa[x]->time.minutes) ? TRUE :
	684	(pciSa[x]->time.minutes < pciDa[x]->time.minutes) ? FALSE :
	685	(pciSa[x]->time.seconds > pciDa[x]->time.seconds) ? TRUE :
	686	(pciSa[x]->time.seconds < pciDa[x]->time.seconds) ? FALSE : FALSE) {
	687	pciSa[x]->flags \|= CNRITEM_NEWER;
	688	pciDa[x]->flags \|= CNRITEM_OLDER;
[2]	689	}
[362]	690	else if ((pciSa[x]->date.year < pciDa[x]->date.year) ? TRUE :
[551]	691	(pciSa[x]->date.year > pciDa[x]->date.year) ? FALSE :
	692	(pciSa[x]->date.month < pciDa[x]->date.month) ? TRUE :
	693	(pciSa[x]->date.month > pciDa[x]->date.month) ? FALSE :
	694	(pciSa[x]->date.day < pciDa[x]->date.day) ? TRUE :
	695	(pciSa[x]->date.day > pciDa[x]->date.day) ? FALSE :
	696	(pciSa[x]->time.hours < pciDa[x]->time.hours) ? TRUE :
	697	(pciSa[x]->time.hours > pciDa[x]->time.hours) ? FALSE :
	698	(pciSa[x]->time.minutes < pciDa[x]->time.minutes) ? TRUE :
	699	(pciSa[x]->time.minutes > pciDa[x]->time.minutes) ? FALSE :
	700	(pciSa[x]->time.seconds < pciDa[x]->time.seconds) ? TRUE :
	701	(pciSa[x]->time.seconds > pciDa[x]->time.seconds) ? FALSE :
	702	FALSE) {
	703	pciSa[x]->flags \|= CNRITEM_OLDER;
	704	pciDa[x]->flags \|= CNRITEM_NEWER;
[2]	705	}
[362]	706	if (!(x % 500))
[551]	707	DosSleep(1L);
[362]	708	else if (!(x % 50))
[551]	709	DosSleep(0L);
[2]	710	}
	711	}
	712
[551]	713	switch (action) {
	714	case IDM_SELECTIDENTICAL:
	715	for (x = 0; x < numS; x++) {
	716	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED)) {
	717	if (*pciSa[x]->szFileName &&
	718	(pciSa[x]->flags & CNRITEM_EXISTS) &&
	719	!(pciSa[x]->flags & CNRITEM_SMALLER) &&
	720	!(pciSa[x]->flags & CNRITEM_LARGER) &&
	721	!(pciSa[x]->flags & CNRITEM_NEWER) &&
	722	!(pciSa[x]->flags & CNRITEM_OLDER)) {
	723	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	724	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	725	MPFROM2SHORT(TRUE, CRA_SELECTED));
	726	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	727	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	728	MPFROM2SHORT(TRUE, CRA_SELECTED));
	729	}
	730	if (!(x % 500))
	731	DosSleep(1L);
	732	else if (!(x % 50))
	733	DosSleep(0L);
[2]	734	}
[551]	735	}
	736	break;
[2]	737
[551]	738	case IDM_SELECTSAME:
	739	for (x = 0; x < numS; x++) {
	740	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	741	*pciSa[x]->szFileName &&
	742	(pciSa[x]->flags & CNRITEM_EXISTS) &&
	743	!(pciSa[x]->flags & CNRITEM_SMALLER) &&
	744	!(pciSa[x]->flags & CNRITEM_LARGER)) {
	745	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	746	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	747	MPFROM2SHORT(TRUE, CRA_SELECTED));
	748	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	749	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	750	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	751	}
[551]	752	if (!(x % 500))
	753	DosSleep(1L);
	754	else if (!(x % 50))
	755	DosSleep(0L);
	756	}
	757	break;
[2]	758
[551]	759	case IDM_SELECTSAMECONTENT:
	760	// fixme
	761	for (x = 0; x < numS; x++) {
	762	if (~pciSa[x]->rc.flRecordAttr & CRA_FILTERED &&
	763	*pciSa[x]->szFileName &&
	764	*pciDa[x]->szFileName &&
	765	pciSa[x]->flags & CNRITEM_EXISTS &&
	766	pciDa[x]->flags & CNRITEM_EXISTS) {
[317]	767
[551]	768	FILE *fp1 = NULL;
	769	FILE *fp2 = NULL;
	770	BOOL gotMatch = FALSE;
	771	UINT errLineNo = 0;
	772	UINT compErrno = 0;
	773	CHAR buf1[1024];
	774	CHAR buf2[1024];
	775	HAB hab = WinQueryAnchorBlock(hwndCnrS);
[317]	776
[551]	777	fp1 = _fsopen(pciSa[x]->szFileName, "rb", SH_DENYNO);
	778	if (!fp1) {
	779	errLineNo = __LINE__;
	780	compErrno = errno;
	781	}
	782	else {
	783	fp2 = _fsopen(pciDa[x]->szFileName, "rb", SH_DENYNO);
	784	if (!fp2) {
[362]	785	errLineNo = __LINE__;
	786	compErrno = errno;
[317]	787	}
	788	else {
[551]	789	size_t len1 = filelength(fileno(fp1));
	790	size_t len2 = filelength(fileno(fp2));
	791
	792	if (len1 == len2) {
	793	setbuf(fp1, NULL);
	794	setbuf(fp2, NULL);
	795	while (WinIsWindow(hab, hwndCnrS)) {
	796	size_t numread1 = fread(buf1, 1, 1024, fp1);
	797	size_t numread2 = fread(buf2, 1, 1024, fp2);
	798
	799	if (!numread1 \|\| !numread2 \|\| numread1 != numread2) {
	800	if (ferror(fp1) \|\| ferror(fp2)) {
	801	errLineNo = __LINE__;
	802	compErrno = errno;
[317]	803	}
[551]	804	else if (feof(fp1) && feof(fp2))
	805	gotMatch = TRUE;
	806	break;
	807	}
	808	else if (memcmp(buf1, buf2, numread1))
	809	break;
	810	} // while
	811	} // same len
	812	}
	813	}
[317]	814
[551]	815	if (fp1)
	816	fclose(fp1);
[317]	817
[551]	818	if (fp2)
	819	fclose(fp2);
[317]	820
[551]	821	if (errLineNo) {
	822	Runtime_Error(pszSrcFile, errLineNo,
	823	"error %d while comparing", compErrno);
	824	}
	825	if (gotMatch) {
	826	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	827	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	828	MPFROM2SHORT(TRUE, CRA_SELECTED));
	829	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	830	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	831	MPFROM2SHORT(TRUE, CRA_SELECTED));
	832	}
	833	}
	834	if (!(x % 500))
	835	DosSleep(1L);
	836	else if (!(x % 50))
	837	DosSleep(0L);
	838	} // for records
	839	break;
[317]	840
[551]	841	case IDM_SELECTBOTH:
	842	for (x = 0; x < numS; x++) {
	843	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	844	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
	845	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	846	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	847	MPFROM2SHORT(TRUE, CRA_SELECTED));
	848	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	849	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	850	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	851	}
[551]	852	if (!(x % 500))
	853	DosSleep(1L);
	854	else if (!(x % 50))
	855	DosSleep(0L);
	856	}
	857	break;
[2]	858
[551]	859	case IDM_SELECTONE:
	860	for (x = 0; x < numS; x++) {
	861	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	862	*pciSa[x]->szFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
	863	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	864	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	865	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	866	}
[551]	867	else if (*pciDa[x]->szFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
	868	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	869	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	870	MPFROM2SHORT(TRUE, CRA_SELECTED));
	871	}
	872	if (!(x % 500))
	873	DosSleep(1L);
	874	else if (!(x % 50))
	875	DosSleep(0L);
	876	}
	877	break;
[2]	878
[551]	879	case IDM_SELECTBIGGER:
	880	for (x = 0; x < numS; x++) {
	881	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	882	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
	883	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	884	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	885	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	886	}
[551]	887	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	888	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
	889	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	890	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	891	MPFROM2SHORT(TRUE, CRA_SELECTED));
	892	}
	893	if (!(x % 500))
	894	DosSleep(1L);
	895	else if (!(x % 50))
	896	DosSleep(0L);
	897	}
	898	break;
[2]	899
[551]	900	case IDM_SELECTSMALLER:
	901	for (x = 0; x < numS; x++) {
	902	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	903	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
	904	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	905	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	906	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	907	}
[551]	908	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	909	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
	910	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	911	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	912	MPFROM2SHORT(TRUE, CRA_SELECTED));
	913	}
	914	if (!(x % 500))
	915	DosSleep(1L);
	916	else if (!(x % 50))
	917	DosSleep(0L);
	918	}
	919	break;
[2]	920
[551]	921	case IDM_SELECTNEWER:
	922	for (x = 0; x < numS; x++) {
	923	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	924	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
	925	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	926	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	927	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	928	}
[551]	929	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	930	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
	931	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	932	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	933	MPFROM2SHORT(TRUE, CRA_SELECTED));
	934	}
	935	if (!(x % 500))
	936	DosSleep(1L);
	937	else if (!(x % 50))
	938	DosSleep(0L);
	939	}
	940	break;
[2]	941
[551]	942	case IDM_SELECTOLDER:
	943	for (x = 0; x < numS; x++) {
	944	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	945	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
	946	if (!(pciSa[x]->rc.flRecordAttr & CRA_SELECTED))
	947	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	948	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	949	}
[551]	950	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	951	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
	952	if (!(pciDa[x]->rc.flRecordAttr & CRA_SELECTED))
	953	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	954	MPFROM2SHORT(TRUE, CRA_SELECTED));
	955	}
	956	if (!(x % 500))
	957	DosSleep(1L);
	958	else if (!(x % 50))
	959	DosSleep(0L);
	960	}
	961	break;
[2]	962
[551]	963	case IDM_DESELECTBOTH:
	964	for (x = 0; x < numS; x++) {
	965	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	966	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_EXISTS)) {
	967	if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
	968	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	969	MPFROM2SHORT(FALSE, CRA_SELECTED));
	970	if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
	971	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	972	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	973	}
[551]	974	if (!(x % 500))
	975	DosSleep(1L);
	976	else if (!(x % 50))
	977	DosSleep(0L);
	978	}
	979	break;
[2]	980
[551]	981	case IDM_DESELECTONE:
	982	for (x = 0; x < numS; x++) {
	983	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	984	*pciSa[x]->szFileName && !(pciSa[x]->flags & CNRITEM_EXISTS)) {
	985	if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
	986	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	987	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	988	}
[551]	989	else if (*pciDa[x]->szFileName && !(pciDa[x]->flags & CNRITEM_EXISTS)) {
	990	if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
	991	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	992	MPFROM2SHORT(FALSE, CRA_SELECTED));
	993	}
	994	if (!(x % 500))
	995	DosSleep(1L);
	996	else if (!(x % 50))
	997	DosSleep(0L);
	998	}
	999	break;
[2]	1000
[551]	1001	case IDM_DESELECTBIGGER:
	1002	for (x = 0; x < numS; x++) {
	1003	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1004	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_LARGER)) {
	1005	if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
	1006	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	1007	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1008	}
[551]	1009	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1010	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_LARGER)) {
	1011	if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
	1012	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	1013	MPFROM2SHORT(FALSE, CRA_SELECTED));
	1014	}
	1015	if (!(x % 500))
	1016	DosSleep(1L);
	1017	else if (!(x % 50))
	1018	DosSleep(0L);
	1019	}
	1020	break;
[2]	1021
[551]	1022	case IDM_DESELECTSMALLER:
	1023	for (x = 0; x < numS; x++) {
	1024	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1025	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_SMALLER)) {
	1026	if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
	1027	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	1028	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1029	}
[551]	1030	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1031	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_SMALLER)) {
	1032	if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
	1033	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	1034	MPFROM2SHORT(FALSE, CRA_SELECTED));
	1035	}
	1036	if (!(x % 500))
	1037	DosSleep(1L);
	1038	else if (!(x % 50))
	1039	DosSleep(0L);
	1040	}
	1041	break;
[2]	1042
[551]	1043	case IDM_DESELECTNEWER:
	1044	for (x = 0; x < numS; x++) {
	1045	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1046	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_NEWER)) {
	1047	if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
	1048	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	1049	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1050	}
[551]	1051	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1052	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_NEWER)) {
	1053	if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
	1054	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	1055	MPFROM2SHORT(FALSE, CRA_SELECTED));
	1056	}
	1057	if (!(x % 500))
	1058	DosSleep(1L);
	1059	else if (!(x % 50))
	1060	DosSleep(0L);
	1061	}
	1062	break;
[2]	1063
[551]	1064	case IDM_DESELECTOLDER:
	1065	for (x = 0; x < numS; x++) {
	1066	if (!(pciSa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1067	*pciSa[x]->szFileName && (pciSa[x]->flags & CNRITEM_OLDER)) {
	1068	if (pciSa[x]->rc.flRecordAttr & CRA_SELECTED)
	1069	WinSendMsg(hwndCnrS, CM_SETRECORDEMPHASIS, MPFROMP(pciSa[x]),
	1070	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1071	}
[551]	1072	else if (!(pciDa[x]->rc.flRecordAttr & CRA_FILTERED) &&
	1073	*pciDa[x]->szFileName && (pciDa[x]->flags & CNRITEM_OLDER)) {
	1074	if (pciDa[x]->rc.flRecordAttr & CRA_SELECTED)
	1075	WinSendMsg(hwndCnrD, CM_SETRECORDEMPHASIS, MPFROMP(pciDa[x]),
	1076	MPFROM2SHORT(FALSE, CRA_SELECTED));
	1077	}
	1078	if (!(x % 500))
	1079	DosSleep(1L);
	1080	else if (!(x % 50))
	1081	DosSleep(0L);
	1082	}
	1083	break;
[2]	1084
[551]	1085	default:
	1086	break;
[2]	1087	}
	1088
[362]	1089	if (reset) {
	1090	while (numS) {
[551]	1091	WinSendMsg(hwndCnrS, CM_INVALIDATERECORD,
	1092	MPFROMP(pciSa), MPFROM2SHORT((min(numS, 65535)), 0));
[2]	1093	DosSleep(0L);
[551]	1094	WinSendMsg(hwndCnrD, CM_INVALIDATERECORD,
	1095	MPFROMP(pciDa), MPFROM2SHORT((min(numD, 65535)), 0));
	1096	numS -= min(numS, 65535);
[362]	1097	if (numS)
[551]	1098	DosSleep(0L);
[2]	1099	}
	1100	}
	1101
	1102	free(pciSa);
	1103	free(pciDa);
	1104	DosPostEventSem(CompactSem);
	1105	}
	1106
[551]	1107	struct SS
	1108	{
	1109	PCNRITEM pci;
	1110	BOOL unique, all, smallest, largest, newest, oldest;
[2]	1111	};
	1112
[551]	1113	struct Cnr
	1114	{
	1115	HWND hwndCnr;
	1116	ULONG numfiles;
[2]	1117	struct SS *ss;
	1118	};
	1119
[551]	1120	static int CompSSNamesB(const void s1, const void s2)
[317]	1121	{
[2]	1122	struct SS ss2 = (struct SS )s2;
	1123
[551]	1124	return stricmp((CHAR *) s1, ss2->pci->pszFileName);
[2]	1125	}
	1126
[551]	1127	static int CompSSNames(const void s1, const void s2)
[317]	1128	{
[2]	1129	struct SS ss1 = (struct SS )s1;
	1130	struct SS ss2 = (struct SS )s2;
	1131
[551]	1132	return stricmp(ss1->pci->pszFileName, ss2->pci->pszFileName);
[2]	1133	}
	1134
[551]	1135	VOID FreeCnrs(struct Cnr * Cnrs, INT numw)
[317]	1136	{
[2]	1137	register INT z;
	1138
[551]	1139	for (z = 0; z < numw; z++) {
[362]	1140	if (Cnrs[z].ss)
[2]	1141	free(Cnrs[z].ss);
	1142	}
	1143	free(Cnrs);
	1144	DosPostEventSem(CompactSem);
	1145	}
	1146
[551]	1147	VOID SpecialSelect2(HWND hwndParent, INT action)
[317]	1148	{
[551]	1149	PCNRITEM pci;
	1150	HENUM henum;
	1151	HWND hwnd;
	1152	register INT numwindows = 0, w, x, z, cmp;
	1153	struct Cnr *Cnrs = NULL;
	1154	struct SS *bsres;
[2]	1155
[362]	1156	if (!hwndParent)
[2]	1157	return;
	1158
	1159	/* count directory containers, build array of hwnds */
	1160	henum = WinBeginEnumWindows(hwndParent);
[362]	1161	while ((hwnd = WinGetNextWindow(henum)) != NULLHANDLE) {
[551]	1162	if (WinWindowFromID(WinWindowFromID(hwnd, FID_CLIENT), DIR_CNR)) {
	1163	Cnrs =
	1164	xrealloc(Cnrs, (numwindows + 1) * sizeof(struct Cnr), pszSrcFile,
	1165	__LINE__);
[362]	1166	if (!Cnrs) {
[551]	1167	Notify(GetPString(IDS_OUTOFMEMORY));
	1168	return;
[2]	1169	}
[551]	1170	memset(&Cnrs[numwindows], 0, sizeof(struct Cnr));
[2]	1171	Cnrs[numwindows].hwndCnr = WinWindowFromID(WinWindowFromID(hwnd,
[551]	1172	FID_CLIENT),
	1173	DIR_CNR);
[2]	1174	numwindows++;
	1175	}
	1176	}
	1177	WinEndEnumWindows(henum);
[362]	1178	if (numwindows < 2) {
[551]	1179	FreeCnrs(Cnrs, numwindows);
[362]	1180	Runtime_Error(pszSrcFile, __LINE__, "expected two windows");
	1181	// fixme DosBeep(250,100);
[2]	1182	Notify(GetPString(IDS_COMPSEL2ORMORETEXT));
	1183	return;
	1184	}
[362]	1185	if (numwindows > 4) {
[2]	1186	WinSendMsg(Cnrs[0].
[551]	1187	hwndCnr,
	1188	UM_NOTIFY, MPFROMP(GetPString(IDS_BUILDINGLISTSTEXT)), MPVOID);
[2]	1189	DosSleep(0L);
	1190	}
	1191
	1192	/* count records, build array of pointers to records */
[551]	1193	for (z = 0; z < numwindows; z++) {
	1194	pci = (PCNRITEM) WinSendMsg(Cnrs[z].hwndCnr,
	1195	CM_QUERYRECORD,
	1196	MPVOID,
	1197	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
[2]	1198	x = 0;
[551]	1199	while (pci && (INT) pci != -1) {
[362]	1200	if (!(pci->rc.flRecordAttr & CRA_FILTERED) &&
[551]	1201	!(pci->attrFile & FILE_DIRECTORY)) {
	1202	Cnrs[z].ss =
	1203	xrealloc(Cnrs[z].ss, (x + 1) * sizeof(struct SS), pszSrcFile,
	1204	__LINE__);
	1205	if (!Cnrs[z].ss) {
	1206	FreeCnrs(Cnrs, numwindows);
	1207	Notify(GetPString(IDS_OUTOFMEMORY));
	1208	return;
	1209	}
	1210	memset(&Cnrs[z].ss[x], 0, sizeof(struct SS));
	1211	Cnrs[z].ss[x].pci = pci;
	1212	x++;
[2]	1213	}
[551]	1214	pci = (PCNRITEM) WinSendMsg(Cnrs[z].hwndCnr,
	1215	CM_QUERYRECORD,
	1216	MPFROMP(pci),
	1217	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[2]	1218	}
	1219	DosSleep(0L);
	1220	Cnrs[z].numfiles = x;
[362]	1221	if (Cnrs[z].numfiles)
[551]	1222	qsort(Cnrs[z].ss, Cnrs[z].numfiles, sizeof(struct SS), CompSSNames);
[2]	1223	}
	1224
[551]	1225	for (z = 0; z < numwindows; z++) {
	1226	for (x = 0; x < Cnrs[z].numfiles; x++) {
[2]	1227	Cnrs[z].ss[x].all = Cnrs[z].ss[x].unique = Cnrs[z].ss[x].newest =
[551]	1228	Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].smallest =
	1229	Cnrs[z].ss[x].largest = TRUE;
	1230	for (w = 0; w < numwindows; w++) {
	1231	if (w != z && Cnrs[w].numfiles) {
	1232	bsres = (struct SS *)bsearch(Cnrs[z].ss[x].pci->pszFileName,
	1233	Cnrs[w].ss, Cnrs[w].numfiles,
	1234	sizeof(struct SS), CompSSNamesB);
	1235	if (bsres) {
	1236	Cnrs[z].ss[x].unique = FALSE;
	1237	if (Cnrs[z].ss[x].pci->cbFile + Cnrs[z].ss[x].pci->easize >
	1238	bsres->pci->cbFile + bsres->pci->easize)
	1239	Cnrs[z].ss[x].smallest = FALSE;
	1240	if (Cnrs[z].ss[x].pci->cbFile + Cnrs[z].ss[x].pci->easize <
	1241	bsres->pci->cbFile + bsres->pci->easize)
	1242	Cnrs[z].ss[x].largest = FALSE;
	1243	cmp =
	1244	(Cnrs[z].ss[x].pci->date.year >
	1245	bsres->pci->date.year) ? TRUE : (Cnrs[z].ss[x].pci->date.year <
	1246	bsres->pci->date.
	1247	year) ? FALSE : (Cnrs[z].
	1248	ss[x].pci->
	1249	date.month >
	1250	bsres->pci->
	1251	date.
	1252	month) ? TRUE
	1253	: (Cnrs[z].ss[x].pci->date.month <
	1254	bsres->pci->date.month) ? FALSE : (Cnrs[z].ss[x].pci->date.
	1255	day >
	1256	bsres->pci->date.
	1257	day) ? TRUE : (Cnrs[z].
	1258	ss[x].pci->
	1259	date.day <
	1260	bsres->
	1261	pci->date.
	1262	day) ?
	1263	FALSE : (Cnrs[z].ss[x].pci->time.hours >
	1264	bsres->pci->time.hours) ? TRUE : (Cnrs[z].ss[x].pci->
	1265	time.hours <
	1266	bsres->pci->time.
	1267	hours) ? FALSE
	1268	: (Cnrs[z].ss[x].pci->time.minutes >
	1269	bsres->pci->time.minutes) ? TRUE : (Cnrs[z].ss[x].pci->time.
	1270	minutes <
	1271	bsres->pci->time.
	1272	minutes) ? FALSE
	1273	: (Cnrs[z].ss[x].pci->time.seconds >
	1274	bsres->pci->time.seconds) ? TRUE : (Cnrs[z].ss[x].pci->time.
	1275	seconds <
	1276	bsres->pci->time.
	1277	seconds) ? FALSE : FALSE;
	1278	if (!cmp)
	1279	Cnrs[z].ss[x].newest = FALSE;
	1280	cmp =
	1281	(Cnrs[z].ss[x].pci->date.year <
	1282	bsres->pci->date.year) ? TRUE : (Cnrs[z].ss[x].pci->date.year >
	1283	bsres->pci->date.
	1284	year) ? FALSE : (Cnrs[z].
	1285	ss[x].pci->
	1286	date.month <
	1287	bsres->pci->
	1288	date.
	1289	month) ? TRUE
	1290	: (Cnrs[z].ss[x].pci->date.month >
	1291	bsres->pci->date.month) ? FALSE : (Cnrs[z].ss[x].pci->date.
	1292	day <
	1293	bsres->pci->date.
	1294	day) ? TRUE : (Cnrs[z].
	1295	ss[x].pci->
	1296	date.day >
	1297	bsres->
	1298	pci->date.
	1299	day) ?
	1300	FALSE : (Cnrs[z].ss[x].pci->time.hours <
	1301	bsres->pci->time.hours) ? TRUE : (Cnrs[z].ss[x].pci->
	1302	time.hours >
	1303	bsres->pci->time.
	1304	hours) ? FALSE
	1305	: (Cnrs[z].ss[x].pci->time.minutes <
	1306	bsres->pci->time.minutes) ? TRUE : (Cnrs[z].ss[x].pci->time.
	1307	minutes >
	1308	bsres->pci->time.
	1309	minutes) ? FALSE
	1310	: (Cnrs[z].ss[x].pci->time.seconds <
	1311	bsres->pci->time.seconds) ? TRUE : (Cnrs[z].ss[x].pci->time.
	1312	seconds >
	1313	bsres->pci->time.
	1314	seconds) ? FALSE : FALSE;
	1315	if (!cmp)
	1316	Cnrs[z].ss[x].oldest = FALSE;
	1317	cmp = 0;
	1318	break;
	1319	}
	1320	else
	1321	Cnrs[z].ss[x].all = FALSE;
	1322	}
[2]	1323	}
[362]	1324	if (Cnrs[z].ss[x].unique)
[551]	1325	Cnrs[z].ss[x].oldest = Cnrs[z].ss[x].newest = Cnrs[z].ss[x].all =
	1326	Cnrs[z].ss[x].largest = Cnrs[z].ss[x].smallest = FALSE;
[2]	1327	DosSleep(0L);
	1328	}
	1329	DosSleep(1L);
	1330	}
	1331
[551]	1332	switch (action) {
	1333	case IDM_SELECTBOTH:
	1334	for (z = 0; z < numwindows; z++) {
	1335	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1336	if (Cnrs[z].ss[x].all)
	1337	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1338	MPFROMP(Cnrs[z].ss[x].pci),
	1339	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1340	}
[551]	1341	DosSleep(0L);
	1342	}
	1343	break;
	1344	case IDM_SELECTMORE:
	1345	for (z = 0; z < numwindows; z++) {
	1346	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1347	if (!Cnrs[z].ss[x].unique)
	1348	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1349	MPFROMP(Cnrs[z].ss[x].pci),
	1350	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1351	}
[551]	1352	DosSleep(0L);
	1353	}
	1354	break;
	1355	case IDM_SELECTONE:
	1356	for (z = 0; z < numwindows; z++) {
	1357	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1358	if (Cnrs[z].ss[x].unique)
	1359	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1360	MPFROMP(Cnrs[z].ss[x].pci),
	1361	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1362	}
[551]	1363	DosSleep(0L);
	1364	}
	1365	break;
	1366	case IDM_SELECTNEWER:
	1367	for (z = 0; z < numwindows; z++) {
	1368	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1369	if (Cnrs[z].ss[x].newest)
	1370	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1371	MPFROMP(Cnrs[z].ss[x].pci),
	1372	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1373	}
[551]	1374	DosSleep(0L);
	1375	}
	1376	break;
	1377	case IDM_SELECTOLDER:
	1378	for (z = 0; z < numwindows; z++) {
	1379	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1380	if (Cnrs[z].ss[x].oldest)
	1381	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1382	MPFROMP(Cnrs[z].ss[x].pci),
	1383	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1384	}
[551]	1385	DosSleep(0L);
	1386	}
	1387	break;
	1388	case IDM_SELECTBIGGER:
	1389	for (z = 0; z < numwindows; z++) {
	1390	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1391	if (Cnrs[z].ss[x].largest)
	1392	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1393	MPFROMP(Cnrs[z].ss[x].pci),
	1394	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1395	}
[551]	1396	DosSleep(0L);
	1397	}
	1398	break;
	1399	case IDM_SELECTSMALLER:
	1400	for (z = 0; z < numwindows; z++) {
	1401	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1402	if (Cnrs[z].ss[x].smallest)
	1403	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1404	MPFROMP(Cnrs[z].ss[x].pci),
	1405	MPFROM2SHORT(TRUE, CRA_SELECTED));
[2]	1406	}
[551]	1407	DosSleep(0L);
	1408	}
	1409	break;
[2]	1410
[551]	1411	case IDM_DESELECTBOTH:
	1412	for (z = 0; z < numwindows; z++) {
	1413	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1414	if (Cnrs[z].ss[x].all)
	1415	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1416	MPFROMP(Cnrs[z].ss[x].pci),
	1417	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1418	}
[551]	1419	DosSleep(0L);
	1420	}
	1421	break;
	1422	case IDM_DESELECTMORE:
	1423	for (z = 0; z < numwindows; z++) {
	1424	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1425	if (!Cnrs[z].ss[x].unique)
	1426	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1427	MPFROMP(Cnrs[z].ss[x].pci),
	1428	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1429	}
[551]	1430	DosSleep(0L);
	1431	}
	1432	break;
	1433	case IDM_DESELECTONE:
	1434	for (z = 0; z < numwindows; z++) {
	1435	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1436	if (Cnrs[z].ss[x].unique)
	1437	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1438	MPFROMP(Cnrs[z].ss[x].pci),
	1439	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1440	}
[551]	1441	DosSleep(0L);
	1442	}
	1443	break;
	1444	case IDM_DESELECTNEWER:
	1445	for (z = 0; z < numwindows; z++) {
	1446	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1447	if (Cnrs[z].ss[x].newest)
	1448	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1449	MPFROMP(Cnrs[z].ss[x].pci),
	1450	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1451	}
[551]	1452	DosSleep(0L);
	1453	}
	1454	break;
	1455	case IDM_DESELECTOLDER:
	1456	for (z = 0; z < numwindows; z++) {
	1457	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1458	if (Cnrs[z].ss[x].oldest)
	1459	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1460	MPFROMP(Cnrs[z].ss[x].pci),
	1461	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1462	}
[551]	1463	DosSleep(0L);
	1464	}
	1465	break;
	1466	case IDM_DESELECTBIGGER:
	1467	for (z = 0; z < numwindows; z++) {
	1468	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1469	if (Cnrs[z].ss[x].largest)
	1470	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1471	MPFROMP(Cnrs[z].ss[x].pci),
	1472	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1473	}
[551]	1474	DosSleep(0L);
	1475	}
	1476	break;
	1477	case IDM_DESELECTSMALLER:
	1478	for (z = 0; z < numwindows; z++) {
	1479	for (x = 0; x < Cnrs[z].numfiles; x++) {
	1480	if (Cnrs[z].ss[x].smallest)
	1481	WinSendMsg(Cnrs[z].hwndCnr, CM_SETRECORDEMPHASIS,
	1482	MPFROMP(Cnrs[z].ss[x].pci),
	1483	MPFROM2SHORT(FALSE, CRA_SELECTED));
[2]	1484	}
[551]	1485	DosSleep(0L);
	1486	}
	1487	break;
[2]	1488	}
	1489
[551]	1490	FreeCnrs(Cnrs, numwindows);
[2]	1491	}

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

Download in other formats: