Context Navigation

source: trunk/dll/collect.c@ 433

Visit:

Last change on this file since 433 was 403, checked in by root, 19 years ago
Avoid shutdown hang - pre3 typo Use xfgets_bstripcr
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 72.5 KB

Rev	Line
[96]	1
	2	/***********************************************************************
	3
	4	$Id: collect.c 403 2006-07-29 20:00:53Z root $
	5
	6	Collector
	7
	8	Copyright (c) 1993-98 M. Kimes
[352]	9	Copyright (c) 2003, 2006 Steven H. Levine
[96]	10
[130]	11	15 Oct 02 MK Baseline
	12	10 Jan 04 SHL Avoid -1L byte counts
	13	01 Aug 04 SHL Rework lstrip/rstrip usage
	14	23 May 05 SHL Use QWL_USER
[145]	15	24 May 05 SHL Rework Win_Error usage
[155]	16	25 May 05 SHL Use ULONGLONG and CommaFmtULL
	17	25 May 05 SHL Rework for FillInRecordFromFFB
[186]	18	05 Jun 05 SHL Use QWL_USER
[194]	19	06 Jun 05 SHL Indent -i2
[197]	20	06 Jun 05 SHL Make savedSortFlags static to avoid referencing garbage
[280]	21	24 Oct 05 SHL Sanitize handle references
	22	24 Oct 05 SHL CollectorCnrWndProc: avoid excess writes to Status2 window
	23	10 Nov 05 SHL CollectorCnrWndProc: correct missing button window updates
[352]	24	14 Jul 06 SHL Use Runtime_Error
[403]	25	27 Jul 06 SHL Avoid shutdown hang - pre3 typo
	26	29 Jul 06 SHL Use xfgets_bstripcr
[96]	27
	28	***********************************************************************/
	29
[2]	30	#define INCL_DOS
	31	#define INCL_WIN
	32	#define INCL_GPI
	33	#define INCL_DOSERRORS
[155]	34	#define INCL_LONGLONG
	35	#include <os2.h>
[2]	36
	37	#include <stdarg.h>
	38	#include <stdio.h>
	39	#include <stdlib.h>
	40	#include <string.h>
	41	#include <ctype.h>
	42	#include <time.h>
	43	#include <share.h>
	44	#include <limits.h>
[155]	45
[2]	46	#include "fm3dll.h"
	47	#include "fm3dlg.h"
	48	#include "fm3str.h"
	49	#include "mle.h"
	50	#include "grep.h"
	51
	52	#pragma data_seg(DATA1)
[352]	53
	54	static PSZ pszSrcFile = __FILE__;
	55
[2]	56	#pragma alloc_text(COLLECTOR,CollectorCnrWndProc,CollectorObjWndProc)
	57	#pragma alloc_text(COLLECTOR,CollectorClientWndProc,CollectorTextProc)
	58	#pragma alloc_text(COLLECTOR,CollectorFrameWndProc)
	59	#pragma alloc_text(STARTUP,StartCollector)
	60
[194]	61	MRESULT EXPENTRY CollectorFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
	62	MPARAM mp2)
	63	{
	64	return CommonFrameWndProc(COLLECTOR_CNR, hwnd, msg, mp1, mp2);
[2]	65	}
	66
[194]	67	MRESULT EXPENTRY CollectorTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[96]	68	{
[197]	69	DIRCNRDATA *dcd;
[155]	70
[194]	71	static BOOL emphasized = FALSE;
[403]	72	static HWND hwndButtonPopup = (HWND)0;
[194]	73	static ULONG timestamp = ULONG_MAX;
	74	static USHORT lastid = 0;
[2]	75
[194]	76	switch (msg)
	77	{
	78	case WM_CREATE:
	79	return CommonTextProc(hwnd, msg, mp1, mp2);
[2]	80
[194]	81	case UM_CONTEXTMENU:
	82	case WM_CONTEXTMENU:
	83	{
	84	USHORT id;
	85
	86	id = WinQueryWindowUShort(hwnd, QWS_ID);
	87	switch (id)
[2]	88	{
[194]	89	case DIR_SELECTED:
	90	case DIR_VIEW:
	91	case DIR_SORT:
	92	{
	93	POINTL ptl = {0, 0};
	94	SWP swp;
[2]	95
[194]	96	if (hwndButtonPopup)
	97	WinDestroyWindow(hwndButtonPopup);
	98	if (id == lastid)
	99	{
	100	ULONG check;
[2]	101
[194]	102	DosQuerySysInfo(QSV_MS_COUNT,
	103	QSV_MS_COUNT,
	104	&check,
	105	sizeof(check));
	106	if (check < timestamp + 500)
	107	{
	108	lastid = 0;
	109	goto MenuAbort;
	110	}
	111	}
	112	hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,
	113	FM3ModHandle,
	114	id);
	115	if (hwndButtonPopup)
	116	{
	117	WinSetWindowUShort(hwndButtonPopup,
	118	QWS_ID,
	119	id);
	120	dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
[352]	121	QW_PARENT),
[194]	122	COLLECTOR_CNR),
	123	QWL_USER);
	124	if (id == DIR_VIEW)
	125	{
	126	if (dcd)
	127	{
	128	SetViewMenu(hwndButtonPopup,
	129	dcd -> flWindowAttr);
	130	SetDetailsSwitches(hwndButtonPopup,
	131	dcd);
	132	}
[2]	133
[194]	134	/* don't have tree view in collector */
	135	WinSendMsg(hwndButtonPopup,
	136	MM_DELETEITEM,
	137	MPFROM2SHORT(IDM_TREEVIEW,
	138	FALSE),
	139	MPVOID);
[2]	140
[194]	141	}
	142	else if (id == DIR_SORT)
	143	{
	144	if (dcd)
	145	SetSortChecks(hwndButtonPopup,
	146	dcd -> sortFlags);
	147	}
	148	ptl.x = 0;
	149	if (WinPopupMenu(HWND_OBJECT,
	150	HWND_OBJECT,
	151	hwndButtonPopup,
	152	-32767,
	153	-32767,
	154	0,
	155	0))
	156	{
	157	WinQueryWindowPos(hwndButtonPopup,
	158	&swp);
	159	ptl.y = -(swp.cy + 2);
	160	}
	161	else
	162	{
	163	WinQueryWindowPos(hwnd,
	164	&swp);
	165	ptl.y = swp.cy + 2;
	166	}
	167	if (WinPopupMenu(hwnd,
	168	hwnd,
	169	hwndButtonPopup,
	170	ptl.x,
	171	ptl.y,
	172	0,
	173	PU_HCONSTRAIN \| PU_VCONSTRAIN \|
	174	PU_KEYBOARD \| PU_MOUSEBUTTON1))
	175	{
	176	CenterOverWindow(hwndButtonPopup);
	177	PaintRecessedWindow(hwnd,
[280]	178	NULLHANDLE,
[194]	179	FALSE,
	180	FALSE);
	181	}
	182	}
	183	}
	184	break;
	185	default:
	186	PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	187	COLLECTOR_CNR),
	188	WM_CONTROL,
	189	MPFROM2SHORT(COLLECTOR_CNR,
	190	CN_CONTEXTMENU),
	191	MPVOID);
	192	break;
[2]	193	}
[194]	194	}
	195	MenuAbort:
	196	if (msg == UM_CONTEXTMENU)
	197	return 0;
	198	break;
[2]	199
[194]	200	case WM_MENUEND:
[403]	201	if (hwndButtonPopup == (HWND)mp2)
[194]	202	{
[403]	203	lastid = WinQueryWindowUShort((HWND)mp2, QWS_ID);
[194]	204	WinDestroyWindow(hwndButtonPopup);
[403]	205	hwndButtonPopup = (HWND)0;
[194]	206	DosQuerySysInfo(QSV_MS_COUNT,
	207	QSV_MS_COUNT,
	208	&timestamp,
	209	sizeof(timestamp));
	210	switch (lastid)
	211	{
	212	case DIR_SELECTED:
	213	case DIR_VIEW:
	214	case DIR_SORT:
	215	PaintRecessedWindow(hwnd,
[280]	216	NULLHANDLE,
[194]	217	TRUE,
	218	FALSE);
	219	break;
[2]	220	}
[194]	221	}
	222	break;
[2]	223
[194]	224	case WM_COMMAND:
	225	{
	226	DIRCNRDATA *dcd;
	227	MRESULT mr;
	228
	229	mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
	230	QW_PARENT),
	231	COLLECTOR_CNR),
	232	msg,
	233	mp1,
	234	mp2);
	235	if (hwndButtonPopup &&
	236	SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
	237	SHORT1FROMMP(mp1) < IDM_DETAILSSETUP)
[2]	238	{
[194]	239	dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
	240	QW_PARENT),
	241	COLLECTOR_CNR),
	242	QWL_USER);
	243	if (dcd)
	244	SetDetailsSwitches(hwndButtonPopup,
	245	dcd);
[2]	246	}
[194]	247	return mr;
	248	}
[2]	249
[194]	250	case WM_MOUSEMOVE:
	251	{
	252	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
	253	char *s = NULL;
	254
	255	if (fOtherHelp)
[2]	256	{
[194]	257	if ((!hwndBubble \|\|
	258	WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
	259	!WinQueryCapture(HWND_DESKTOP))
	260	{
	261	switch (id)
	262	{
	263	case DIR_SELECTED:
	264	s = GetPString(IDS_COLSELECTEDHELP);
	265	break;
	266	case DIR_TOTALS:
	267	s = GetPString(IDS_COLTOTALSHELP);
	268	break;
	269	case DIR_VIEW:
	270	s = GetPString(IDS_DIRCNRVIEWHELP);
	271	break;
	272	case DIR_SORT:
	273	s = GetPString(IDS_DIRCNRSORTHELP);
	274	break;
	275	case DIR_FILTER:
	276	s = GetPString(IDS_DIRCNRFILTERHELP);
	277	break;
	278	default:
	279	break;
	280	}
	281	if (s)
	282	MakeBubble(hwnd, TRUE, s);
	283	else if (hwndBubble)
	284	WinDestroyWindow(hwndBubble);
	285	}
[2]	286	}
[194]	287	switch (id)
	288	{
	289	case DIR_FILTER:
	290	case DIR_SORT:
	291	case DIR_VIEW:
	292	case DIR_SELECTED:
	293	return CommonTextButton(hwnd, msg, mp1, mp2);
	294	}
	295	}
	296	break;
[2]	297
[194]	298	case WM_BUTTON3UP:
	299	case WM_BUTTON1UP:
	300	case WM_BUTTON3DOWN:
	301	case WM_BUTTON1DOWN:
	302	{
	303	USHORT id;
	304
[280]	305	id = WinQueryWindowUShort(hwnd, QWS_ID);
[194]	306	switch (id)
[2]	307	{
[194]	308	case DIR_FILTER:
	309	case DIR_SORT:
	310	case DIR_VIEW:
	311	case DIR_SELECTED:
	312	return CommonTextButton(hwnd, msg, mp1, mp2);
[2]	313	}
[194]	314	}
	315	break;
[2]	316
[194]	317	case UM_CLICKED:
	318	case UM_CLICKED3:
	319	{
	320	USHORT id, cmd = 0;
	321
[280]	322	id = WinQueryWindowUShort(hwnd, QWS_ID);
[194]	323	switch (id)
[2]	324	{
[194]	325	case DIR_VIEW:
	326	case DIR_SORT:
	327	case DIR_SELECTED:
	328	PostMsg(hwnd,
	329	UM_CONTEXTMENU,
	330	MPVOID,
	331	MPVOID);
	332	break;
	333	case DIR_FILTER:
	334	cmd = IDM_FILTER;
	335	break;
	336	default:
	337	break;
[2]	338	}
[194]	339	if (cmd)
	340	PostMsg(WinWindowFromID(WinQueryWindow(hwnd,
	341	QW_PARENT),
	342	COLLECTOR_CNR),
	343	WM_COMMAND,
	344	MPFROM2SHORT(cmd, 0),
	345	MPVOID);
	346	}
	347	return 0;
[2]	348
[194]	349	case DM_DROP:
	350	case DM_DRAGOVER:
	351	case DM_DRAGLEAVE:
	352	case DM_DROPHELP:
	353	if (msg == DM_DRAGOVER)
	354	{
	355	if (!emphasized)
	356	{
	357	emphasized = TRUE;
	358	DrawTargetEmphasis(hwnd, emphasized);
[2]	359	}
[194]	360	}
	361	else
	362	{
	363	if (emphasized)
	364	{
	365	emphasized = FALSE;
	366	DrawTargetEmphasis(hwnd, emphasized);
[2]	367	}
[194]	368	}
	369	{
	370	CNRDRAGINFO cnd;
	371	USHORT dcmd;
	372
	373	switch (msg)
[2]	374	{
[194]	375	case DM_DROP:
	376	dcmd = CN_DROP;
	377	break;
	378	case DM_DRAGOVER:
	379	dcmd = CN_DRAGOVER;
	380	break;
	381	case DM_DRAGLEAVE:
	382	dcmd = CN_DRAGLEAVE;
	383	break;
	384	case DM_DROPHELP:
	385	dcmd = CN_DROPHELP;
	386	break;
[2]	387	}
[194]	388	memset(&cnd, 0, sizeof(cnd));
	389	cnd.pDragInfo = (PDRAGINFO) mp1;
	390	cnd.pRecord = NULL;
	391	return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_CONTROL,
	392	MPFROM2SHORT(COLLECTOR_CNR, dcmd), MPFROMP(&cnd));
	393	}
[2]	394	}
[194]	395	return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]	396	}
	397
[194]	398	MRESULT EXPENTRY CollectorClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
	399	MPARAM mp2)
	400	{
	401	switch (msg)
	402	{
	403	case UM_CONTAINERHWND:
	404	return MRFROMLONG(WinWindowFromID(hwnd, COLLECTOR_CNR));
[2]	405
[194]	406	case UM_VIEWSMENU:
	407	return MRFROMLONG(CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP));
[2]	408
[194]	409	case MM_PORTHOLEINIT:
	410	case WM_INITMENU:
	411	case UM_INITMENU:
	412	case UM_CONTAINER_FILLED:
	413	case UM_FILESMENU:
	414	case UM_UPDATERECORD:
	415	case UM_UPDATERECORDLIST:
	416	return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
[2]	417
[194]	418	case WM_PSETFOCUS:
	419	case WM_SETFOCUS:
	420	if (mp2)
	421	PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
	422	break;
[2]	423
[194]	424	case UM_FOCUSME:
	425	WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, COLLECTOR_CNR));
	426	break;
[2]	427
[194]	428	case WM_PAINT:
	429	{
	430	HPS hps;
	431	RECTL rcl;
[2]	432
[280]	433	hps = WinBeginPaint(hwnd, NULLHANDLE, NULL);
[194]	434	if (hps)
[2]	435	{
[194]	436	WinQueryWindowRect(hwnd, &rcl);
	437	WinFillRect(hps, &rcl, CLR_PALEGRAY);
	438	CommonTextPaint(hwnd, hps);
	439	WinEndPaint(hps);
[2]	440	}
[194]	441	}
	442	break;
[2]	443
[194]	444	case UM_SIZE:
	445	case WM_SIZE:
	446	if (msg == UM_SIZE)
	447	{
	448	SWP swp;
[2]	449
[194]	450	WinQueryWindowPos(hwnd, &swp);
	451	mp1 = MPFROM2SHORT(swp.cx, swp.cy);
	452	mp2 = MPFROM2SHORT(swp.cx, swp.cy);
	453	}
	454	{
	455	USHORT cx, cy, bx;
[2]	456
[194]	457	cx = SHORT1FROMMP(mp2);
	458	cy = SHORT2FROMMP(mp2);
	459	WinSetWindowPos(WinWindowFromID(hwnd, COLLECTOR_CNR), HWND_TOP,
	460	0,
	461	0,
	462	cx,
	463	cy - 24,
	464	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	465	WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
	466	2,
	467	cy - 22,
	468	(cx / 3) - 2,
	469	20,
	470	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	471	WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
	472	2 + (cx / 3) + 2,
	473	cy - 22,
	474	(cx / 3) - 2,
	475	20,
	476	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	477	bx = (cx - (2 + (((cx / 3) + 2) * 2))) / 3;
	478	WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
	479	2 + (((cx / 3) + 2) * 2),
	480	cy - 22,
	481	bx - 4,
	482	20,
	483	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	484	WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
	485	2 + (((cx / 3) + 2) * 2) + bx,
	486	cy - 22,
	487	bx - 4,
	488	20,
	489	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	490	WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
	491	2 + (((cx / 3) + 2) * 2) + (bx * 2),
	492	cy - 22,
	493	bx - 4,
	494	20,
	495	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	496	}
[280]	497	CommonTextPaint(hwnd, NULLHANDLE);
[194]	498	if (msg == UM_SIZE)
	499	{
	500	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
	501	SWP_SHOW \| SWP_ZORDER \| SWP_ACTIVATE);
	502	return 0;
	503	}
	504	break;
[2]	505
[194]	506	case UM_COMMAND:
	507	case WM_COMMAND:
	508	case WM_CONTROL:
	509	case WM_CLOSE:
	510	return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
[2]	511	}
[194]	512	return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]	513	}
	514
[194]	515	MRESULT EXPENTRY CollectorObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
	516	MPARAM mp2)
	517	{
[197]	518	ULONG size;
[2]	519	DIRCNRDATA *dcd;
	520
[194]	521	switch (msg)
	522	{
	523	case WM_CREATE:
	524	break;
[2]	525
[194]	526	case DM_PRINTOBJECT:
	527	return MRFROMLONG(DRR_TARGET);
[2]	528
[194]	529	case DM_DISCARDOBJECT:
	530	dcd = INSTDATA(hwnd);
	531	if (fFM2Deletes && dcd)
	532	{
	533	LISTINFO *li;
	534	CNRDRAGINFO cni;
[2]	535
[194]	536	cni.pRecord = NULL;
	537	cni.pDragInfo = (PDRAGINFO) mp1;
	538	li = DoFileDrop(dcd -> hwndCnr, NULL, FALSE, MPVOID, MPFROMP(&cni));
	539	if (li)
	540	{
	541	li -> type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
	542	if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
	543	FreeListInfo(li);
	544	else
	545	return MRFROMLONG(DRR_SOURCE);
[2]	546	}
[194]	547	}
	548	return MRFROMLONG(DRR_TARGET);
[2]	549
[194]	550	case UM_UPDATERECORDLIST:
	551	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	552	if (dcd && mp1)
	553	{
	554	INT numentries = 0;
	555	CHAR list = (CHAR ) mp1;
[2]	556
[194]	557	while (list[numentries])
	558	numentries++;
	559	if (numentries)
	560	UpdateCnrList(dcd -> hwndCnr, list, numentries, FALSE, dcd);
	561	}
	562	return 0;
[2]	563
[194]	564	case UM_SETUP:
	565	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	566	if (dcd)
	567	{
	568	/* set unique id */
	569	WinSetWindowUShort(hwnd,
	570	QWS_ID,
	571	COLLECTOROBJ_FRAME + (COLLECTOR_FRAME - dcd -> id));
	572	dcd -> hwndObject = hwnd;
	573	if (ParentIsDesktop(hwnd, dcd -> hwndParent))
	574	DosSleep(250L);
	575	}
	576	else
	577	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
	578	return 0;
[2]	579
[194]	580	case UM_COMMAND:
	581	if (mp1)
	582	{
	583	LISTINFO li = (LISTINFO ) mp1;
	584
	585	switch (li -> type)
	586	{
	587	case IDM_DOITYOURSELF:
	588	case IDM_APPENDTOCLIP:
	589	case IDM_SAVETOCLIP:
	590	case IDM_ARCHIVE:
	591	case IDM_ARCHIVEM:
	592	case IDM_VIEW:
	593	case IDM_VIEWTEXT:
	594	case IDM_VIEWBINARY:
	595	case IDM_VIEWARCHIVE:
	596	case IDM_EDIT:
	597	case IDM_EDITTEXT:
	598	case IDM_EDITBINARY:
	599	case IDM_OBJECT:
	600	case IDM_SHADOW:
	601	case IDM_SHADOW2:
	602	case IDM_PRINT:
	603	case IDM_ATTRS:
	604	case IDM_DELETE:
	605	case IDM_PERMDELETE:
	606	case IDM_FAKEEXTRACT:
	607	case IDM_FAKEEXTRACTM:
	608	case IDM_MCIPLAY:
	609	case IDM_UPDATE:
	610	if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
	611	return (MRESULT) TRUE;
	612	break;
	613	default:
	614	if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
	615	return (MRESULT) TRUE;
[2]	616	}
[194]	617	}
	618	return 0;
[2]	619
[194]	620	case UM_COLLECT:
	621	DosError(FERR_DISABLEHARDERR);
	622	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	623	if (dcd)
	624	{
	625	LISTINFO li = (LISTINFO ) mp1;
	626	INT x;
	627	FILEFINDBUF4 fb4;
	628	HDIR hdir;
	629	ULONG nm;
	630	PCNRITEM pci, pciFirst, pciT, pciP = NULL;
	631	RECORDINSERT ri;
	632	ULONG ulMaxFiles;
	633	ULONGLONG ullTotalBytes;
	634	CHAR fullname[CCHMAXPATH];
[2]	635
[194]	636	WinSetWindowText(WinWindowFromID(dcd -> hwndClient,
	637	DIR_SELECTED),
	638	GetPString(IDS_COLLECTINGTEXT));
[352]	639	for (ulMaxFiles = 0; li -> list[ulMaxFiles]; ulMaxFiles++)
	640	; // Count
	641
	642	if (ulMaxFiles) {
[194]	643	pci = WinSendMsg(dcd -> hwndCnr, CM_ALLOCRECORD,
	644	MPFROMLONG(EXTRA_RECORD_BYTES),
	645	MPFROMLONG(ulMaxFiles));
[403]	646	if (!pci) {
[352]	647	Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD %u failed", ulMaxFiles);
	648	break;
	649	}
	650	else {
[194]	651	pciFirst = pci;
	652	for (x = 0; li -> list[x]; x++)
	653	{
	654	nm = 1L;
	655	hdir = HDIR_CREATE;
	656	DosError(FERR_DISABLEHARDERR);
	657	if (*li -> list[x] &&
	658	!DosQueryPathInfo(li -> list[x], FIL_QUERYFULLNAME,
	659	fullname, sizeof(fullname)) &&
	660	!IsRoot(fullname) &&
	661	!FindCnrRecord(dcd -> hwndCnr,
	662	fullname,
	663	NULL,
	664	FALSE,
	665	FALSE,
	666	TRUE) &&
	667	!DosFindFirst(fullname,
	668	&hdir,
	669	FILE_NORMAL \| FILE_DIRECTORY \|
	670	FILE_ARCHIVED \| FILE_SYSTEM \|
	671	FILE_HIDDEN \| FILE_READONLY,
	672	&fb4,
	673	sizeof(fb4),
	674	&nm,
	675	FIL_QUERYEASIZE))
	676	{
	677	DosFindClose(hdir);
	678	priority_normal();
	679	*fb4.achName = 0;
	680	ullTotalBytes = FillInRecordFromFFB(dcd -> hwndCnr,
	681	pci,
	682	fullname,
	683	&fb4,
	684	FALSE,
	685	dcd);
	686	dcd -> ullTotalBytes += ullTotalBytes;
	687	pciP = pci;
	688	pci = (PCNRITEM) pci -> rc.preccNextRecord;
	689	}
	690	else
	691	{
	692	pciT = pci;
	693	pci = (PCNRITEM) pci -> rc.preccNextRecord;
	694	if (pciP)
	695	pciP -> rc.preccNextRecord = (PMINIRECORDCORE) pci;
	696	else
	697	pciFirst = pci;
	698	WinSendMsg(hwnd, CM_FREERECORD, MPFROMP(&pciT),
	699	MPFROM2SHORT(1, 0));
	700	ulMaxFiles--;
	701	}
	702	DosSleep(1L);
	703	}
	704	if (ulMaxFiles)
	705	{
	706	memset(&ri, 0, sizeof(RECORDINSERT));
	707	ri.cb = sizeof(RECORDINSERT);
	708	ri.pRecordOrder = (PRECORDCORE) CMA_END;
	709	ri.pRecordParent = (PRECORDCORE) 0;
	710	ri.zOrder = (ULONG) CMA_TOP;
	711	ri.cRecordsInsert = ulMaxFiles;
	712	ri.fInvalidateRecord = TRUE;
	713	WinSendMsg(dcd -> hwndCnr,
	714	CM_INSERTRECORD,
	715	MPFROMP(pciFirst),
	716	MPFROMP(&ri));
	717	PostMsg(dcd -> hwndCnr,
	718	UM_RESCAN,
	719	MPVOID,
	720	MPVOID);
	721	}
	722	}
[2]	723	}
[194]	724	}
	725	if (dcd -> flWindowAttr & CV_DETAIL)
	726	WinSendDlgItemMsg(hwnd,
	727	COLLECTOR_CNR,
	728	CM_INVALIDATERECORD,
	729	MPVOID,
	730	MPFROM2SHORT(0,
	731	CMA_ERASE \| CMA_REPOSITION));
	732	return 0;
[2]	733
[194]	734	case UM_COLLECTFROMFILE:
	735	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[403]	736	if (dcd && mp1) {
[194]	737	FILESTATUS4 fs4;
	738	PCNRITEM pci;
	739	RECORDINSERT ri;
	740	CHAR fullname[1024], *p;
	741	FILE *fp;
	742	ULONG errs = 0L;
[2]	743
[194]	744	fp = _fsopen((CHAR *) mp1, "r", SH_DENYNO);
[403]	745	if (fp) {
	746	while (!feof(fp)) {
	747	if (!xfgets_bstripcr(fullname, sizeof(fullname), fp,pszSrcFile, __LINE__))
[194]	748	break;
[403]	749	if (*fullname == '\"') {
[194]	750	memmove(fullname, fullname + 1, strlen(fullname) + 1);
	751	lstrip(fullname);
	752	p = strchr(fullname, '\"');
	753	if (p)
	754	*p = 0;
	755	rstrip(fullname);
	756	}
[403]	757	else {
[194]	758	p = strchr(fullname, ' ');
	759	if (p)
	760	*p = 0;
	761	}
	762	/* fullname now contains name of file to collect */
	763	DosError(FERR_DISABLEHARDERR);
	764	if (IsFullName(fullname) &&
	765	!IsRoot(fullname) &&
	766	!DosQueryPathInfo(fullname,
	767	FIL_QUERYEASIZE,
	768	&fs4,
	769	sizeof(fs4)) &&
	770	!FindCnrRecord(dcd -> hwndCnr,
	771	fullname,
	772	NULL,
	773	FALSE,
	774	FALSE,
	775	TRUE))
	776	{
	777	/* collect it */
	778	pci = WinSendMsg(dcd -> hwndCnr,
	779	CM_ALLOCRECORD,
	780	MPFROMLONG(EXTRA_RECORD_BYTES),
	781	MPFROMLONG(1L));
	782	if (pci)
	783	{
	784	dcd -> ullTotalBytes += FillInRecordFromFSA(dcd -> hwndCnr, pci,
	785	fullname,
	786	&fs4, FALSE, dcd);
	787	memset(&ri, 0, sizeof(RECORDINSERT));
	788	ri.cb = sizeof(RECORDINSERT);
	789	ri.pRecordOrder = (PRECORDCORE) CMA_END;
	790	ri.pRecordParent = (PRECORDCORE) 0;
	791	ri.zOrder = (ULONG) CMA_TOP;
	792	ri.cRecordsInsert = 1L;
	793	ri.fInvalidateRecord = TRUE;
	794	WinSendMsg(dcd -> hwndCnr, CM_INSERTRECORD,
	795	MPFROMP(pci), MPFROMP(&ri));
	796	}
	797	}
	798	else
	799	{
	800	errs++;
	801	if (errs > 50L)
	802	{ /* prevent runaway on bad file */
[2]	803
[194]	804	APIRET ret;
[2]	805
[194]	806	ret = saymsg(MB_YESNO, dcd -> hwndCnr,
	807	GetPString(IDS_COLLECTNOLISTHDRTEXT),
	808	GetPString(IDS_COLLECTNOLISTTEXT),
	809	(CHAR *) mp1);
	810	if (ret == MBID_NO)
	811	break;
	812	errs = 0L;
	813	}
	814	}
	815	}
	816	fclose(fp);
[2]	817	}
[194]	818	}
[403]	819	xfree(mp1);
[194]	820	return 0;
[2]	821
[194]	822	case UM_SELECT:
	823	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	824	if (dcd)
	825	{
	826	switch (SHORT1FROMMP(mp1))
	827	{
	828	case IDM_SELECTLIST:
	829	{
	830	CHAR filename[CCHMAXPATH], p, pp;
[2]	831
[194]	832	strcpy(filename, "*.LST");
	833	size = CCHMAXPATH;
	834	PrfQueryProfileData(fmprof,
	835	appname,
	836	"SaveToListName",
	837	filename,
	838	&size);
	839	pp = strrchr(filename, '\\');
	840	if (!pp)
	841	pp = filename;
	842	p = strrchr(pp, '.');
	843	if (p && *(p + 1) && p > pp + 1)
	844	{
	845	if (pp > filename)
	846	pp++;
	847	pp = '';
	848	pp++;
	849	if (p > pp)
	850	memmove(pp, p, strlen(p) + 1);
	851	}
	852	if (insert_filename(hwnd, filename, FALSE, FALSE))
	853	SelectList(dcd -> hwndCnr, TRUE, FALSE, FALSE, NULL, filename, NULL);
	854	}
	855	break;
	856	case IDM_SELECTALL:
	857	SelectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
	858	break;
	859	case IDM_DESELECTALL:
	860	DeselectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
	861	break;
	862	case IDM_SELECTALLFILES:
	863	SelectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
	864	break;
	865	case IDM_DESELECTALLFILES:
	866	DeselectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
	867	break;
	868	case IDM_SELECTALLDIRS:
	869	SelectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
	870	break;
	871	case IDM_DESELECTALLDIRS:
	872	DeselectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
	873	break;
	874	case IDM_DESELECTMASK:
	875	case IDM_SELECTMASK:
	876	{
	877	MASK mask;
	878	PCNRITEM pci = (PCNRITEM) mp2;
[2]	879
[194]	880	memset(&mask, 0, sizeof(MASK));
	881	mask.fNoAttribs = TRUE;
	882	mask.fNoDirs = TRUE;
	883	mask.fText = TRUE;
	884	strcpy(mask.prompt,
	885	GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
	886	IDS_SELECTFILTERTEXT :
	887	IDS_DESELECTFILTERTEXT));
	888	if (pci && (INT) pci != -1)
	889	strcpy(mask.szMask, pci -> szFileName);
	890	if (WinDlgBox(HWND_DESKTOP, dcd -> hwndCnr, PickMaskDlgProc,
	891	FM3ModHandle, MSK_FRAME, MPFROMP(&mask)))
	892	{
	893	if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
	894	SelectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
	895	FALSE);
	896	else
	897	DeselectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
	898	FALSE);
	899	}
	900	}
[2]	901
[194]	902	case IDM_DESELECTCLIP:
	903	case IDM_SELECTCLIP:
	904	{
	905	CHAR **list;
[2]	906
[194]	907	list = ListFromClipboard(hwnd);
	908	if (list)
	909	{
	910	SelectList(dcd -> hwndCnr, TRUE, FALSE,
	911	(SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
	912	NULL, NULL, list);
	913	FreeList(list);
	914	}
	915	}
	916	break;
[2]	917
[194]	918	case IDM_INVERT:
	919	InvertAll(dcd -> hwndCnr);
	920	break;
[2]	921	}
[194]	922	}
	923	return 0;
[2]	924
[194]	925	case UM_MASSACTION:
	926	if (mp1)
	927	{
	928	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	929	if (dcd)
	930	{
	931	WORKER *wk;
[2]	932
[352]	933	wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
	934	if (!wk) {
	935	FreeListInfo((LISTINFO *) mp1);
	936	}
	937	else {
[194]	938	wk -> size = sizeof(WORKER);
	939	wk -> hwndCnr = dcd -> hwndCnr;
	940	wk -> hwndParent = dcd -> hwndParent;
	941	wk -> hwndFrame = dcd -> hwndFrame;
	942	wk -> hwndClient = dcd -> hwndClient;
	943	wk -> li = (LISTINFO *) mp1;
	944	strcpy(wk -> directory, dcd -> directory);
	945	if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1)
	946	{
[352]	947	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
[194]	948	free(wk);
	949	FreeListInfo((LISTINFO *) mp1);
	950	}
	951	}
[2]	952	}
[194]	953	}
	954	return 0;
[2]	955
[194]	956	case UM_ACTION:
	957	if (mp1)
	958	{
	959	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	960	if (dcd)
	961	{
	962	WORKER *wk;
[2]	963
[352]	964	wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
	965	if (!wk)
	966	FreeListInfo((LISTINFO *) mp1);
	967	else {
[194]	968	wk -> size = sizeof(WORKER);
	969	wk -> hwndCnr = dcd -> hwndCnr;
	970	wk -> hwndParent = dcd -> hwndParent;
	971	wk -> hwndFrame = dcd -> hwndFrame;
	972	wk -> hwndClient = dcd -> hwndClient;
	973	wk -> li = (LISTINFO *) mp1;
	974	strcpy(wk -> directory, dcd -> directory);
	975	if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1)
	976	{
[352]	977	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
[194]	978	free(wk);
	979	FreeListInfo((LISTINFO *) mp1);
	980	}
	981	}
[2]	982	}
[194]	983	}
	984	return 0;
[2]	985
[194]	986	case WM_CLOSE:
	987	WinDestroyWindow(hwnd);
	988	break;
[2]	989
[194]	990	case WM_DESTROY:
	991	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
	992	if (dcd)
	993	{
	994	INT x = 0;
[2]	995
[194]	996	dcd -> stopflag = 1;
[280]	997	// Allow rescan logic to quiesce
[194]	998	while (x++ < 10 && dcd -> amextracted)
	999	DosSleep(250L);
	1000	WinSendMsg(dcd -> hwndCnr, UM_CLOSE, MPVOID, MPVOID);
	1001	FreeList(dcd -> lastselection);
	1002	free(dcd);
	1003	}
	1004	DosPostEventSem(CompactSem);
[403]	1005	if (!PostMsg((HWND)0, WM_QUIT, MPVOID, MPVOID))
	1006	WinSendMsg((HWND)0, WM_QUIT, MPVOID, MPVOID);
[194]	1007	break;
[2]	1008	}
[194]	1009	return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]	1010	}
	1011
[194]	1012	MRESULT EXPENTRY CollectorCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[155]	1013	{
[194]	1014	DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[197]	1015	ULONG size;
[2]	1016
[197]	1017	static INT savedSortFlags;
	1018
[194]	1019	switch (msg)
	1020	{
	1021	case DM_PRINTOBJECT:
	1022	return MRFROMLONG(DRR_TARGET);
	1023
	1024	case DM_DISCARDOBJECT:
	1025	if (dcd)
	1026	return WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
	1027	else
[2]	1028	return MRFROMLONG(DRR_TARGET);
	1029
[194]	1030	case WM_CHAR:
	1031	shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
	1032	if (SHORT1FROMMP(mp1) & KC_KEYUP)
	1033	return (MRESULT) TRUE;
	1034	if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
	1035	{
	1036	switch (SHORT2FROMMP(mp2))
	1037	{
	1038	case VK_DELETE:
	1039	if ((shiftstate & KC_CTRL) == KC_CTRL)
	1040	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
	1041	else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
	1042	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
	1043	else
	1044	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
	1045	break;
[2]	1046	}
[194]	1047	}
	1048	if (shiftstate \|\| fNoSearch)
	1049	break;
	1050	if (SHORT1FROMMP(mp1) & KC_CHAR)
	1051	{
	1052	ULONG thistime, len;
	1053	SEARCHSTRING srch;
	1054	PCNRITEM pci;
[2]	1055
[194]	1056	if (!dcd)
	1057	break;
	1058	switch (SHORT1FROMMP(mp2))
	1059	{
	1060	case '\x1b':
	1061	case '\r':
	1062	case '\n':
	1063	dcd -> lasttime = 0;
	1064	*dcd -> szCommonName = 0;
	1065	break;
	1066	default:
	1067	thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
	1068	if (thistime > dcd -> lasttime + 1250)
	1069	*dcd -> szCommonName = 0;
	1070	dcd -> lasttime = thistime;
	1071	if (SHORT1FROMMP(mp2) == ' ' && !dcd -> szCommonName)
	1072	break;
	1073	KbdRetry:
	1074	len = strlen(dcd -> szCommonName);
	1075	if (len >= CCHMAXPATH - 1)
	1076	{
	1077	*dcd -> szCommonName = 0;
	1078	len = 0;
	1079	}
	1080	dcd -> szCommonName[len] = toupper(SHORT1FROMMP(mp2));
	1081	dcd -> szCommonName[len + 1] = 0;
	1082	memset(&srch, 0, sizeof(SEARCHSTRING));
[197]	1083	srch.cb = sizeof(SEARCHSTRING);
	1084	srch.pszSearch = dcd -> szCommonName;
[194]	1085	srch.fsPrefix = TRUE;
	1086	srch.fsCaseSensitive = FALSE;
	1087	srch.usView = CV_ICON;
	1088	pci = WinSendMsg(hwnd, CM_SEARCHSTRING, MPFROMP(&srch),
	1089	MPFROMLONG(CMA_FIRST));
	1090	if (pci && (INT) pci != -1)
	1091	{
	1092	USHORT attrib = CRA_CURSORED;
[2]	1093
[194]	1094	/* make found item current item */
	1095	if (!stricmp(pci -> pszFileName, dcd -> szCommonName))
	1096	attrib \|= CRA_SELECTED;
	1097	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	1098	MPFROM2SHORT(TRUE, attrib));
	1099	/* make sure that record shows in viewport */
	1100	ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
	1101	return (MRESULT) TRUE;
	1102	}
	1103	else
	1104	{
	1105	if (SHORT1FROMMP(mp2) == ' ')
	1106	{
	1107	dcd -> szCommonName[len] = 0;
	1108	break;
	1109	}
	1110	*dcd -> szCommonName = 0;
	1111	dcd -> lasttime = 0;
	1112	if (len) // retry as first letter if no match
[2]	1113
[194]	1114	goto KbdRetry;
	1115	}
	1116	break;
[2]	1117	}
[194]	1118	}
	1119	break;
[2]	1120
[194]	1121	case WM_MOUSEMOVE:
	1122	case WM_BUTTON1UP:
	1123	case WM_BUTTON2UP:
	1124	case WM_BUTTON3UP:
	1125	case WM_CHORD:
	1126	shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
	1127	break;
[2]	1128
[194]	1129	case WM_BUTTON1MOTIONEND:
	1130	{
	1131	CNRINFO cnri;
	1132
	1133	memset(&cnri, 0, sizeof(CNRINFO));
	1134	cnri.cb = sizeof(CNRINFO);
	1135	if (WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
	1136	MPFROMLONG(sizeof(CNRINFO))))
[2]	1137	{
[194]	1138	if (cnri.flWindowAttr & CV_DETAIL)
	1139	PrfWriteProfileData(fmprof, appname, "CollectorCnrSplitBar",
	1140	(PVOID) & cnri.xVertSplitbar, sizeof(LONG));
[2]	1141	}
[194]	1142	}
	1143	break;
[2]	1144
[194]	1145	case WM_PRESPARAMCHANGED:
	1146	PresParamChanged(hwnd, "Collector", mp1, mp2);
	1147	break;
[2]	1148
[194]	1149	case UM_COMPARE:
	1150	if (dcd && mp1 && mp2)
	1151	{
	1152	COMPARE *cmp;
	1153	CHAR leftdir = (CHAR ) mp1, rightdir = (CHAR ) mp2;
[2]	1154
[194]	1155	if (!IsFile(leftdir) && !IsFile(rightdir))
	1156	{
[352]	1157	cmp = xmallocz(sizeof(COMPARE),pszSrcFile,__LINE__);
[194]	1158	if (cmp)
	1159	{
	1160	cmp -> size = sizeof(COMPARE);
	1161	strcpy(cmp -> leftdir, leftdir);
	1162	strcpy(cmp -> rightdir, rightdir);
	1163	cmp -> hwndParent = dcd -> hwndParent;
	1164	cmp -> dcd.hwndParent = dcd -> hwndParent;
	1165	WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, CompareDlgProc,
	1166	FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
	1167	}
[2]	1168	}
[194]	1169	}
	1170	return 0;
[2]	1171
[194]	1172	case UM_UPDATERECORDLIST:
	1173	if (dcd && mp1)
	1174	WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
	1175	return 0;
[2]	1176
[194]	1177	case UM_UPDATERECORD:
	1178	if (dcd && mp1)
	1179	{
	1180	CHAR *filename;
[2]	1181
[194]	1182	filename = mp1;
	1183	if (filename)
	1184	UpdateCnrRecord(hwnd, filename, TRUE, dcd);
	1185	}
	1186	return 0;
[2]	1187
[194]	1188	case WM_SETFOCUS:
	1189	/*
	1190	* put name of our window on status line
	1191	*/
	1192	if (dcd && hwndStatus && mp2)
	1193	{
	1194	PCNRITEM pci = NULL;
[2]	1195
[194]	1196	if (fAutoView && hwndMain)
	1197	{
	1198	pci = WinSendMsg(hwnd,
	1199	CM_QUERYRECORDEMPHASIS,
	1200	MPFROMLONG(CMA_FIRST),
	1201	MPFROMSHORT(CRA_CURSORED));
	1202	if (pci && (INT) pci != -1 &&
	1203	(!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
	1204	WinSendMsg(hwndMain,
	1205	UM_LOADFILE,
	1206	MPFROMP(pci -> szFileName),
	1207	MPVOID);
	1208	else
	1209	WinSendMsg(hwndMain,
	1210	UM_LOADFILE,
	1211	MPVOID,
	1212	MPVOID);
[2]	1213	}
[194]	1214	if (dcd -> amextracted)
	1215	WinSetWindowText(hwndStatus2,
[280]	1216	GetPString(IDS_INSEEKSCANTEXT)); // Say working
[194]	1217	WinSendMsg(hwnd,
	1218	UM_RESCAN,
	1219	MPVOID,
	1220	MPVOID);
	1221	}
	1222	break;
[2]	1223
[194]	1224	case UM_RESCAN:
	1225	if (dcd)
	1226	{
	1227	CNRINFO cnri;
	1228	CHAR s[CCHMAXPATH + 69], tb[81], tf[81], *p;
	1229	PCNRITEM pci = NULL;
[2]	1230
[194]	1231	memset(&cnri, 0, sizeof(CNRINFO));
	1232	cnri.cb = sizeof(CNRINFO);
	1233	WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
	1234	MPFROMLONG(sizeof(CNRINFO)));
	1235	dcd -> totalfiles = cnri.cRecords;
	1236	commafmt(tf, sizeof(tf), dcd -> totalfiles);
	1237	CommaFmtULL(tb, sizeof(tb), dcd -> ullTotalBytes, ' ');
	1238	sprintf(s, "%s / %s", tf, tb);
	1239	WinSetDlgItemText(dcd -> hwndClient, DIR_TOTALS, s);
[2]	1240
[194]	1241	commafmt(tf, sizeof(tf), dcd -> selectedfiles);
	1242	CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
	1243	sprintf(s, "%s / %s", tf, tb);
	1244	WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
[155]	1245
[194]	1246	if (hwndStatus &&
	1247	dcd -> hwndFrame == WinQueryActiveWindow(dcd -> hwndParent))
	1248	{
	1249	if (hwndMain)
	1250	{
	1251	pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
	1252	MPFROMLONG(CMA_FIRST),
	1253	MPFROMSHORT(CRA_CURSORED));
	1254	if (pci && (INT) pci != -1)
	1255	PostMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName), MPVOID);
	1256	else
	1257	PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
	1258	}
	1259	if (!fMoreButtons)
	1260	sprintf(s, " %s%s%s%s", GetPString(IDS_COLLECTORTEXT),
	1261	(*dcd -> mask.szMask \|\| dcd -> mask.antiattr \|\|
	1262	dcd -> mask.attrFile != ALLATTRS) ? " (" : NullStr,
	1263	(*dcd -> mask.szMask) ? dcd -> mask.szMask :
	1264	(dcd -> mask.antiattr \|\|
	1265	dcd -> mask.attrFile != ALLATTRS) ?
	1266	GetPString(IDS_ATTRTEXT) : NullStr,
	1267	(*dcd -> mask.szMask \|\| dcd -> mask.antiattr \|\|
	1268	dcd -> mask.attrFile != ALLATTRS) ? ")" : NullStr);
	1269	else
	1270	strcpy(s, GetPString(IDS_COLLECTORTEXT));
	1271	WinSetWindowText(hwndStatus, s);
	1272	if (!pci)
	1273	pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
	1274	MPFROMLONG(CMA_FIRST),
	1275	MPFROMSHORT(CRA_CURSORED));
	1276	if (pci && (INT) pci != -1)
	1277	{
[280]	1278	BOOL fStatus2Used = FALSE;
[194]	1279	if (fSplitStatus && hwndStatus2)
	1280	{
	1281	if (pci -> attrFile & FILE_DIRECTORY)
	1282	p = pci -> pszFileName;
	1283	else
	1284	{
	1285	p = strrchr(pci -> szFileName, '\\');
	1286	if (p)
[155]	1287	{
[194]	1288	if (*(p + 1))
	1289	p++;
	1290	else
	1291	p = pci -> pszFileName;
[155]	1292	}
[194]	1293	else
	1294	p = pci -> pszFileName;
	1295	}
	1296	CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
	1297	if (!fMoreButtons)
	1298	{
	1299	sprintf(s, " %s %04u/%02u/%02u %02u:%02u:%02u [%s] %s",
	1300	tb, pci -> date.year, pci -> date.month,
	1301	pci -> date.day, pci -> time.hours, pci -> time.minutes,
	1302	pci -> time.seconds, pci -> pszDispAttr, p);
	1303	}
	1304	else
	1305	{
	1306	if (pci -> cbFile + pci -> easize > 1024)
	1307	CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, 'K');
	1308	else
	1309	*tf = 0;
	1310	sprintf(s, GetPString(IDS_STATUSSIZETEXT),
	1311	tb,
	1312	*tf ? " (" : NullStr,
	1313	tf,
	1314	*tf ? ")" : NullStr);
	1315	}
	1316	WinSetWindowText(hwndStatus2, s);
[280]	1317	fStatus2Used = TRUE;
[194]	1318	}
	1319	if (fMoreButtons)
	1320	{
	1321	WinSetWindowText(hwndName, pci -> pszFileName);
	1322	sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
	1323	pci -> date.year, pci -> date.month,
	1324	pci -> date.day, pci -> time.hours, pci -> time.minutes,
	1325	pci -> time.seconds);
	1326	WinSetWindowText(hwndDate, s);
	1327	WinSetWindowText(hwndAttr, pci -> pszDispAttr);
	1328	}
[280]	1329	if (dcd -> amextracted && hwndStatus2 && !fStatus2Used)
	1330	WinSetWindowText(hwndStatus2, GetPString(IDS_INSEEKSCANTEXT)); // Say working
[194]	1331	}
	1332	else
	1333	{
	1334	if (hwndStatus2)
	1335	WinSetWindowText(hwndStatus2, NullStr);
	1336	if (fMoreButtons)
	1337	{
	1338	WinSetWindowText(hwndName, NullStr);
	1339	WinSetWindowText(hwndDate, NullStr);
	1340	WinSetWindowText(hwndAttr, NullStr);
	1341	}
	1342	}
[2]	1343	}
[194]	1344	}
	1345	return 0;
[2]	1346
[194]	1347	case UM_CONTAINER_FILLED:
[352]	1348	DosBeep(1000, 50); // fixme to know why beep here
[194]	1349	WinSendMsg(hwnd,
	1350	CM_INVALIDATERECORD,
	1351	MPVOID,
	1352	MPFROM2SHORT(0, CMA_ERASE \| CMA_REPOSITION));
	1353	WinSendMsg(CollectorCnrMenu,
	1354	MM_SETITEMATTR,
	1355	MPFROM2SHORT(DID_CANCEL, TRUE),
	1356	MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
	1357	WinSendMsg(CollectorCnrMenu,
	1358	MM_SETITEMATTR,
	1359	MPFROM2SHORT(IDM_GREP, TRUE),
	1360	MPFROM2SHORT(MIA_DISABLED, 0));
	1361	PostMsg(hwnd,
	1362	UM_RESCAN,
	1363	MPVOID,
	1364	MPVOID);
	1365	if (dcd)
	1366	{
	1367	dcd -> stopflag = 0;
[280]	1368	dcd -> amextracted = FALSE; // Say not scanning
[194]	1369	if (dcd -> namecanchange)
	1370	{
	1371	if (!PostMsg(hwnd,
	1372	WM_CLOSE,
	1373	MPVOID,
	1374	MPVOID))
	1375	WinSendMsg(hwnd,
	1376	WM_CLOSE,
	1377	MPVOID,
	1378	MPVOID);
[2]	1379	}
[194]	1380	else
	1381	WinSetWindowPos(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
	1382	QW_PARENT),
	1383	HWND_TOP,
	1384	0,
	1385	0,
	1386	0,
	1387	0,
	1388	SWP_SHOW \| SWP_RESTORE \| SWP_ZORDER);
	1389	}
	1390	return 0;
[2]	1391
[194]	1392	case UM_SETUP:
	1393	if (dcd)
	1394	{
	1395	if (!dcd -> hwndObject)
	1396	{
	1397	/*
	1398	* first time through -- set things up
	1399	*/
[2]	1400
[194]	1401	CNRINFO cnri;
[2]	1402
[194]	1403	RestorePresParams(hwnd, "Collector");
	1404	LoadDetailsSwitches("Collector", dcd);
	1405	WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
	1406	MPFROM2SHORT(DID_CANCEL, TRUE),
	1407	MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
	1408	WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_GREP, TRUE),
	1409	MPFROM2SHORT(MIA_DISABLED, 0));
[280]	1410	dcd -> amextracted = FALSE; // Use to indicate scan busy
[194]	1411	dcd -> stopflag = 0;
	1412	memset(&cnri, 0, sizeof(CNRINFO));
	1413	cnri.cb = sizeof(CNRINFO);
	1414	WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
	1415	MPFROMLONG(sizeof(CNRINFO)));
	1416	cnri.cyLineSpacing = 0;
	1417	cnri.cxTreeIndent = 12L;
[2]	1418
[194]	1419	cnri.flWindowAttr &= (~(CV_ICON \| CV_TREE \| CV_TEXT \|
	1420	CV_DETAIL));
	1421	cnri.flWindowAttr \|= (CV_NAME \| CA_DETAILSVIEWTITLES \|
	1422	CV_MINI \| CV_FLOW);
	1423	cnri.pSortRecord = (PVOID) SortCollectorCnr;
[2]	1424
[194]	1425	{
[197]	1426	size = sizeof(ULONG);
[194]	1427	PrfQueryProfileData(fmprof, appname, "CollectorflWindowAttr",
	1428	(PVOID) & cnri.flWindowAttr, &size);
	1429	size = sizeof(MASK);
	1430	if (PrfQueryProfileSize(fmprof, appname, "CollectorFilter", &size) &&
	1431	size)
	1432	{
	1433	PrfQueryProfileData(fmprof, appname, "CollectorFilter", &dcd -> mask,
	1434	&size);
	1435	SetMask(dcd -> mask.szMask, &dcd -> mask);
	1436	}
	1437	else
	1438	{
	1439	dcd -> mask.attrFile = (FILE_NORMAL \| FILE_READONLY \|
	1440	FILE_DIRECTORY \| FILE_HIDDEN \|
	1441	FILE_SYSTEM \| FILE_ARCHIVED);
	1442	dcd -> mask.antiattr = 0;
	1443	}
	1444	*(dcd -> mask.prompt) = 0;
	1445	}
	1446	cnri.flWindowAttr \|= CV_FLOW;
	1447	cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH \| CA_ORDEREDTARGETEMPH));
	1448	dcd -> flWindowAttr = cnri.flWindowAttr;
	1449	WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
	1450	MPFROMLONG(CMA_FLWINDOWATTR \| CMA_LINESPACING \|
	1451	CMA_CXTREEINDENT \| CMA_PSORTRECORD));
	1452	SetCnrCols(hwnd, FALSE);
	1453	AdjustCnrColsForPref(hwnd, NULL, dcd, FALSE);
[2]	1454
[197]	1455	/* fix splitbar for collector container */
	1456	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
	1457	size = sizeof(LONG);
	1458	PrfQueryProfileData(fmprof, appname, "CollectorCnrSplitBar",
	1459	&cnri.xVertSplitbar, &size);
	1460	if (cnri.xVertSplitbar <= 0)
[194]	1461	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
[197]	1462	WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
	1463	MPFROMLONG(CMA_XVERTSPLITBAR));
	1464
[194]	1465	if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1)
	1466	{
[352]	1467	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
[194]	1468	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
	1469	return 0;
	1470	}
	1471	else
	1472	DosSleep(64L);
[2]	1473	}
[194]	1474	SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	1475	DIR_FILTER), &dcd -> mask, FALSE);
	1476	SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	1477	DIR_SORT), CollectorsortFlags, FALSE);
	1478	SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	1479	DIR_VIEW), dcd -> flWindowAttr);
	1480	}
	1481	else
	1482	{
	1483	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
[2]	1484	return 0;
[194]	1485	}
	1486	return 0;
[2]	1487
[194]	1488	case WM_MENUEND:
	1489	if (dcd)
	1490	{
[403]	1491	HWND hwndMenu = (HWND)mp2;
[2]	1492
[194]	1493	if (hwndMenu == CollectorCnrMenu \|\| hwndMenu == CollectorFileMenu \|\|
	1494	hwndMenu == CollectorDirMenu)
	1495	{
	1496	MarkAll(hwnd, TRUE, FALSE, TRUE);
	1497	if (dcd -> cnremphasized)
	1498	{
	1499	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
	1500	MPFROM2SHORT(FALSE, CRA_SOURCE));
	1501	dcd -> cnremphasized = FALSE;
	1502	}
[2]	1503	}
[194]	1504	}
	1505	break;
[2]	1506
[194]	1507	case UM_OPENWINDOWFORME:
	1508	if (dcd)
	1509	{
	1510	if (mp1 &&
	1511	!IsFile((CHAR *) mp1))
[280]	1512	OpenDirCnr(HWND_DESKTOP,
[194]	1513	hwndMain,
	1514	dcd -> hwndFrame,
	1515	FALSE,
	1516	(char *) mp1);
	1517	else if (mp1 &&
	1518	IsFile(mp1) == 1)
	1519	StartArcCnr(HWND_DESKTOP,
	1520	dcd -> hwndFrame,
	1521	(CHAR *) mp1,
	1522	4,
	1523	(ARC_TYPE *) mp2);
	1524	}
	1525	return 0;
[2]	1526
[194]	1527	case MM_PORTHOLEINIT:
	1528	if (dcd)
	1529	{
	1530	switch (SHORT1FROMMP(mp1))
	1531	{
	1532	case 0:
	1533	case 1:
	1534	{
	1535	ULONG wmsg;
[2]	1536
[194]	1537	wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
[403]	1538	PortholeInit((HWND)WinSendMsg(dcd -> hwndClient, wmsg, MPVOID,
[194]	1539	MPVOID), mp1, mp2);
	1540	}
	1541	break;
[2]	1542	}
[194]	1543	}
	1544	break;
[2]	1545
[194]	1546	case UM_INITMENU:
	1547	case WM_INITMENU:
	1548	if (dcd)
	1549	{
	1550	switch (SHORT1FROMMP(mp1))
	1551	{
	1552	case IDM_VIEWSMENU:
[403]	1553	SetViewMenu((HWND)mp2, dcd -> flWindowAttr);
	1554	WinEnableMenuItem((HWND)mp2, IDM_RESELECT,
[194]	1555	(dcd -> lastselection != NULL));
	1556	break;
[2]	1557
[194]	1558	case IDM_DETAILSSETUP:
[403]	1559	SetDetailsSwitches((HWND)mp2, dcd);
[194]	1560	break;
[2]	1561
[194]	1562	case IDM_COMMANDSMENU:
[403]	1563	SetupCommandMenu((HWND)mp2, hwnd);
[194]	1564	break;
[2]	1565
[194]	1566	case IDM_SORTSUBMENU:
[403]	1567	SetSortChecks((HWND)mp2, CollectorsortFlags);
[194]	1568	break;
[2]	1569	}
[403]	1570	dcd -> hwndLastMenu = (HWND)mp2;
[194]	1571	}
	1572	if (msg == WM_INITMENU)
	1573	break;
	1574	return 0;
[2]	1575
[194]	1576	case UM_COLLECTFROMFILE:
	1577	if (mp1)
	1578	{
	1579	if (dcd)
	1580	{
	1581	if (!PostMsg(dcd -> hwndObject, UM_COLLECTFROMFILE, mp1, mp2))
	1582	{
[352]	1583	Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
[194]	1584	free(mp1);
	1585	}
[2]	1586	}
	1587	else
[194]	1588	free(mp1);
	1589	}
	1590	else
	1591	free(mp1);
	1592	return 0;
[2]	1593
[194]	1594	case UM_COMMAND:
	1595	if (mp1)
	1596	{
	1597	if (dcd)
	1598	{
	1599	if (!PostMsg(dcd -> hwndObject, UM_COMMAND, mp1, mp2))
	1600	{
[352]	1601	Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
[194]	1602	FreeListInfo((LISTINFO *) mp1);
	1603	}
	1604	else
	1605	return (MRESULT) TRUE;
[2]	1606	}
[194]	1607	else
	1608	FreeListInfo((LISTINFO *) mp1);
	1609	}
	1610	return 0;
[2]	1611
[194]	1612	case UM_NOTIFY:
	1613	if (mp2)
	1614	AddNote((CHAR *) mp2);
	1615	return 0;
[2]	1616
[194]	1617	case WM_COMMAND:
	1618	DosError(FERR_DISABLEHARDERR);
	1619	if (dcd)
	1620	{
	1621	switch (SHORT1FROMMP(mp1))
	1622	{
	1623	case IDM_SETTARGET:
	1624	SetTargetDir(hwnd, FALSE);
	1625	break;
[2]	1626
[194]	1627	case IDM_CONTEXTMENU:
	1628	{
	1629	PCNRITEM pci;
[2]	1630
[194]	1631	pci = (PCNRITEM) CurrentRecord(hwnd);
	1632	PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(COLLECTOR_CNR,
	1633	CN_CONTEXTMENU), MPFROMP(pci));
	1634	}
	1635	break;
[2]	1636
[194]	1637	case IDM_SHOWALLFILES:
	1638	{
	1639	PCNRITEM pci;
[2]	1640
[194]	1641	pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
	1642	MPFROMLONG(CMA_FIRST),
	1643	MPFROMSHORT(CRA_CURSORED));
	1644	if (pci && (INT) pci != -1)
	1645	{
	1646	static CHAR dirname[CCHMAXPATH];
[2]	1647
[194]	1648	strcpy(dirname, pci -> szFileName);
	1649	MakeValidDir(dirname);
	1650	StartSeeAll(HWND_DESKTOP, FALSE, dirname);
	1651	}
	1652	}
	1653	break;
[2]	1654
[194]	1655	case IDM_BEGINEDIT:
	1656	OpenEdit(hwnd);
	1657	break;
[2]	1658
[194]	1659	case IDM_ENDEDIT:
	1660	WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
	1661	break;
[2]	1662
[194]	1663	case IDM_SHOWSELECT:
	1664	QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
	1665	IDM_SELECTSUBMENU);
	1666	break;
[2]	1667
[194]	1668	case IDM_SHOWSORT:
	1669	QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
	1670	IDM_SORTSUBMENU);
	1671	break;
[2]	1672
[194]	1673	case IDM_VIEWORARC:
	1674	{
	1675	SWP swp;
	1676	PCNRITEM pci;
[2]	1677
[194]	1678	pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
	1679	MPFROMLONG(CMA_FIRST),
	1680	MPFROMSHORT(CRA_CURSORED));
	1681	if (pci && (INT) pci != -1)
	1682	{
	1683	WinQueryWindowPos(dcd -> hwndFrame, &swp);
	1684	DefaultViewKeys(hwnd, dcd -> hwndFrame, dcd -> hwndParent, &swp,
	1685	pci -> szFileName);
	1686	}
	1687	}
	1688	break;
[2]	1689
[194]	1690	case IDM_SEEALL:
	1691	StartSeeAll(HWND_DESKTOP,
	1692	FALSE,
	1693	NULL);
	1694	break;
[2]	1695
[194]	1696	case IDM_COLLECTSELECT:
	1697	{
	1698	CHAR filename[CCHMAXPATH], p, pp;
[2]	1699
[194]	1700	strcpy(filename, "*.LST");
	1701	size = CCHMAXPATH;
	1702	PrfQueryProfileData(fmprof, appname, "SaveToListName",
	1703	filename, &size);
	1704	pp = strrchr(filename, '\\');
	1705	if (!pp)
	1706	pp = filename;
	1707	p = strrchr(pp, '.');
	1708	if (p && *(p + 1) && p > pp + 1)
	1709	{
	1710	if (pp > filename)
	1711	pp++;
	1712	pp = '';
	1713	pp++;
	1714	if (p > pp)
	1715	memmove(pp, p, strlen(p) + 1);
	1716	}
	1717	if (insert_filename(hwnd, filename, FALSE, FALSE))
	1718	{
[352]	1719	p = xstrdup(filename,pszSrcFile,__LINE__);
[194]	1720	if (p)
	1721	{
	1722	if (!PostMsg(hwnd, UM_COLLECTFROMFILE, MPFROMP(p), MPVOID))
	1723	free(p);
	1724	}
	1725	}
	1726	}
	1727	break;
[2]	1728
[194]	1729	case IDM_NOTEBOOK:
	1730	if (!ParentIsDesktop(dcd -> hwndParent, dcd -> hwndParent))
	1731	PostMsg(dcd -> hwndParent, msg, mp1, mp2);
	1732	else
	1733	WinDlgBox(HWND_DESKTOP, hwnd, CfgDlgProc, FM3ModHandle,
	1734	CFG_FRAME, (PVOID) "Collector");
	1735	break;
[2]	1736
[194]	1737	case IDM_RESELECT:
	1738	SelectList(hwnd, FALSE, FALSE, FALSE, NULL, NULL, dcd -> lastselection);
	1739	break;
[2]	1740
[194]	1741	case IDM_HELP:
	1742	if (hwndHelp)
	1743	WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
	1744	MPFROM2SHORT(HELP_COLLECT, 0),
	1745	MPFROMSHORT(HM_RESOURCEID));
	1746	break;
[2]	1747
[194]	1748	case IDM_SORTNONE:
	1749	case IDM_SORTSMARTNAME:
	1750	case IDM_SORTNAME:
	1751	case IDM_SORTFILENAME:
	1752	case IDM_SORTSIZE:
	1753	case IDM_SORTEASIZE:
	1754	case IDM_SORTFIRST:
	1755	case IDM_SORTLAST:
	1756	case IDM_SORTLWDATE:
	1757	case IDM_SORTLADATE:
	1758	case IDM_SORTCRDATE:
	1759	case IDM_SORTSUBJECT:
[197]	1760	savedSortFlags = CollectorsortFlags;
[194]	1761	CollectorsortFlags &= (SORT_REVERSE \| SORT_DIRSFIRST \| SORT_DIRSLAST);
	1762	case IDM_SORTDIRSFIRST:
	1763	case IDM_SORTDIRSLAST:
	1764	case IDM_SORTREVERSE:
	1765	switch (SHORT1FROMMP(mp1))
	1766	{
	1767	case IDM_SORTSUBJECT:
	1768	CollectorsortFlags \|= SORT_SUBJECT;
	1769	break;
	1770	case IDM_SORTNONE:
	1771	CollectorsortFlags \|= SORT_NOSORT;
	1772	break;
	1773	case IDM_SORTSMARTNAME:
[197]	1774	if (~savedSortFlags & SORT_FILENAME)
[194]	1775	CollectorsortFlags \|= SORT_FILENAME;
	1776	break;
	1777	case IDM_SORTFILENAME:
	1778	CollectorsortFlags \|= SORT_FILENAME;
	1779	break;
	1780	case IDM_SORTSIZE:
	1781	CollectorsortFlags \|= SORT_SIZE;
	1782	break;
	1783	case IDM_SORTEASIZE:
	1784	CollectorsortFlags \|= SORT_EASIZE;
	1785	break;
	1786	case IDM_SORTFIRST:
	1787	CollectorsortFlags \|= SORT_FIRSTEXTENSION;
	1788	break;
	1789	case IDM_SORTLAST:
	1790	CollectorsortFlags \|= SORT_LASTEXTENSION;
	1791	break;
	1792	case IDM_SORTLWDATE:
	1793	CollectorsortFlags \|= SORT_LWDATE;
	1794	break;
	1795	case IDM_SORTLADATE:
	1796	CollectorsortFlags \|= SORT_LADATE;
	1797	break;
	1798	case IDM_SORTCRDATE:
	1799	CollectorsortFlags \|= SORT_CRDATE;
	1800	break;
	1801	case IDM_SORTDIRSFIRST:
	1802	if (CollectorsortFlags & SORT_DIRSFIRST)
	1803	CollectorsortFlags &= (~SORT_DIRSFIRST);
	1804	else
	1805	{
	1806	CollectorsortFlags \|= SORT_DIRSFIRST;
	1807	CollectorsortFlags &= (~SORT_DIRSLAST);
	1808	}
	1809	break;
	1810	case IDM_SORTDIRSLAST:
	1811	if (CollectorsortFlags & SORT_DIRSLAST)
	1812	CollectorsortFlags &= (~SORT_DIRSLAST);
	1813	else
	1814	{
	1815	CollectorsortFlags \|= SORT_DIRSLAST;
	1816	CollectorsortFlags &= (~SORT_DIRSFIRST);
	1817	}
	1818	break;
	1819	case IDM_SORTREVERSE:
	1820	if (CollectorsortFlags & SORT_REVERSE)
	1821	CollectorsortFlags &= (~SORT_REVERSE);
	1822	else
	1823	CollectorsortFlags \|= SORT_REVERSE;
	1824	break;
	1825	}
	1826	PrfWriteProfileData(fmprof, appname, "CollectorSort",
	1827	&CollectorsortFlags, sizeof(INT));
	1828	WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
	1829	SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	1830	DIR_SORT), CollectorsortFlags, FALSE);
	1831	break;
[2]	1832
[194]	1833	case IDM_COLLECTFROMCLIP:
	1834	{
	1835	LISTINFO *li;
[2]	1836
[352]	1837	li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
[194]	1838	if (li)
	1839	{
	1840	li -> list = ListFromClipboard(hwnd);
	1841	if (!li -> list \|\| !li -> list[0])
	1842	FreeListInfo(li);
	1843	else
	1844	{
	1845	li -> type = IDM_COLLECT;
	1846	if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),
	1847	MPVOID))
	1848	FreeListInfo(li);
	1849	}
	1850	}
	1851	}
	1852	break;
[2]	1853
[194]	1854	case IDM_REMOVE:
	1855	if (fAutoView &&
	1856	hwndMain)
	1857	PostMsg(hwndMain,
	1858	UM_LOADFILE,
	1859	MPVOID,
	1860	MPVOID);
	1861	dcd -> suspendview = 1;
	1862	RemoveAll(hwnd,
	1863	&dcd -> ullTotalBytes,
	1864	&dcd -> totalfiles);
	1865	dcd -> suspendview = 0;
	1866	PostMsg(hwnd,
	1867	UM_RESCAN,
	1868	MPVOID,
	1869	MPVOID);
	1870	break;
[2]	1871
[194]	1872	case IDM_CLEARCNR:
	1873	{
	1874	PCNRITEM pci;
[2]	1875
[194]	1876	pci = (PCNRITEM) WinSendMsg(hwnd,
	1877	CM_QUERYRECORD,
	1878	MPVOID,
	1879	MPFROM2SHORT(CMA_FIRST,
	1880	CMA_ITEMORDER));
	1881	if (pci && (INT) pci != -1)
	1882	{
	1883	WinSendMsg(hwnd,
	1884	CM_REMOVERECORD,
	1885	MPVOID,
	1886	MPFROM2SHORT(0, CMA_FREE \| CMA_INVALIDATE));
	1887	dcd -> ullTotalBytes = dcd -> selectedbytes = dcd -> selectedfiles =
	1888	dcd -> totalfiles = 0L;
	1889	PostMsg(hwnd,
	1890	UM_RESCAN,
	1891	MPVOID,
	1892	MPVOID);
	1893	}
	1894	}
	1895	break;
[2]	1896
[194]	1897	case DID_CANCEL:
	1898	if (dcd -> amextracted)
[280]	1899	dcd -> stopflag = 1; // Request cancel
[194]	1900	break;
[2]	1901
[194]	1902	case IDM_COLLECTOR:
	1903	if (mp2)
	1904	{
	1905	LISTINFO *li;
[2]	1906
[352]	1907	li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
[194]	1908	if (li)
	1909	{
	1910	li -> list = mp2;
	1911	if (!li -> list \|\| !li -> list[0])
	1912	FreeListInfo(li);
	1913	else
	1914	{
	1915	li -> type = IDM_COLLECT;
	1916	if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),
	1917	MPVOID))
	1918	FreeListInfo(li);
	1919	}
	1920	}
	1921	else
	1922	FreeList(mp2);
	1923	}
	1924	break;
[2]	1925
[194]	1926	case IDM_UNDELETE:
	1927	{
	1928	PCNRITEM pci;
	1929	CHAR path[CCHMAXPATH];
[2]	1930
[194]	1931	pci = (PCNRITEM) CurrentRecord(hwnd);
	1932	if (pci)
	1933	{
	1934	strcpy(path, pci -> szFileName);
	1935	MakeValidDir(path);
	1936	WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
	1937	UNDEL_FRAME, MPFROMP(path));
	1938	}
	1939	}
	1940	break;
[2]	1941
[194]	1942	case IDM_GREP:
[352]	1943	if (dcd -> amextracted) {
	1944	// fixme to disable?
	1945	Runtime_Error(pszSrcFile, __LINE__, "busy");
	1946	}
	1947	else
[194]	1948	{
	1949	if (WinDlgBox(HWND_DESKTOP, hwnd, GrepDlgProc,
	1950	FM3ModHandle, GREP_FRAME, (PVOID) & hwnd))
	1951	{
[280]	1952	dcd -> amextracted = TRUE; // Collector scan in progress
[194]	1953	WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
	1954	MPFROM2SHORT(DID_CANCEL, TRUE),
	1955	MPFROM2SHORT(MIA_DISABLED, 0));
	1956	WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
	1957	MPFROM2SHORT(IDM_GREP, TRUE),
	1958	MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
	1959	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
	1960	}
	1961	}
	1962	break;
[2]	1963
[194]	1964	case IDM_RESORT:
	1965	WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
	1966	break;
[2]	1967
[194]	1968	case IDM_FILTER:
	1969	{
	1970	BOOL empty = FALSE;
	1971	PCNRITEM pci;
	1972	CHAR *p;
[2]	1973
[194]	1974	if (!*dcd -> mask.szMask)
	1975	{
	1976	empty = TRUE;
	1977	pci = (PCNRITEM) CurrentRecord(hwnd);
	1978	if (pci && !(pci -> attrFile & FILE_DIRECTORY))
	1979	{
	1980	p = strrchr(pci -> szFileName, '\\');
	1981	if (p)
	1982	{
	1983	p++;
	1984	strcpy(dcd -> mask.szMask, p);
	1985	}
	1986	}
	1987	}
	1988	*(dcd -> mask.prompt) = 0;
[2]	1989
[194]	1990	if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
	1991	FM3ModHandle, MSK_FRAME, MPFROMP(&dcd -> mask)))
	1992	{
[197]	1993	size = sizeof(MASK);
	1994	PrfWriteProfileData(fmprof, appname, "CollectorFilter",
	1995	&dcd -> mask, size);
[194]	1996	dcd -> suspendview = 1;
	1997	WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd -> mask));
	1998	dcd -> suspendview = 0;
	1999	if (fAutoView && hwndMain)
	2000	{
	2001	pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
	2002	MPFROMLONG(CMA_FIRST),
	2003	MPFROMSHORT(CRA_CURSORED));
	2004	if (pci && (INT) pci != -1 &&
	2005	(!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
	2006	WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName),
	2007	MPVOID);
	2008	else
	2009	WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
	2010	}
	2011	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
	2012	}
	2013	else if (empty)
	2014	*dcd -> mask.szMask = 0;
	2015	SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	2016	DIR_FILTER), &dcd -> mask, FALSE);
	2017	}
	2018	break;
[2]	2019
[194]	2020	case IDM_HIDEALL:
	2021	if (fAutoView && hwndMain)
	2022	PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
	2023	dcd -> suspendview = 1;
	2024	HideAll(hwnd);
	2025	dcd -> suspendview = 0;
	2026	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
	2027	break;
[2]	2028
[194]	2029	case IDM_SELECTLIST:
	2030	case IDM_SELECTALL:
	2031	case IDM_DESELECTALL:
	2032	case IDM_SELECTALLFILES:
	2033	case IDM_DESELECTALLFILES:
	2034	case IDM_SELECTALLDIRS:
	2035	case IDM_DESELECTALLDIRS:
	2036	case IDM_SELECTMASK:
	2037	case IDM_DESELECTMASK:
	2038	case IDM_INVERT:
	2039	case IDM_SELECTCLIP:
	2040	case IDM_DESELECTCLIP:
	2041	{
	2042	PCNRITEM pci;
[2]	2043
[194]	2044	pci = (PCNRITEM) CurrentRecord(hwnd);
	2045	if ((INT) pci == -1)
	2046	pci = NULL;
	2047	if (SHORT1FROMMP(mp1) == IDM_HIDEALL)
	2048	{
	2049	if (pci)
	2050	{
	2051	if (!(pci -> rc.flRecordAttr & CRA_SELECTED))
	2052	pci -> rc.flRecordAttr \|= CRA_FILTERED;
	2053	WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci),
	2054	MPFROM2SHORT(1, CMA_ERASE \| CMA_REPOSITION));
	2055	break;
	2056	}
	2057	}
	2058	PostMsg(dcd -> hwndObject, UM_SELECT, mp1, MPFROMP(pci));
	2059	}
	2060	break;
[2]	2061
[194]	2062	case IDM_RESCAN:
	2063	PostMsg(dcd -> hwndObject, UM_RESCAN, MPVOID, MPVOID);
	2064	break;
[2]	2065
[194]	2066	case IDM_SHOWLNAMES:
	2067	case IDM_SHOWSUBJECT:
	2068	case IDM_SHOWEAS:
	2069	case IDM_SHOWSIZE:
	2070	case IDM_SHOWICON:
	2071	case IDM_SHOWLWDATE:
	2072	case IDM_SHOWLWTIME:
	2073	case IDM_SHOWLADATE:
	2074	case IDM_SHOWLATIME:
	2075	case IDM_SHOWCRDATE:
	2076	case IDM_SHOWCRTIME:
	2077	case IDM_SHOWATTR:
	2078	AdjustDetailsSwitches(hwnd, dcd -> hwndLastMenu,
	2079	SHORT1FROMMP(mp1), NULL,
	2080	"Collector", dcd, FALSE);
	2081	break;
[2]	2082
[194]	2083	case IDM_ICON:
	2084	case IDM_TEXT:
	2085	case IDM_DETAILS:
	2086	case IDM_NAME:
	2087	case IDM_MINIICONS:
	2088	case IDM_DETAILSTITLES:
	2089	{
	2090	CNRINFO cnri;
[2]	2091
[194]	2092	memset(&cnri, 0, sizeof(CNRINFO));
	2093	cnri.cb = sizeof(CNRINFO);
	2094	WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
	2095	MPFROMLONG(sizeof(CNRINFO)));
	2096	switch (SHORT1FROMMP(mp1))
	2097	{
	2098	case IDM_ICON:
	2099	cnri.flWindowAttr &= (~(CV_ICON \| CV_TREE \| CV_TEXT \|
	2100	CV_DETAIL \| CV_NAME));
	2101	cnri.flWindowAttr \|= CV_ICON;
	2102	break;
	2103	case IDM_NAME:
	2104	cnri.flWindowAttr &= (~(CV_ICON \| CV_TREE \| CV_TEXT \|
	2105	CV_DETAIL \| CV_NAME));
	2106	cnri.flWindowAttr \|= CV_NAME;
	2107	break;
	2108	case IDM_TEXT:
	2109	cnri.flWindowAttr &= (~(CV_ICON \| CV_TREE \| CV_TEXT \|
	2110	CV_DETAIL \| CV_NAME));
	2111	cnri.flWindowAttr \|= CV_TEXT;
	2112	break;
	2113	case IDM_DETAILS:
	2114	cnri.flWindowAttr &= (~(CV_ICON \| CV_TREE \| CV_TEXT \|
	2115	CV_DETAIL \| CV_NAME));
	2116	cnri.flWindowAttr \|= CV_DETAIL;
	2117	break;
	2118	case IDM_MINIICONS:
	2119	if (cnri.flWindowAttr & CV_MINI)
	2120	cnri.flWindowAttr &= (~CV_MINI);
	2121	else
	2122	cnri.flWindowAttr \|= CV_MINI;
	2123	break;
	2124	case IDM_DETAILSTITLES:
	2125	if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
	2126	cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
	2127	else
	2128	cnri.flWindowAttr \|= CA_DETAILSVIEWTITLES;
	2129	break;
	2130	}
	2131	cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH \|
	2132	CA_MIXEDTARGETEMPH));
	2133	cnri.flWindowAttr \|= CV_FLOW;
	2134	dcd -> flWindowAttr = cnri.flWindowAttr;
	2135	PrfWriteProfileData(fmprof, appname, "CollectorflWindowAttr",
	2136	&cnri.flWindowAttr, sizeof(ULONG));
	2137	WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
	2138	MPFROMLONG(CMA_FLWINDOWATTR));
	2139	WinSendMsg(hwnd, CM_INVALIDATERECORD, MPVOID,
	2140	MPFROM2SHORT(0, CMA_ERASE \| CMA_REPOSITION));
	2141	SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	2142	DIR_VIEW), dcd -> flWindowAttr);
	2143	}
	2144	break;
[2]	2145
[194]	2146	case IDM_SAVETOLIST:
	2147	WinDlgBox(HWND_DESKTOP, hwnd, SaveListDlgProc, FM3ModHandle,
	2148	SAV_FRAME, MPFROMP(&hwnd));
	2149	break;
[2]	2150
[194]	2151	case IDM_SIZES:
	2152	{
	2153	PCNRITEM pci;
[2]	2154
[194]	2155	pci = (PCNRITEM) CurrentRecord(hwnd);
	2156	if (pci && (INT) pci != -1)
	2157	WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, DirSizeProc, FM3ModHandle,
	2158	DSZ_FRAME, pci -> szFileName);
	2159	}
	2160	break;
[2]	2161
[194]	2162	case IDM_MKDIR:
	2163	{
	2164	PCNRITEM pci;
[2]	2165
[194]	2166	pci = (PCNRITEM) CurrentRecord(hwnd);
	2167	PMMkDir(dcd -> hwndParent, (pci && (INT) pci != -1) ?
	2168	pci -> szFileName : NULL, FALSE);
	2169	}
	2170	break;
[2]	2171
[194]	2172	case IDM_DOITYOURSELF:
	2173	case IDM_UPDATE:
	2174	case IDM_COLLECTFROMFILE:
	2175	case IDM_OPENWINDOW:
	2176	case IDM_OPENSETTINGS:
	2177	case IDM_OPENDEFAULT:
	2178	case IDM_OPENICON:
	2179	case IDM_OPENDETAILS:
	2180	case IDM_OPENTREE:
	2181	case IDM_OBJECT:
	2182	case IDM_SHADOW:
	2183	case IDM_SHADOW2:
	2184	case IDM_DELETE:
	2185	case IDM_PERMDELETE:
	2186	case IDM_PRINT:
	2187	case IDM_ATTRS:
	2188	case IDM_INFO:
	2189	case IDM_COPY:
	2190	case IDM_MOVE:
	2191	case IDM_WPSCOPY:
	2192	case IDM_WPSMOVE:
	2193	case IDM_COPYPRESERVE:
	2194	case IDM_MOVEPRESERVE:
	2195	case IDM_WILDCOPY:
	2196	case IDM_WILDMOVE:
	2197	case IDM_RENAME:
	2198	case IDM_COMPARE:
	2199	case IDM_EAS:
	2200	case IDM_SUBJECT:
	2201	case IDM_VIEW:
	2202	case IDM_VIEWTEXT:
	2203	case IDM_VIEWBINARY:
	2204	case IDM_VIEWARCHIVE:
	2205	case IDM_EDIT:
	2206	case IDM_EDITTEXT:
	2207	case IDM_EDITBINARY:
	2208	case IDM_SAVETOCLIP:
	2209	case IDM_APPENDTOCLIP:
	2210	case IDM_ARCHIVE:
	2211	case IDM_ARCHIVEM:
	2212	case IDM_EXTRACT:
	2213	case IDM_MCIPLAY:
	2214	case IDM_UUDECODE:
	2215	case IDM_MERGE:
	2216	{
	2217	LISTINFO *li;
	2218	ULONG action = UM_ACTION;
[2]	2219
[352]	2220	li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
[194]	2221	if (li)
	2222	{
	2223	li -> type = SHORT1FROMMP(mp1);
	2224	li -> hwnd = hwnd;
	2225	li -> list = BuildList(hwnd);
	2226	if (li -> list)
	2227	{
	2228	switch (SHORT1FROMMP(mp1))
	2229	{
	2230	case IDM_DOITYOURSELF:
	2231	case IDM_APPENDTOCLIP:
	2232	case IDM_SAVETOCLIP:
	2233	case IDM_ARCHIVE:
	2234	case IDM_ARCHIVEM:
	2235	case IDM_DELETE:
	2236	case IDM_PERMDELETE:
	2237	case IDM_ATTRS:
	2238	case IDM_PRINT:
	2239	case IDM_SHADOW:
	2240	case IDM_SHADOW2:
	2241	case IDM_OBJECT:
	2242	case IDM_VIEW:
	2243	case IDM_VIEWTEXT:
	2244	case IDM_VIEWBINARY:
	2245	case IDM_EDIT:
	2246	case IDM_EDITTEXT:
	2247	case IDM_EDITBINARY:
	2248	case IDM_MCIPLAY:
	2249	case IDM_UPDATE:
	2250	case IDM_INFO:
	2251	case IDM_EAS:
	2252	action = UM_MASSACTION;
	2253	break;
	2254	}
	2255	if (li -> type == IDM_SHADOW \|\| li -> type == IDM_OBJECT \|\|
	2256	li -> type == IDM_SHADOW2)
	2257	*li -> targetpath = 0;
	2258	if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li),
	2259	MPVOID))
	2260	{
[352]	2261	Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
[194]	2262	FreeListInfo(li);
	2263	}
	2264	else if (fUnHilite)
	2265	UnHilite(hwnd, TRUE, &dcd -> lastselection);
	2266	}
	2267	else
	2268	free(li);
	2269	}
	2270	}
	2271	break;
[2]	2272
[194]	2273	default:
	2274	if (!cmdloaded)
	2275	load_commands();
	2276	if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
	2277	SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART)
	2278	{
	2279	INT x;
[2]	2280
[194]	2281	x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
	2282	if (x >= 0)
	2283	{
	2284	x++;
	2285	RunCommand(hwnd, x);
	2286	if (fUnHilite)
	2287	UnHilite(hwnd, TRUE, &dcd -> lastselection);
	2288	}
	2289	}
	2290	break;
	2291	}
	2292	}
	2293	return 0;
[2]	2294
[194]	2295	case UM_FIXCNRMLE:
	2296	case UM_FIXEDITNAME:
	2297	return CommonCnrProc(hwnd, msg, mp1, mp2);
[2]	2298
[194]	2299	case UM_FILESMENU:
	2300	{
	2301	PCNRITEM pci;
[403]	2302	HWND menuHwnd = (HWND)0;
[2]	2303
[194]	2304	pci = (PCNRITEM) CurrentRecord(hwnd);
	2305	if (pci && (INT) pci != -1)
	2306	{
	2307	if (pci -> attrFile & FILE_DIRECTORY)
	2308	menuHwnd = CheckMenu(&CollectorDirMenu, COLLECTORDIR_POPUP);
	2309	else
	2310	menuHwnd = CheckMenu(&CollectorFileMenu, COLLECTORFILE_POPUP);
[2]	2311	}
[194]	2312	return MRFROMLONG(menuHwnd);
	2313	}
[2]	2314
[194]	2315	case WM_CONTROL:
	2316	DosError(FERR_DISABLEHARDERR);
	2317	if (dcd)
	2318	{
	2319	switch (SHORT2FROMMP(mp1))
[2]	2320	{
[194]	2321	case CN_CONTEXTMENU:
	2322	{
	2323	PCNRITEM pci = (PCNRITEM) mp2;
[2]	2324
[194]	2325	if (pci)
	2326	{
	2327	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
	2328	MPFROM2SHORT(TRUE, CRA_CURSORED));
	2329	MarkAll(hwnd, FALSE, FALSE, TRUE);
	2330	if (pci -> attrFile & FILE_DIRECTORY)
	2331	dcd -> hwndLastMenu = CheckMenu(&CollectorDirMenu,
	2332	COLLECTORDIR_POPUP);
	2333	else
	2334	dcd -> hwndLastMenu = CheckMenu(&CollectorFileMenu,
	2335	COLLECTORFILE_POPUP);
	2336	}
	2337	else
	2338	{
	2339	dcd -> hwndLastMenu = CheckMenu(&CollectorCnrMenu,
	2340	COLLECTORCNR_POPUP);
	2341	if (dcd -> hwndLastMenu && !dcd -> cnremphasized)
	2342	{
	2343	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
	2344	MPFROM2SHORT(TRUE, CRA_SOURCE));
	2345	dcd -> cnremphasized = TRUE;
	2346	}
	2347	}
	2348	if (dcd -> hwndLastMenu)
	2349	{
	2350	if (dcd -> hwndLastMenu == CollectorCnrMenu)
	2351	{
	2352	SetViewMenu(dcd -> hwndLastMenu, dcd -> flWindowAttr);
	2353	SetDetailsSwitches(dcd -> hwndLastMenu, dcd);
	2354	if (dcd -> flWindowAttr & CV_MINI)
	2355	WinCheckMenuItem(dcd -> hwndLastMenu, IDM_MINIICONS, TRUE);
	2356	}
	2357	if (!PopupMenu(hwnd, hwnd, dcd -> hwndLastMenu))
	2358	{
	2359	if (dcd -> cnremphasized)
	2360	{
	2361	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
	2362	MPFROM2SHORT(FALSE, CRA_SOURCE));
	2363	dcd -> cnremphasized = TRUE;
	2364	}
	2365	MarkAll(hwnd, TRUE, FALSE, TRUE);
	2366	}
	2367	}
	2368	}
	2369	break;
[2]	2370
[194]	2371	case CN_DROPHELP:
	2372	if (mp2)
	2373	{
	2374	PDRAGINFO pDInfo;
	2375	PCNRITEM pci;
	2376	ULONG numitems;
	2377	USHORT usOperation;
[2]	2378
[194]	2379	pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
	2380	pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
	2381	if (!DrgAccessDraginfo(pDInfo))
	2382	{
[352]	2383	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
[194]	2384	"%s",
	2385	GetPString(IDS_DROPERRORTEXT));
	2386	break;
	2387	}
	2388	numitems = DrgQueryDragitemCount(pDInfo);
	2389	usOperation = pDInfo -> usOperation;
	2390	DrgDeleteDraginfoStrHandles(pDInfo);
	2391	DrgFreeDraginfo(pDInfo);
	2392	saymsg(MB_ENTER \| MB_ICONASTERISK,
	2393	hwnd,
	2394	GetPString(IDS_DROPHELPHDRTEXT),
	2395	GetPString(IDS_DROPHELPTEXT),
	2396	numitems,
	2397	&"s"[numitems == 1L],
	2398	(pci) ? NullStr : GetPString(IDS_NOTEXT),
	2399	(pci) ? NullStr : " ",
	2400	(pci) ? pci -> szFileName : NullStr,
	2401	(pci) ? " " : NullStr,
	2402	GetPString((usOperation == DO_COPY) ?
	2403	IDS_COPYTEXT :
	2404	(usOperation == DO_LINK) ?
	2405	IDS_LINKTEXT : IDS_MOVETEXT));
	2406	}
	2407	return 0;
[2]	2408
[194]	2409	case CN_DRAGLEAVE:
	2410	if (mp2)
	2411	{
	2412	PDRAGINFO pDInfo;
[2]	2413
[194]	2414	pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
	2415	DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
	2416	DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
	2417	}
	2418	return 0;
[2]	2419
[194]	2420	case CN_DRAGAFTER:
	2421	case CN_DRAGOVER:
	2422	if (mp2)
	2423	{
	2424	PDRAGITEM pDItem; /* Pointer to DRAGITEM */
	2425	PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
	2426	PCNRITEM pci;
	2427	USHORT uso;
[2]	2428
[194]	2429	pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
[2]	2430	// if(SHORT1FROMMP(mp1) == CN_DRAGAFTER)
[194]	2431	// pci = NULL;
	2432	pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
	2433	DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
	2434	if (pci)
	2435	{
	2436	if (pci -> rc.flRecordAttr & CRA_SOURCE)
	2437	{
	2438	DrgFreeDraginfo(pDInfo);
	2439	return (MRFROM2SHORT(DOR_NODROP, 0));
	2440	}
	2441	uso = pDInfo -> usOperation;
	2442	if (uso == DO_DEFAULT)
	2443	uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
	2444	if (!(pci -> attrFile & FILE_DIRECTORY))
	2445	{
	2446	if (uso != DO_LINK && uso != DO_MOVE &&
	2447	uso != DO_COPY)
	2448	{
	2449	DrgFreeDraginfo(pDInfo);
	2450	return MRFROM2SHORT(DOR_NODROP, 0);
	2451	}
	2452	if (uso != DO_LINK &&
	2453	!(driveflags[toupper(*pci -> szFileName) - 'A'] &
	2454	DRIVE_NOTWRITEABLE))
	2455	{
	2456	ARC_TYPE *info = NULL;
[2]	2457
[194]	2458	if (!fQuickArcFind &&
	2459	!(driveflags[toupper(*pci -> szFileName) - 'A'] &
	2460	DRIVE_SLOW))
	2461	info = find_type(pci -> szFileName, NULL);
	2462	else
	2463	info = quick_find_type(pci -> szFileName, NULL);
	2464	if (!info \|\| ((uso == DO_MOVE && !info -> move) \|\|
	2465	(uso == DO_COPY && !info -> create)))
	2466	{
	2467	DrgFreeDraginfo(pDInfo);
	2468	return MRFROM2SHORT(DOR_NODROP, 0);
	2469	}
	2470	}
	2471	}
	2472	}
	2473	pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
	2474	0); /* Index to DRAGITEM */
	2475	if (DrgVerifyRMF(pDItem, /* Check valid rendering */
	2476	DRM_OS2FILE, /* mechanisms and data */
	2477	NULL))
	2478	{
	2479	DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
	2480	if (pci)
	2481	{
	2482	if (driveflags[toupper(*pci -> szFileName) - 'A'] &
	2483	DRIVE_NOTWRITEABLE)
	2484	return MRFROM2SHORT(DOR_DROP, DO_LINK);
	2485	if (toupper(*pci -> szFileName) < 'C')
	2486	return MRFROM2SHORT(DOR_DROP, DO_COPY);
	2487	return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
	2488	((fCopyDefault) ?
	2489	DO_COPY :
	2490	DO_MOVE));
	2491	}
	2492	else
	2493	return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
	2494	DO_COPY);
	2495	}
	2496	DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
	2497	}
	2498	return (MRFROM2SHORT(DOR_NODROP, 0)); /* Drop not valid */
[2]	2499
[194]	2500	case CN_INITDRAG:
	2501	if (mp2)
	2502	{
	2503	BOOL wasemphasized = FALSE;
	2504	PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
	2505	PCNRITEM pci;
[2]	2506
[194]	2507	if (pcd)
	2508	{
	2509	pci = (PCNRITEM) pcd -> pRecord;
	2510	if (pci)
	2511	{
	2512	if (pci -> rc.flRecordAttr & CRA_SELECTED)
	2513	wasemphasized = TRUE;
	2514	if (IsRoot(pci -> szFileName))
	2515	break;
	2516	if (hwndStatus2)
	2517	WinSetWindowText(hwndStatus2,
	2518	GetPString(IDS_DRAGFILEOBJTEXT));
	2519	if (DoFileDrag(hwnd,
	2520	dcd -> hwndObject,
	2521	mp2,
	2522	NULL,
	2523	NULL,
	2524	TRUE))
	2525	{
	2526	if (fUnHilite && wasemphasized)
	2527	UnHilite(hwnd, TRUE, &dcd -> lastselection);
	2528	}
	2529	if (hwndStatus2)
	2530	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
	2531	}
	2532	}
	2533	}
	2534	return 0;
[2]	2535
[194]	2536	case CN_DROP:
	2537	if (mp2)
	2538	{
	2539	LISTINFO *li;
	2540	ULONG action = UM_ACTION;
[2]	2541
[194]	2542	li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
	2543	if (li)
	2544	{
	2545	if (!*li -> targetpath)
	2546	{
	2547	li -> type = IDM_COLLECT;
	2548	action = UM_COLLECT;
	2549	}
	2550	else
	2551	{
	2552	if (li -> list && li -> list[0] && IsRoot(li -> list[0]))
	2553	li -> type = DO_LINK;
	2554	else if (fDragndropDlg && (!*li -> arcname \|\| !li -> info))
	2555	{
	2556	CHECKLIST cl;
[2]	2557
[194]	2558	memset(&cl, 0, sizeof(cl));
	2559	cl.size = sizeof(cl);
	2560	cl.flags = li -> type;
	2561	cl.list = li -> list;
	2562	cl.cmd = li -> type;
	2563	cl.prompt = li -> targetpath;
	2564	li -> type = WinDlgBox(HWND_DESKTOP, dcd -> hwndParent,
	2565	DropListProc, FM3ModHandle,
	2566	DND_FRAME, MPFROMP(&cl));
	2567	if (!li -> type)
	2568	{
	2569	FreeListInfo(li);
	2570	return 0;
	2571	}
	2572	li -> list = cl.list;
	2573	if (!li -> list \|\| !li -> list[0])
	2574	{
	2575	FreeListInfo(li);
	2576	return 0;
	2577	}
	2578	}
	2579	switch (li -> type)
	2580	{
	2581	case DND_LAUNCH:
	2582	strcat(li -> targetpath, " %a");
	2583	ExecOnList(dcd -> hwndParent, li -> targetpath,
	2584	PROMPT \| WINDOWED, NULL, li -> list, NULL);
	2585	FreeList(li -> list);
	2586	li -> list = NULL;
	2587	break;
	2588	case DO_LINK:
	2589	if (fLinkSetsIcon)
	2590	{
	2591	li -> type = IDM_SETICON;
	2592	action = UM_MASSACTION;
	2593	}
	2594	else
	2595	li -> type = IDM_COMPARE;
	2596	break;
	2597	case DND_EXTRACT:
	2598	if (*li -> targetpath && !IsFile(li -> targetpath))
	2599	li -> type = IDM_EXTRACT;
	2600	break;
	2601	case DND_MOVE:
	2602	li -> type = IDM_MOVE;
	2603	if (*li -> targetpath && IsFile(li -> targetpath) == 1)
	2604	{
	2605	action = UM_MASSACTION;
	2606	li -> type = IDM_ARCHIVEM;
	2607	}
	2608	break;
	2609	case DND_WILDMOVE:
	2610	li -> type = IDM_WILDMOVE;
	2611	if (*li -> targetpath && IsFile(li -> targetpath) == 1)
	2612	{
	2613	action = UM_MASSACTION;
	2614	li -> type = IDM_ARCHIVEM;
	2615	}
	2616	break;
	2617	case DND_OBJECT:
	2618	li -> type = IDM_OBJECT;
	2619	action = UM_MASSACTION;
	2620	break;
	2621	case DND_SHADOW:
	2622	li -> type = IDM_SHADOW;
	2623	action = UM_MASSACTION;
	2624	break;
	2625	case DND_COMPARE:
	2626	li -> type = IDM_COMPARE;
	2627	break;
	2628	case DND_SETICON:
	2629	action = UM_MASSACTION;
	2630	li -> type = IDM_SETICON;
	2631	break;
	2632	case DND_WILDCOPY:
	2633	li -> type = IDM_WILDCOPY;
	2634	if (*li -> targetpath && IsFile(li -> targetpath) == 1)
	2635	{
	2636	action = UM_MASSACTION;
	2637	li -> type = IDM_ARCHIVE;
	2638	}
	2639	break;
	2640	case DND_COPY:
	2641	li -> type = IDM_COPY;
	2642	if (*li -> targetpath && IsFile(li -> targetpath) == 1)
	2643	{
	2644	action = UM_MASSACTION;
	2645	li -> type = IDM_ARCHIVE;
	2646	}
	2647	break;
	2648	default:
	2649	if (*li -> arcname && li -> info)
	2650	{
	2651	action = UM_MASSACTION;
	2652	li -> type = (li -> type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
	2653	}
	2654	else if (*li -> targetpath && IsFile(li -> targetpath) == 1)
	2655	{
	2656	action = UM_MASSACTION;
	2657	li -> type = (li -> type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
	2658	}
	2659	else
	2660	li -> type = (li -> type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
	2661	break;
	2662	}
	2663	}
	2664	if (!li -> list \|\| !li -> list[0])
	2665	FreeListInfo(li);
	2666	else if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li), MPVOID))
	2667	FreeListInfo(li);
	2668	else
	2669	{
	2670	USHORT usop = 0;
[2]	2671
[194]	2672	switch (li -> type)
	2673	{
	2674	case IDM_COPY:
	2675	case IDM_WILDCOPY:
	2676	usop = DO_COPY;
	2677	break;
	2678	case IDM_MOVE:
	2679	case IDM_WILDMOVE:
	2680	case IDM_ARCHIVEM:
	2681	usop = DO_MOVE;
	2682	break;
	2683	}
	2684	if (usop)
	2685	return MRFROM2SHORT(DOR_DROP, usop);
	2686	}
	2687	}
	2688	}
	2689	return 0;
[2]	2690
[194]	2691	case CN_BEGINEDIT:
	2692	case CN_REALLOCPSZ:
	2693	case CN_ENDEDIT:
	2694	{
	2695	MRESULT mre;
[2]	2696
[194]	2697	mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
	2698	if (mre != (MRESULT) - 1)
	2699	return mre;
	2700	}
	2701	break;
[2]	2702
[194]	2703	case CN_EMPHASIS:
	2704	if (mp2)
	2705	{
	2706	PNOTIFYRECORDEMPHASIS pre = mp2;
	2707	PCNRITEM pci;
	2708	CHAR s[CCHMAXPATH + 91], tb[81], tf[81], *p;
[2]	2709
[194]	2710	pci = (PCNRITEM) ((pre) ? pre -> pRecord : NULL);
	2711	if (!pci)
	2712	{
	2713	if (hwndStatus2)
	2714	WinSetWindowText(hwndStatus2, NullStr);
	2715	if (fMoreButtons)
	2716	{
	2717	WinSetWindowText(hwndName, NullStr);
	2718	WinSetWindowText(hwndDate, NullStr);
	2719	WinSetWindowText(hwndAttr, NullStr);
	2720	}
	2721	if (hwndMain)
	2722	WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
	2723	break;
	2724	}
	2725	if (pre -> fEmphasisMask & CRA_SELECTED)
	2726	{
	2727	if (pci -> rc.flRecordAttr & CRA_SELECTED)
	2728	{
	2729	dcd -> selectedbytes += (pci -> cbFile + pci -> easize);
	2730	dcd -> selectedfiles++;
	2731	}
	2732	else if (dcd -> selectedfiles)
	2733	{
	2734	dcd -> selectedbytes -= (pci -> cbFile + pci -> easize);
	2735	dcd -> selectedfiles--;
	2736	}
	2737	if (!dcd -> suspendview)
	2738	{
	2739	commafmt(tf, sizeof(tf), dcd -> selectedfiles);
	2740	CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
	2741	sprintf(s, "%s / %s", tf, tb);
	2742	WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
	2743	}
	2744	}
[280]	2745	if (!dcd -> suspendview &&
	2746	WinQueryActiveWindow(dcd -> hwndParent) == dcd -> hwndFrame)
[194]	2747	{
	2748	if (pre -> fEmphasisMask & CRA_CURSORED)
	2749	{
	2750	if (pci -> rc.flRecordAttr & CRA_CURSORED)
	2751	{
	2752	if (fSplitStatus && hwndStatus2)
[155]	2753	{
[194]	2754	if (pci -> attrFile & FILE_DIRECTORY)
	2755	p = pci -> pszFileName;
	2756	else
	2757	{
	2758	p = strrchr(pci -> szFileName, '\\');
	2759	if (p)
	2760	{
	2761	if (*(p + 1))
	2762	p++;
	2763	else
	2764	p = pci -> pszFileName;
	2765	}
	2766	else
	2767	p = pci -> pszFileName;
	2768	}
	2769	CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
	2770	if (!fMoreButtons)
	2771	sprintf(s, " %s %04u/%02u/%02u %02u:%02u:%02u [%s] %s",
	2772	tb, pci -> date.year,
	2773	pci -> date.month, pci -> date.day, pci -> time.hours,
	2774	pci -> time.minutes, pci -> time.seconds,
	2775	pci -> pszDispAttr, p);
	2776	else
	2777	{
	2778	if (pci -> cbFile + pci -> easize > 1024)
	2779	CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, ' ');
	2780	else
	2781	*tf = 0;
	2782	sprintf(s, GetPString(IDS_STATUSSIZETEXT),
	2783	tb,
	2784	*tf ? " (" : NullStr,
	2785	tf,
	2786	*tf ? ")" : NullStr);
	2787	}
	2788	WinSetWindowText(hwndStatus2, s);
	2789	}
	2790	if (fMoreButtons)
	2791	{
	2792	WinSetWindowText(hwndName, pci -> pszFileName);
	2793	sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
	2794	pci -> date.year, pci -> date.month,
	2795	pci -> date.day, pci -> time.hours, pci -> time.minutes,
	2796	pci -> time.seconds);
	2797	WinSetWindowText(hwndDate, s);
	2798	WinSetWindowText(hwndAttr, pci -> pszDispAttr);
	2799	}
	2800	}
	2801	}
	2802	}
	2803	if (!dcd -> suspendview && hwndMain &&
	2804	(pre -> fEmphasisMask & CRA_CURSORED) &&
	2805	(pci -> rc.flRecordAttr & CRA_CURSORED) &&
	2806	WinQueryActiveWindow(dcd -> hwndParent) == dcd -> hwndFrame)
	2807	WinSendMsg(hwndMain, UM_LOADFILE,
	2808	MPFROMP(((fComments \|\| (pci -> attrFile & FILE_DIRECTORY) == 0) ?
	2809	pci -> szFileName : NULL)), MPVOID);
	2810	}
	2811	break;
[2]	2812
[194]	2813	case CN_ENTER:
	2814	if (mp2)
	2815	{
	2816	PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2) -> pRecord;
	2817	FILEFINDBUF3 ffb;
	2818	HDIR hDir = HDIR_CREATE;
	2819	ULONG nm = 1L;
	2820	APIRET status = 0;
[2]	2821
[194]	2822	SetShiftState();
	2823	if (pci)
	2824	{
	2825	if (pci -> rc.flRecordAttr & CRA_INUSE)
	2826	break;
	2827	DosError(FERR_DISABLEHARDERR);
	2828	status = DosFindFirst(pci -> szFileName, &hDir,
	2829	FILE_NORMAL \| FILE_DIRECTORY \|
	2830	FILE_ARCHIVED \| FILE_READONLY \|
	2831	FILE_HIDDEN \| FILE_SYSTEM,
	2832	&ffb, sizeof(ffb), &nm,
	2833	FIL_STANDARD);
	2834	priority_bumped();
	2835	if (!status)
	2836	{
	2837	DosFindClose(hDir);
	2838	if (ffb.attrFile & FILE_DIRECTORY)
	2839	{
	2840	if ((shiftstate & (KC_CTRL \| KC_ALT)) ==
	2841	(KC_CTRL \| KC_ALT))
	2842	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0),
	2843	MPVOID);
	2844	else if ((shiftstate & (KC_CTRL \| KC_SHIFT)) ==
	2845	(KC_CTRL \| KC_SHIFT))
	2846	OpenObject(pci -> szFileName, Settings, dcd -> hwndFrame);
	2847	else if (shiftstate & KC_CTRL)
	2848	OpenObject(pci -> szFileName, Default, dcd -> hwndFrame);
	2849	else
[280]	2850	OpenDirCnr(HWND_DESKTOP,
[194]	2851	hwndMain,
	2852	dcd -> hwndFrame,
	2853	FALSE,
	2854	pci -> szFileName);
	2855	}
	2856	else
	2857	{
	2858	SWP swp;
[2]	2859
[194]	2860	WinSendMsg(hwnd,
	2861	CM_SETRECORDEMPHASIS,
	2862	MPFROMP(pci),
	2863	MPFROM2SHORT(TRUE, CRA_INUSE));
	2864	WinQueryWindowPos(dcd -> hwndFrame, &swp);
	2865	DefaultViewKeys(hwnd,
	2866	dcd -> hwndFrame,
	2867	dcd -> hwndParent,
	2868	&swp,
	2869	pci -> szFileName);
	2870	WinSendMsg(hwnd,
	2871	CM_SETRECORDEMPHASIS,
	2872	MPFROMP(pci),
	2873	MPFROM2SHORT(FALSE, CRA_INUSE \|
	2874	((fUnHilite) ? CRA_SELECTED : 0)));
	2875	}
	2876	}
	2877	else
	2878	WinSendMsg(hwnd,
	2879	CM_REMOVERECORD,
	2880	MPFROMP(&pci),
	2881	MPFROM2SHORT(1,
	2882	CMA_FREE \| CMA_INVALIDATE \| CMA_ERASE));
	2883	}
	2884	}
	2885	break;
[2]	2886	}
[194]	2887	}
	2888	return 0;
[2]	2889
[194]	2890	case UM_LOADFILE:
	2891	if (dcd && mp2)
	2892	{
	2893	HWND ret;
[2]	2894
[194]	2895	ret = StartMLEEditor(dcd -> hwndParent,
	2896	(INT) mp1,
	2897	(CHAR *) mp2,
	2898	dcd -> hwndFrame);
	2899	if (mp2)
	2900	free((CHAR *) mp2);
	2901	return MRFROMLONG(ret);
	2902	}
	2903	return 0;
[2]	2904
[194]	2905	case UM_CLOSE:
	2906	WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
	2907	QW_PARENT));
	2908	return 0;
[2]	2909
[194]	2910	case UM_FOLDUP:
[403]	2911	if (!PostMsg((HWND)0, WM_QUIT, MPVOID, MPVOID))
[194]	2912	DosExit(EXIT_PROCESS, 1);
	2913	return 0;
[2]	2914
[194]	2915	case WM_CLOSE:
	2916	if (dcd)
	2917	{
	2918	dcd -> namecanchange = TRUE;
	2919	dcd -> stopflag = 1;
	2920	if (dcd -> amextracted)
[280]	2921	return 0; // Can not close yet
[194]	2922	}
	2923	WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
	2924	if (dcd)
	2925	{
	2926	if (!dcd -> dontclose && ParentIsDesktop(hwnd, dcd -> hwndParent))
	2927	PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
	2928	if (dcd -> hwndObject)
	2929	{
	2930	DosSleep(64L);
	2931	if (!PostMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID))
	2932	WinSendMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID);
[2]	2933	}
[194]	2934	}
	2935	else
	2936	WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
	2937	return 0;
[2]	2938
[194]	2939	case WM_DESTROY:
	2940	if (CollectorDirMenu)
	2941	WinDestroyWindow(CollectorDirMenu);
	2942	if (CollectorFileMenu)
	2943	WinDestroyWindow(CollectorFileMenu);
	2944	if (CollectorCnrMenu)
	2945	WinDestroyWindow(CollectorCnrMenu);
[403]	2946	CollectorCnrMenu = CollectorFileMenu = CollectorDirMenu = (HWND)0;
	2947	Collector = (HWND)0;
[194]	2948	EmptyCnr(hwnd);
	2949	break;
[2]	2950	}
[194]	2951	return (dcd && dcd -> oldproc) ? dcd -> oldproc(hwnd, msg, mp1, mp2) :
	2952	PFNWPCnr(hwnd, msg, mp1, mp2);
[2]	2953	}
	2954
[194]	2955	HWND StartCollector(HWND hwndParent, INT flags)
[155]	2956	{
[403]	2957	HWND hwndFrame = (HWND)0;
[197]	2958	HWND hwndClient;
[194]	2959	ULONG FrameFlags = FCF_TITLEBAR \| FCF_SYSMENU \|
[197]	2960	FCF_SIZEBORDER \| FCF_MINMAX \|
	2961	FCF_ICON \| FCF_NOBYTEALIGN \|
	2962	FCF_ACCELTABLE;
[194]	2963	USHORT id;
	2964	DIRCNRDATA *dcd;
[2]	2965
[197]	2966	static USHORT idinc = 0;
	2967
[194]	2968	if (ParentIsDesktop(hwndParent, hwndParent))
[2]	2969	FrameFlags \|= (FCF_TASKLIST \| FCF_SHELLPOSITION \| FCF_MENU);
[194]	2970	if (Collector)
	2971	{
[2]	2972	WinSetWindowPos(WinQueryWindow(WinQueryWindow(Collector,
[194]	2973	QW_PARENT),
	2974	QW_PARENT),
	2975	HWND_TOP,
	2976	0,
	2977	0,
	2978	0,
	2979	0,
	2980	SWP_SHOW \| SWP_RESTORE);
[2]	2981	return WinQueryWindow(WinQueryWindow(Collector,
[194]	2982	QW_PARENT),
	2983	QW_PARENT);
[2]	2984	}
	2985	hwndFrame = WinCreateStdWindow(hwndParent,
[194]	2986	WS_VISIBLE,
	2987	&FrameFlags,
	2988	GetPString(IDS_WCCOLLECTOR),
	2989	NULL,
	2990	WS_VISIBLE \| fwsAnimate,
	2991	FM3ModHandle,
	2992	COLLECTOR_FRAME,
	2993	&hwndClient);
	2994	if (hwndFrame && hwndClient)
	2995	{
[2]	2996	id = COLLECTOR_FRAME + idinc++;
[194]	2997	WinSetWindowUShort(hwndFrame, QWS_ID, id);
[352]	2998	dcd = xmallocz(sizeof(DIRCNRDATA),pszSrcFile,__LINE__);
[377]	2999	if (!dcd) {
	3000	Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
	3001	PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
[403]	3002	hwndFrame = (HWND)0;
[377]	3003	}
	3004	else {
[194]	3005	dcd -> size = sizeof(DIRCNRDATA);
	3006	dcd -> id = id;
	3007	dcd -> type = COLLECTOR_FRAME;
	3008	dcd -> hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
	3009	dcd -> hwndFrame = hwndFrame;
	3010	dcd -> hwndClient = hwndClient;
	3011	if (flags & 4)
	3012	dcd -> dontclose = TRUE;
[2]	3013	{
[194]	3014	PFNWP oldproc;
[2]	3015
[194]	3016	oldproc = WinSubclassWindow(hwndFrame,
	3017	(PFNWP) CollectorFrameWndProc);
	3018	WinSetWindowPtr(hwndFrame,
	3019	QWL_USER,
	3020	(PVOID) oldproc);
[2]	3021	}
[194]	3022	dcd -> hwndCnr = WinCreateWindow(hwndClient,
	3023	WC_CONTAINER,
	3024	NULL,
	3025	CCS_AUTOPOSITION \| CCS_MINIICONS \|
	3026	CCS_MINIRECORDCORE \| ulCnrType \|
	3027	WS_VISIBLE,
	3028	0,
	3029	0,
	3030	0,
	3031	0,
	3032	hwndClient,
	3033	HWND_TOP,
	3034	(ULONG) COLLECTOR_CNR,
	3035	NULL,
	3036	NULL);
[377]	3037	if (!dcd -> hwndCnr) {
	3038	Win_Error2(hwndClient,hwndClient,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
	3039	PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
	3040	free(dcd);
[403]	3041	hwndFrame = (HWND)0;
[377]	3042	}
	3043	else {
[194]	3044	Collector = dcd -> hwndCnr;
	3045	WinSetWindowPtr(dcd -> hwndCnr, QWL_USER, (PVOID) dcd);
	3046	WinSetWindowText(hwndFrame,
	3047	GetPString(IDS_COLLECTORTITLETEXT));
	3048	if (FrameFlags & FCF_MENU)
	3049	{
	3050	if (!fToolbar)
	3051	{
	3052	HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
[2]	3053
[194]	3054	if (hwndMenu)
	3055	{
	3056	WinSendMsg(hwndMenu,
	3057	MM_DELETEITEM,
	3058	MPFROM2SHORT(IDM_SEEALL, FALSE),
	3059	MPVOID);
	3060	WinSendMsg(hwndMenu,
	3061	MM_DELETEITEM,
	3062	MPFROM2SHORT(IDM_GREP, FALSE),
	3063	MPVOID);
	3064	WinSendMsg(hwndMenu,
	3065	MM_DELETEITEM,
	3066	MPFROM2SHORT(IDM_CLEARCNR, FALSE),
	3067	MPVOID);
	3068	WinSendMsg(hwndMenu,
	3069	MM_DELETEITEM,
	3070	MPFROM2SHORT(IDM_REMOVE, FALSE),
	3071	MPVOID);
	3072	}
	3073	}
	3074	}
	3075	dcd -> oldproc = WinSubclassWindow(dcd -> hwndCnr,
	3076	(PFNWP) CollectorCnrWndProc);
	3077	{
	3078	USHORT ids[] =
	3079	{DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
	3080	DIR_FILTER, 0};
[2]	3081
[194]	3082	CommonCreateTextChildren(dcd -> hwndClient,
	3083	GetPString(IDS_WCCOLSTATUS),
	3084	ids);
	3085	}
	3086	if (FrameFlags & FCF_SHELLPOSITION)
	3087	PostMsg(hwndClient,
	3088	UM_SIZE,
	3089	MPVOID,
	3090	MPVOID);
	3091	if (!PostMsg(dcd -> hwndCnr,
	3092	UM_SETUP,
	3093	MPVOID,
	3094	MPVOID))
	3095	WinSendMsg(dcd -> hwndCnr,
	3096	UM_SETUP,
	3097	MPVOID,
	3098	MPVOID);
[2]	3099	}
	3100	}
	3101	}
	3102	return hwndFrame;
	3103	}

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

Download in other formats: