Context Navigation

source: trunk/dll/collect.c@ 975

Visit:

Last change on this file since 975 was 958, checked in by Gregg Young, 18 years ago
Add Unhide menu option every place that has hide (Ticket 218). Use additional xfrees where appropriate.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 75.7 KB

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

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

Download in other formats: