Context Navigation

source: trunk/dll/treecnr.c@ 1875

Visit:

Last change on this file since 1875 was 1875, checked in by Gregg Young, 10 years ago
Move the eUnflesh call from UM_ENTER to the object window so WaitFleshWorkListEmpty can be used (UM_ENTER is on TID 1); Prevent eUnflesh from running if no child directories are present; treat floppies like invalid drives on rescan (IDM_UPDATE to avoid them seen as directories and having random subdirectories attached to them.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 101.2 KB

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

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

Download in other formats: