Context Navigation

source: trunk/dll/collect.c@ 283

Visit:

Last change on this file since 283 was 280, checked in by root, 20 years ago
Sanitize handle references CollectorCnrWndProc: avoid excess writes to Status2 window CollectorCnrWndProc: correct missing button window updates
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 71.9 KB

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

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

Download in other formats: