Context Navigation

source: trunk/dll/treecnr.c@ 672

Visit:

Last change on this file since 672 was 672, checked in by Steven Levine, 18 years ago
Use dcd->ulItemsToUnHilite Sync UnHilite calls with arg mods
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 77.9 KB

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

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

Download in other formats: