Context Navigation

source: trunk/dll/collect.c@ 444

Visit:

Last change on this file since 444 was 444, checked in by root, 19 years ago
Don't write garbage to CollectorFilter INI entry Rework SetMask args CollectorCnrWndProc: avoid freeing NULL pointer
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 72.2 KB

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

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

Download in other formats: