Context Navigation

source: trunk/dll/treecnr.c@ 1078

Visit:

Last change on this file since 1078 was 1078, checked in by Steven Levine, 17 years ago
More Fortify infrastructure enhancements Rework Fortify_SetOwner Add Fortify_BecomeOwner Avoid more spurious leak reports
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 82.3 KB

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

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

Download in other formats: