Context Navigation

source: trunk/dll/treecnr.c@ 636

Visit:

Last change on this file since 636 was 618, checked in by Steven Levine, 19 years ago
Add more drag/drop error checking Use FreeDragInfoData Sync with NumItemsToUnhilite AcceptOneDrop GetOneDrop mods
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 77.6 KB

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

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

Download in other formats: