Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

treecnr.c

Visit:

Last change on this file was 1912, checked in by Gregg Young, 14 months ago
One more attempt to fix the tree container corruption on scan/rescan
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 98.4 KB

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

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

Context Navigation

source: trunk/dll/treecnr.c

Download in other formats: