Context Navigation

source: trunk/dll/collect.c@ 188

Visit:

Last change on this file since 188 was 186, checked in by root, 20 years ago
Use QWL_USER
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 97.0 KB

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

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

Download in other formats: