Context Navigation

source: trunk/dll/treecnr.c@ 1102

Visit:

Last change on this file since 1102 was 1102, checked in by Gregg Young, 17 years ago
Make the variable passed to treecnr UM_RESCAN a pointer to a temp variable every where to avoid freeing pci->pszFileName or dcd->directory early
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 82.9 KB

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

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

Download in other formats: