Context Navigation

source: trunk/dll/treecnr.c@ 1876

Visit:

Last change on this file since 1876 was 1876, checked in by Gregg Young, 10 years ago
Eliminate some unnecessary Flesh and UnFlesh calls.Update icon and display name on CD/DVD eject in all cases. Don't use Flesh thread for floppy drive scans fix them getting mistakenly identified as directories and add nonexistent subdirectories.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 101.4 KB

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

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

Download in other formats: