Context Navigation

source: trunk/dll/collect.c@ 145

Visit:

Last change on this file since 145 was 145, checked in by root, 20 years ago
Rework Win_Error usage
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 97.2 KB

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

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

Download in other formats: